【go从入门到精通】go基本类型和运算符用法

大家好，这是我给大家准备的新的一期专栏，专门讲golang，从入门到精通各种框架和中间件，工具类库，希望对go有兴趣的同学可以订阅此专栏。

---------------------------------------------------------------------------------------------------------------------------------

上一篇文章中【go从入门到精通】go包，内置类型和初始化顺序偏重概念和知识，想必大家都对如何开始写代码已经开始蠢蠢欲动了，但是不要着急，基础知识扎实，能让你少走很多弯道。

基本数据类型

正如前一篇的内容，go的基本数据类型和其他语言都差不多，我们可以先看看go是如何声明变量的。

标准声明

Go语言的变量声明格式为：

    var 变量名 变量类型

变量声明以关键字var开头，变量类型放在变量的后面，行尾无需分号。举个例子：

    var str string var i   int32var b   bool

批量声明

每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明：

    var (a stringb intc boold float32)

变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，例如：整型和浮点型变量的默认值为0。字符串变量的默认值为空字符串。布尔型变量默认为false。切片、函数、指针变量的默认为nil。

当然我们也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下：

    var 变量名 类型 = 表达式

举个例子：

    var a int32 = 1

类型推导
有时候我们会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

var str = "pprof.cn"
var i = 1
短变量声明
在函数内部，可以使用更简略的 := 方式声明并初始化变量。

package mainimport ("fmt"
)func main() {var i = 10j := 100fmt.Println(i,j)
}

匿名变量
在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量。匿名变量用一个下划线_表示，例如我希望通过strconv。Atoi来将数字字符串转整型数字，由于这个函数有2个返回值，我只想用i接收最终的整型变量，用_来作为匿名变量，可以用下面的代码来实现：

package mainimport ("fmt""strconv"
)func main() { i,_:=strconv.Atoi("100")fmt.Println(i)
}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。 (在Lua等编程语言里，匿名变量也被叫做哑元变量。)

注意事项：

函数外的每个语句都必须以关键字开始（var、const、func等）

:=不能使用在函数外。

_多用于占位，表示忽略值。

const常量的初始化

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。

const pi = 3.1415

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。例如：

const (
n1 = 100
n2
n3
)
上面示例中，常量n1、n2、n3的值都是100。

其他注意的

但是这里要注意的一些区别是：

（1）空指针值 nil ：

package mainimport ("fmt"
) 
func main(){i := 0p := &i if p == nil {fmt.Println("p is nil")} 
}

（2）多行字符串的输出方式：

Go语言中要定义一个多行字符串时，就必须使用反引号字符：

package mainimport ("fmt"
) 
func main(){s := `thisisgolangprogram`fmt.Println(s)
}

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

（3）byte和rune类型

组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。字符用单引号（’）包裹起来，如：

Go 语言的字符有以下两种：

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。

rune类型，代表一个 UTF-8字符。

    var a := '啊'var b := 'b'

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。
Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾

package mainimport ("fmt"
)func disp() {s := "hello 你好"for i := 0; i < len(s); i++ { //bytefmt.Printf("%v(%c) ", s[i], s[i])}fmt.Println("")for _, r := range s { //runefmt.Printf("%v(%c) ", r, r)}
}
func main() {disp()
}

输出：

104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 228(ä) 189(½) 160( ) 229(å) 165(¥) 189(½)
104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 20320(你) 22909(好)

因为UTF8编码下一个中文汉字由3-4个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行的结果。

字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。

我们有时候会有这样的需求，判断某个游戏玩家起的昵称不能超过10个汉字或者字符，那么我想你这个时候就知道用哪种方式了。

（4）修改字符串

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

package main
import ("fmt"
)func modstring1(s string) {// 强制类型转换bytes := []byte(s)bytes[0] = 'H'fmt.Println(string(bytes))
}
func modstring2(s string) {// 强制类型转换bytes := []rune(s)bytes[0] = '你'fmt.Println(string(bytes))
}
func main() {s := "hello"modstring1(s)modstring2(s)
}

（5）array数组

go的数组array是同一种数据类型的固定长度的序列。

（1）如何定义一个数组呢？我们可以用： var 数组名 [长度]，不过你要注意的是长度也是数组类型的一部分。
比如：

var a [10]int 和var a [100]int是不同的类型

var arr0 [5]int = [5]int{1, 2, 3} // 未初始化元素值为 0。

c := [5]int{2: 100, 4: 200} // 使用索引号初始化元素。

var arr2 = [...]int{1, 2, 3, 4, 5, 6} // 通过初始化值确定数组长度。

（2）数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1

遍历数组有两种方式：

for i := 0; i < len(a); i++ {
}
for index, v := range a {
}

（3）访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic

package mainimport "fmt"func main() {a := [3]int{1, 2, 3}b := a[0]c := a[6]fmt.Println(b, c)
}

运行时报错信息如下：

PS E:\project\go\hello> ./main.exe
panic: runtime error: index out of range [6] with length 3goroutine 1 [running]:
main.main()E:/project/go/hello/main.go:8 +0x1d

（4）数组是值类型，赋值和传参会复制整个数组，而不是指针。因此改变副本的值，不会改变本身的值。

此时此刻，一定有人想做下验证，于是写了如下代码：

package mainimport "fmt"func fun1(a []int) {a[0] = 100
}
func main() {a := []int{1, 2, 3}fun1(a)fmt.Println(a[0])
}

这段代码似乎是想修改数组a的第一个元素的值，但是很不幸，你可能认为调用fun1之后，a的第一个元素的值仍然是1。

为什么呢? 因为你传的不是数组，而且切片。数组是指定了长度，且是值传递而切片是没有指定长度，且是引用传递。所以你的代码改成这样就没有问题了：

package mainimport "fmt"func fun1(a [3]int) {a[0] = 100
}
func main() {a := [3]int{1, 2, 3}fun1(a)fmt.Println(a[0])
}

（6）slice和map

后边逐步针对这slIce,map,以及和数组的三者之间的比较差异来细细道来。

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

强制类型转换的基本语法如下：

目标类型(表达式)
其中，目标类型表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.

package mainimport ("fmt"
)func main() {i := int32(0)var j intj = i fmt.Println(j) 
}

比如这段代码，简简单单，但是编译的时候报错：

cannot use i (variable of type int32) as int value in assignment

所以我们在把i赋值给j的时候，需要做个类型强制转换，j = int(i)

运算符

go的常用的运算符用法和其他语言没有区别