Golang(二)基本语法 Golang(二)基本语法

变量与常量什么是变量变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。
声明变量 var名称类型是声明单个变量的语法。
以字母或下划线开头，由一个或多个字母、数字、下划线组成。
声明一个变量
第一种，指定变量类型，声明后若不赋值，使用默认值

var name type name = value

第二种，根据值自行判定变量类型(类型推断Type inference)
如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。因此，如果变量具有初始值，则可以省略变量声明中的类型。

var name = value

第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量)，否则会导致编译错误(简短声明)

name := value// 例如 var a int = 10 var b = 10 c : = 10

这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值

示例

package main var a = "Hello" var b string = "World" var c boolfunc main(){ println(a, b, c) }

结果

Hello World false

多变量声明
第一种，以逗号分隔，声明与赋值分开，若不赋值，存在默认值

var name1, name2, name3 type name1, name2, name3 = v1, v2, v3

第二种，直接赋值，下面的变量类型可以是不同的类型

var name1, name2, name3 = v1, v2, v3

第三种，集合类型

var ( name1 type1 name2 type2 )

注意事项
如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。
如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。
如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：

func main() { var a string = "abc" fmt.Println("hello, world") }

尝试编译这段代码将得到错误 a declared and not used
此外，单纯地给 a 赋值也是不够的，这个值必须被使用
在同一个作用域中，已存在同名的变量，则之后的声明初始化，则退化为赋值操作。但这个前提是，最少要有一个新的变量被定义，且在同一作用域，例如，下面的y就是新定义的变量

package mainimport ( "fmt" )func main() { x := 140 fmt.Println(&x) x, y := 200, "abc" fmt.Println(&x, x) fmt.Print(y) }

结果

0xc04200a2b0 0xc04200a2b0 200 abc

空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃
_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值
并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)
常量声明常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
不曾使用的常量，在编译的时候，是不会报错的
显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值

const identifier [type] = value

显式类型定义： const b string = "abc" 隐式类型定义： const b = "abc"

package mainimport "fmt"func main() { const LENGTH int = 10 const WIDTH int = 5 var area int const a, b, c = 1, false, "str" //多重赋值area = LENGTH * WIDTH fmt.Printf("面积为 : %d", area) println() println(a, b, c) }

结果

面积为 : 50 1 false str

常量可以作为枚举

const ( Unknown = 0 Female = 1 Male = 2 )

常量组中如不指定类型和初始化值，则与上一行非空常量右值相同

package mainimport ( "fmt" )func main() { const ( x uint16 = 16 y s = "abc" z ) fmt.Printf("%T,%v\n", y, y) fmt.Printf("%T,%v\n", z, z) }

结果

uint16,16 string,abc

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

在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1

iota 可以被用作枚举值：

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

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

const ( a = iota b c )

iota 用法

package mainimport "fmt"func main() { const ( a = iota//0 b//1 c//2 d = "ha"//独立值，iota += 1 e//"ha"iota += 1 f = 100//iota +=1 g//100iota +=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

如果中断iota自增，则必须显式恢复。且后续自增值按行序递增
自增默认是int类型，可以自行进行显示指定类型
数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址
基本数据类型以下是go中可用的基本数据类型

文章图片
布尔型bool 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true
数值型整型

int8 有符号 8 位整型 (-128 到 127)
int16 有符号 16 位整型 (-32768 到 32767)
int32 有符号 32 位整型 (-2147483648 到 2147483647)
int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
uint8 无符号 8 位整型 (0 到 255)
uint16 无符号 16 位整型 (0 到 65535)
uint32 无符号 32 位整型 (0 到 4294967295)
uint64 无符号 64 位整型 (0 到 18446744073709551615)

int:根据底层平台，表示32或64位整数。除非需要使用特定大小的整数，否则通常应该使用int来表示整数。大小:32位系统32位，64位系统64位。范围:-2147483648到2147483647的32位系统和-9223372036854775808到9223372036854775807的64位系统。

浮点型

float32

IEEE-754 32位浮点型数

float64

IEEE-754 64位浮点型数

complex64

32 位实数和虚数

complex128

64 位实数和虚数
其他

byte

类似 uint8

rune

类似 int32

uint

32 或 64 位

与 uint 一样大小

uintptr

无符号整型，用于存放一个指针
字符串型字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本

var str string str = "Hello World"

运算符算术运算符

+ - * / %(求余) ++ --

关系运算符

== != > < >= <=

逻辑运算符

运算符	描述
&&	所谓逻辑与运算符。如果两个操作数都非零，则条件变为真
丨丨	所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真
!	所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假

位运算符

A	B	A&B	A丨B	A^B
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

这里最难理解的就是^了，只要认为AB两者都相同的时候，为0，其他都为1

运算	描述	示例
&	二进制与操作副本位的结果，如果它存在于两个操作数	(A & B) = 12, 也就是 0000 1100
丨	二进制或操作副本，如果它存在一个操作数	(A 丨 B) = 61, 也就是 0011 1101
^	二进制异或操作副本，如果它被设置在一个操作数但不能同时是比特	(A ^ B) = 49, 也就是 0011 0001
?	二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数	A ? 2 will give 240 也就是 1111 0000
?	二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动	A ? 2 = 15 也就是 0000 1111

赋值运算符

运算符	描述	示例
=	简单的赋值操作符，分配值从右边的操作数左侧的操作数	C = A + B 将分配A + B的值到C
+=	相加并赋值运算符，它增加了右操作数左操作数和分配结果左操作数	C += A 相当于 C = C + A
-=	减和赋值运算符，它减去右操作数从左侧的操作数和分配结果左操作数	C -= A 相当于 C = C - A
*=	乘法和赋值运算符，它乘以右边的操作数与左操作数和分配结果左操作数	C = A is equivalent to C = C A
/=	除法赋值运算符，它把左操作数与右操作数和分配结果左操作数	C /= A 相当于 C = C / A
%=	模量和赋值运算符，它需要使用两个操作数的模量和分配结果左操作数	C %= A 相当于 C = C % A
?=	左移位并赋值运算符	C ?= 2 相同于 C = C ? 2
?=	向右移位并赋值运算符	C ?= 2 相同于 C = C ? 2
&=	按位与赋值运算符	C &= 2 相同于 C = C & 2
^=	按位异或并赋值运算符	C ^= 2 相同于 C = C ^ 2
丨=	按位或并赋值运算符	C 丨= 2 相同于 C = C 丨 2