go语言一——基础

参考《Go_web_编程.pdf》

See Also:

Go 语言简介（上）— 语法

Go 语言简介（下）— 特性

首先编写一个简单的脚本hello.go

/*
* 定义包名
*  main    表示可独立运行
*  [other] 编译生成.a文件
*/
package main
/*
* 引入系统级别包 fmt
*/
import "fmt"
// main.main 是每一个可执行程序的入口点
func main() {
        fmt.Printf("Hello, world or 你好,世界 or こんにちは世界\n")
}

运行方式如下：

> go run hello.go #直接运行脚本
Hello World
>
> go build hello.go #编译生成可执行文件或库文件
//generate hello
>
> go clean #删除

变量定义

package main
import "fmt"

// var vname type = value, 一般用var关键字定义全局变量
var g_val1 int32 = 100

//:= 赋值方式只能在函数体内用，不能用来创建全局变量
//g_val2 := 100


// 常量定义
const cint = 1
const cint2 int = 1
const cstr string = "hello"
const cstr2 = `hello` // 字符串用双引号或者反引号表示，不能用单引号

// 声明未使用全局变量编译运行不报错
var bval bool

func main(){
        fmt.Printf("Global g_val1 = %v\n",g_val1)

        // var vname1,vname2 type
        var l_val1, l_val2 float32 = 1.2, 2.3
        fmt.Printf("Local l_val1 = %v , l_val2 = %v\n",l_val1,l_val2)

        // vname1,vname2 := value1,value2
        l_val3, l_val4 := 2.3, 4
        fmt.Printf("Local l_val3 = %v , l_val4 = %v\n",l_val3,l_val4)

        // 声明未使用局部变量在编译阶段会报错
        //var l_val5 int
}

数据类型

package main

//分组声明
import(
        "fmt"
        "errors"
)

const(
        i = 0
        s = "测试"
)

func main(){

        //不同数据类型之间不能直接转换,尽管长度一样
        var(
                a int = 3
                b int32
                c rune = 4
        )
        b = a //error
        b = c //ok
        //cannot use a (type int) as type int32 in assignment

        //字符串拼接用"+"号
        name := "你" + "好"
        name = "世界"

        fmt.Printf("name = %v\n",name)
        //输出"世界"

        err := errors.New("自定义错误信息\n")
        if err != nil {
                fmt.Print(err)
                //输出 "自定义错误信息"
        }
}

Go 之所以会那么简洁,是因为它有一些默认的行为:
•大写字母开头的变量是可导出的,也就是其它包可以读取的,是公用变量;小写字母开头的就是不可导出的,是私有变量。
•大写字母开头的函数也是一样,相当于 class 中的带 public 关键词的公有函数;小写字母开头的就是有 private 关键词的私有函数

数组操作

package main

//分组声明
import(
    "fmt"
    //引用的包未使用时编译会出错
    //"errors"
)

func main(){

    //数组声明
    var arr [10] int
    arr[0] = 3
    fmt.Printf("arr[0] = %v and arr[4] = %v\n",arr[0],arr[4])
    //输出 3 和 0

    arr2 := [10]string{"name","age"}
    arr2[0] = "nickname"
    fmt.Printf("arr2[0] = %v and arr2[4] = %v\n",arr2[0],arr2[4])
    //输出 nickname 和 空

    //多维数组
    doubleArray := [2][4]int{[4]int{1,2,3,4},[4]int{5,6,7,8}}
    fmt.Printf("doubleArray[0][0] = %v\n",doubleArray[0][0])
    easyArray := [2][4]int{{1,2,3,4},{5,6,7,8}}
    fmt.Printf("easyArray[0][1] = %v\n",easyArray[0][1])

    arr3 := [5]int{1,3,5,7,9}
    //动态数组slice，定义时缺少长度
    var sarr1,sarr2 []int
    sarr1 = arr3[2:3] // sarr1 = {5}
    sarr2 = arr3[1:] // sarr2 = {3,5,7,9}
    fmt.Printf("sarr1[0] = %v\n",sarr1[0])
    fmt.Printf("sarr2[0] = %v\n",sarr2[0])
    
    fmt.Printf("len(sarr1) = %v\n",len(sarr1)) // 获取数组长度
    fmt.Printf("cap(sarr1) = %v\n",cap(sarr1)) // 获取数组最大个数

    sarr1 = append(sarr1,6) // 追加数据 sarr1 = {5,6}
    fmt.Printf("sarr1[1] = %v\n",sarr1[1])

    sarr2 = sarr2[:len(sarr2)-1] // 删除末尾元素
}

arr := []string{str1}

slice 有一些简便的操作
• slice 的默认开始位置是 0,ar[:n]等价于 ar[0:n]
• slice 的第二个序列默认是数组的长度,ar[n:]等价于 ar[n:len(ar)]
• 如果从一个数组里面直接获取 slice,可以这样 ar[:],因为默认第一个序列是 0,第二个是数组的长度,即等价于 ar[0:len(ar)]

package main

import(
        "fmt"
)

func main(){

        var (
                m_val1 map[string] string
        )
        //声明字典后需要调用make初始化
        m_val1 = make(map[string] string)
        m_val1["name"] = "ciaos"
        m_val1["hobby"] = "game"
        fmt.Printf("name is %v and hobby is %v\n",m_val1["name"],m_val1["hobby"])

        m_val2 := make(map[string] int)

        m_val2["first"] = 10
        fmt.Println("字典内容为:","first => ", m_val2["first"])
        // 输出 "字典内容为: first => 10"

        // 初始化一个字典
        m_val3 := map[string] int{"A":1,"B":2,"C":3}
        fmt.Println("length of m_val3 is",len(m_val3))

        // 获取指定key对应alue
        num,ok := m_val3["D"]
        if ok {
                fmt.Println("m_val3[\"D\"] is ",num)
        } else {
                fmt.Println("m_val3[\"D\"] is invalid")
        }

        delete(m_val3,"B")
}

使用 map 过程中需要注意的几点:
• map 是无序的,每次打印出来的 map 都会不一样,它不能通过 index 获取,而必须通过 key 获取
• map 的长度是不固定的,也就是和 slice 一样,也是一种引用类型内置的 len 函数同样适用于 map,返回 map 拥有的 key 的数量
• map 的值可以很方便的修改,通过 numbers["one"]=11 可以很容易的把 key 为 one的字典值改为 11
• map 的初始化可以通过 key:val 的方式初始化值,同时 map 内置有判断是否存在 key 的方式
make 用于内建类型(map、slice 和 channel)的内存分配。new 用于各种类型的内存分配