Go语言笔记1-基本数据类型和语法

初学笔记，有误请多见谅，随着学习的深入会丰富和更新

特点

简洁、快速、安全
并行、有趣、开源
内存管理、数组安全、编译迅速

主要特性

自动垃圾回收
更丰富的内置类型
函数多返回值
错误处理
匿名函数和闭包
类型和接口
并发编程
反射
语言交互性

语言用途

一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言
提供了海量并行的支持，适合游戏服务端的开发

执行程序

程序基本组成

package main  //包声明

import "fmt"  //引入包

func main() {  //函数
   // 注释  /* 第一个简单的程序 */
   fmt.Println("Hello, World!")  
   //变量  
   //语句 & 表达式
}

需要注意’{'不能单独一行

执行程序有两种方式

• go run filename.go
• go build filename.go生成二进制文件filename
  ./filename

关于包

文件名与包名没有直接关系，不一定要将文件名与包名定成同一个。
文件夹名与包名没有直接关系，并非需要一致。
同一个文件夹下的文件只能有一个包名，否则编译报错。

数据类型

布尔类型

true or false:

var b bool = true;

数字类型

整型 int 和浮点型 float32、float64

字符串类型

Go 的字符串是由单个字节连接起来的
Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本

派生类型

• 指针类型（Pointer）
• 数组类型
• 结构化类型(struct)
• Channel 类型
• 函数类型
• 切片类型
• 接口类型（interface）
• Map 类型

语法

声明变量

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字：

var identifier type

简单例子

var a int //没有初始化就为零值，bool零值为false，string为空串
var b int = 32
var c, d int //声明多个变量
var str1 string = “str”
e := 10 //如果省略var，变量必须是新声明的，并且只能在函数体中出现

多变量声明

类型相同多个变量, 非全局变量

var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

和 python 很像,不需要显示声明类型，自动推断

var vname1, vname2, vname3 = v1, v2, v3

出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误

vname1, vname2, vname3 := v1, v2, v3

这种因式分解关键字的写法一般用于声明全局变量

var (
    vname1 v_type1
    vname2 v_type2
 )

值类型和引用类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值
使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝
（可以理解为深拷贝）

一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置
这个内存地址称之为指针，这个指针实际上也被存在另外的某一个值中

当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。
如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容
（可以理解为浅拷贝）

可以像python一样直接交换两个变量的值：

a, b = b, a

空白标识符

空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
_ 实际上是一个只写变量，不能得到它的值。这样做是因为 Go 语言中必须使用所有被声明的变量，但有时并不需要使用从一个函数得到的所有返回值。
比如：

package main

import "fmt"

func main() {
  _,numb,strs := numbers() //只获取函数返回值的后两个
  fmt.Println(numb,strs)
}

//一个可以返回多个值的函数
func numbers()(int,int,string){
  a , b , c := 1 , 2 , "str"
  return a,b,c
}

最后输出结果为2 str

并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。

常量

常量定义

常量的定义格式：

const identifier [type] = value

可以省略[type]，编译器会自动推断
显式类型定义： const b string = “abc”
隐式类型定义： const b = “abc”

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

const (
    a = iota
    b = iota
    c = iota
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

实例：

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
    // 0 1 2 ha ha 100 100 7 8
}

左移实例：

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println(i,j,k,l)
    // 1 6 12 24
}

iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

简单表述:

i=1：左移 0 位,不变仍为 1;
j=3：左移 1 位,变为二进制 110, 即 6;
k=3：左移 2 位,变为二进制 1100, 即 12;
l=3：左移 3 位,变为二进制 11000,即 24。

注：<<n==*(2^n)。

运算符

和C++类似的（可能所有语言都类似）：

位运算符

赋值运算符

其他运算符

条件语句

除了if, if…else, if嵌套和switch之外，还有select
select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

go没有三目运算符

循环语句

for, for嵌套
控制：break, continue, goto