Go语言基础语法

---

---

---

一、注释

• 我们在写代码的时候会有这种情况时长发生，刚写完的代码，觉得逻辑很清晰，自己怎么这么厉害，过一段时间再去看这个代码，就会产牛疑问，这个代码到底TM谁写的！所以为了防止自己看不懂自己的代码，或者你想把你写的代码给别人看，这个时候，我们就需要汗释了！

注释：你可以理解为写给人看的，机器并不会去执行这行语句。

• 注释主要的功能就是为了增强代码的可读性,不参与程序的一切功能,Go语言的注释主要分成两类。

1.单行注释

package main
// 双斜杠表示单行注释，程序不会执行这行语句，这是写给自己或他人看的
import "fmt"func main() {fmt.Printf("helloword!")
}

2.多行注释

package main
/*杠星 星杠表示多行注释，在二者之间的范围内可以换行写多行注释
*/
import "fmt"/*这是一个main函数，这是go语言启动的入口
*/
func main() {// fmt.Printfln:打印一行内容，然后执行完成后进行换行fmt.Printfln("hello,word!")
}

养成写注释是一个良好的习惯，方便自己阅读，也方便他人阅读

二、变量

• 在数学概念中，变量表示没有固定值且可改变的数。比如 x=1，x= 2；
• 字面上的意思理解：变量就是会变化的量。
• 比如我定一个了一个变量叫做名字，它在Go语言中是这样表示的：这个值既可以是张三，也可以是李四，也可以是王五，也可以是你的名字。那么在这里，这个name就是变量，可以变化的量。

// 这里的等于是赋值，就是把等号右边的值，赋值给左边变量的意思
var name string = "guan"

在这里除了name之外，我们还写了其他的东西，比如 var、string 这些都是干嘛的呢，接下来就来带大家了解下go 语言中的变量的定义以及go 语言的一些数据类型（比如上面的 name 名字，它就是一个字符串类型的，我们有时候还需要表示数字，所以还会存在数字类型等，后面进一步了解）。

1.变量的定义

• Go语言是静态类型语言,就是所有的类型我们都需要明确的去定义。这里先不管其他类型,先了解string,用它来表示字符半。
• 在Go语言中,我们声明一个变量一般足使用 var关键字:

var name type

• 第一个 var 是声明变量的关键字，是固定的写法，声明一个变量，就需要一个var。
• 第二个 name，就是变量的名字，你可以按照自己的需求给它定 个名字，用来后续使用。
• 第二个 type，就是用来代表变量的类型。

举个栗子：

// 定义一个字符串变量，name
var name string
// 定义一个数字类型变量 age
var age int

如果之前学过Jva, C或者其他编程语言,第一次看到这样的操作肯人不舒服。Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后,这样做的处就是可以避免像C语言那样合糊不清的声明形式,例如: int *a, b; 其中只有 a 是指针而b不是。如过想要这两个变量都是指针变量，则需要将分开书写。而在Go中，则可以和轻松地将们都声明为用钊类型：

var a,b *int

变量的命名规则遵循骆驼命名命法, 即首个单词小写,每个新单词的首字母大写,例如: helloWord 和 guanGuan。 .

变量定义的标准格式为

var 变量名 变量类型

变量声明以关键字 var 开头，后置变量类型，行尾无须分号。

我们有时候会批量定义变量，如果每次都单独定义比较麻烦，Go语言文持批量定义变量使用关键了 var 和括号，可以将一组变量定义放在一起。

	var (name stringage  intaddr string)

形式的声明语句往往是用于需要显式指定变量类型地方,或者因为变量稍后会被重新赋值而初始值大关紧要的地方。当一个变量被声明之后，如果没有显示的给他赋值，系统自动赋予它该类型的零值：

• 整型和浮点型变量的默认值为 0 和 0.0
• 字符串变量的默认值为空字符串。
• 布尔类型变量默认值为 false。
• 切片、函数、指针变量的默认为 null

fmt.Printf(name, age, addr)

2.变量的初始化

变量初始化的标准格式

var 变量名 类型 = 值（表达式）

比如，我想定义guan的一些信息，我可以这么表示

var name string = "guan"
var age int = 18fmt.Printf("name:%s,age:%d", name, age)

这里的 name 和 age 就是变量名，name 的类型为 string， age 的类型为 int。他们的值分别为 guan 和 18

短变量声明并初始化

name := "guanGuan"
age :=18fmt.Printf("name:%s,age:%d", name, age)

这是Go语言的推导声明写法，编译器会自动根据右值类型推断出左值的对应类型。它可以自动的推导出一些类型，但是使用也是有限制的；

• 定义变量，同时显式初始化。
• 不能提供数据类型。
• 只能用在函数内部。不能随便到处定义

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。

注意：由于使用了：=，而不是赋值的=，因此推导声明写法的左值变量必须是没有被定义过的变量。若定义过，将会发生编译错误。

// 定义变量 name
var name string
// 定义变量 name，并赋值为"guanGuan"
name := "guanGuan"

编译会报错，信息如下：no new variables on left side of :=意思是，在“：=”的左边没有新变量出现，意思就是“：=”的左边变量已经被声明了。

3.理解变量（内存地址）

	var num intnum = 1000fmt.Printf("num的值：%d,内存地址:%p\n", num, &num)num = 2000fmt.Printf("num的值：%d,内存地址:%p\n", num, &num)

4.变量交换

package mainimport "fmt"func main() {/*在编程中，最简单的算法就是变量的交换，但是一般常见的方式就是定义中间变量var a int = 100var b int = 2oovar t intt = aa = ba = tfmt.Println(a,b)*/var a int = 100var b int = 200fmt.Printf("交换前的变量a=%d,b=%d\n", a, b)// 在Go语言中，可以直接用这样的方式实现值得交换，无需中间变量b, a = a, bfmt.Printf("交换后的变量a=%d,b=%d", a, b)}

输出

5.匿名变量

匿名变量的特点是一个下画线””，““本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。使用匿名变量时,只需要在变量声明的地方使用下画线替换即可。

例如:

package mainimport "fmt"
/*
定义一个test函数，它会返回两个int类型的值，每次调用将会返叵 100 和 200 两个数值、这里我们先不只管 函数的定义，后面会讲解。89我们用这个函数来理解这个匿名变量。
*/
func test()(int, int) {return 100, 200
}
func main(){a,_:= test()_, b := test()fmt.Println(a, b) //输出的结果100,200// 在第一行代码巾，我们只需要获取第一个返叵值，所以第二个返回值定义为匿名交量// 在第二行代码巾，我们只需要获取第二个返叵值，所以第一个返回值定义为匿名变量
}

• 在编译过程中,可能会遇到没有名称的变量、类型或方法。虽然这不是必须的,但有时候这样做可以极大地增强代巧的灵活性,这些变量被统称为匿名变量。
• 匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

6.变量的作用域

一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为作用域。

了解变量的作用域对我们学习Go语言来说足比较重要的，因为Go语言会在编译时检查每个变量足否使用过，一旦出现未使用的变量，就会报编译错误。如果不能埋解变量的作用域,就有可能会带来一些不明所以的编译错误。

局部变量

在函数体内声明的变量称之为局部变量,它们的作用域只在函数体内,函数的参数和返回值变量都属于局部变量。

package mainimport "fmt"// 全局变量
var name string = "guanGuan"func main() {//局部变量var age int = 18var name string = "Guan"fmt.Println(name, age)}func test() {fmt.Println(name)}

全局变量

在函数休外声明的变量称之为全局变量,全局变量只需要在一个源文件中定义,就可以在所有源文件中使用,当然,不包含这个全局变量的源文件需要使用"import"关键它引入全局变量所在的源文件之后才能使用这个全局变量。

全局变量声明必须以var关键字开头,如果想要在外部包中使用全局变量的首字母必须大写。

//声明全局变量
var c int 
func main(){//声明局部变量var a,b int初始化参数a = 3b = 4c = a + bfmt.printf("a = %d,b = %d,c = %d\n",a,b,c) //a = 3, b = 4, c = 7
}

Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。

package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main(){//声明局部变量var a int = 3fmt.Printf("a = %d\n", a) // a = 3
}

三、常量

1.常量的定义： const

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

• 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符申型

const identifier [type] = value

你可以省略类型说明符[type],因为编译器可以根据变量的值来推断其类型。

• 显式类型定义： const b string = “abc”
• 隐式类型定义： const b = “abc”

多个相同类型的声明可以简写为:

const c_name1, c_name2 = value1, value2

以下实例演示了常量的应用：

package mainfunc main() {// 常量不能被修改的量，否则会报错const URL string = "www.baidu.com"URL = "www.guan.com"
}

输出

package mainimport "fmt"func main() {const URL1 string = "www.baidu.com" // 显式定义const URL2 = "www.guan.com" // 隐式定义const a,b,c = 3.14,"guanGuan",true //同时定义多个常量fmt.Println(URL1)fmt.Println(URL2)fmt.Println(a,b,c)
}

输出

2.iota（特殊常量）

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

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

iota 可以被用作枚举值：

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

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

package mainimport "fmt"func main() {const (// 一组常量中，如果某个常量没有初始值，默认和上一行一致a = iota         //iota=0b                //iota=1c                //iota=2d = "hello,guan" // hello,guan  iota=3e                // hello,guan  iota=4f = 100          // 100 iota=5g                // 100 iota=6h = iota         //iota=7i                //iota=8)const (j = iota // iota=0k = iota // iota=1)fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}

四、基本数据类型

Go语言是一种静态类型的编程语言,在Go编程语言中,数据类型用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要川大数据的时候才需要申请大内存，就可以充分利川内存。编译器在讲行编译的时候，就要知道每个值的类型，这样编译器就知道要为这个值分配多少内存,并且知道这段分配的内存表示什么.

1.布尔类型

布尔型的值只可以是常量 true 或者 false。举一个简单的栗子：

package mainimport "fmt"func main() {// var 变量名 数据类型// bool： true falsevar isFlag boolvar b1 bool = truevar b2 bool = falsefmt.Println(isFlag) //如果不进行初始赋值，则默认值为falsefmt.Printf("%T,%t\n", b1, b1)fmt.Printf("%T,%t\n", b2, b2)
}

2.数值型

整型int和浮点型loat32、 foat64, Go语言支持整型和浮点型数字,并且支持复数,其中位的运算采用补码。

Go 也有基于架构的类型，例如：uint 无符号、int 有符号

序号	类型和描述
1	uint8 无符号 8 位整型 (0到255)
2	uint16 无符号 16 位整型 (0 到 65535)
3	uint32 无符号 32 位型 (0 到 4294967295)
4	uint64 无符号64位整型 (0到18446744073709551615)
5	int8 力符号 8 位整型 (-128 到 127)
6	int16 有符号 16位整型(-32768 到 32767)
7	int32 有符号 32 位整型 (-2147483648 到 2147483647)
8	int64 符号64位整型(-9223372036854775808到9223372036854775807)

package mainimport "fmt"func main() {// 定义一个整型// byte uint8// rune int32// int int64var age int = -100var i1 int8var i2 uint8i1 = 66i2 = 188fmt.Printf("%T,%d\n",age,age)fmt.Println(i1)fmt.Println(i2)
}

浮点型

序号	类型和描述
1	float32 IEEE-754 32位浮点型数
2	float64 IEEE-754 64位浮点平数
3	complex64 32 位实数和虚数
4	complex128 64 位头数和虚数

package mainimport "fmt"func main() {var f1 float32f1 = 3.14var f2 float64f2 = 5.12// %f 默认保留小数点后6位，.2f%就是保留2位，.3f%就是保留3位fmt.Printf("%T,%.3f\n", f1, f1)fmt.Printf("%T,%f\n", f2, f2)
}

输出

1、关于浮点数在机器中存放形式的简单说明，浮点=符号位+指数位+尾数位

2、尾数位部分可能会丢失，造成精度损失。-123.0000901

package mainimport "fmt"func main() {// float64 尽量使用 float64 来定义浮点类型的小数var num1 float32 = -123.1234567var num2 float64 = -123.1234567fmt.Println("num1=", num1, "num2=", num2)}

• 说明：float64的精度要比float32的要准确
• 说明：如果我们要保存一个精度高的数，则应该选择float64

3、浮点型的存储分为二部分：符号位+指数位+尾数位，在存储过程中，精度会有丢失、

4、golang的浮点型默认为float64类型

5、通常情况下，应该使用float64，因为它比float32更精确

以下列出了其他更多的数字类型：

序号	类型和描述
1	byte 类似 uint8
2	rune 类似 int32
3	uint 32 或 64 位
4	int 与 uint 一样大小
5	uintptr 无符号整型，用于存放一个指针

3.字符串型

import "fmt"func main() {var str stringstr = "helloWorld!"fmt.Printf("%T,%s\n", str, str)//单引号 字符 ，整型-ASCII字符码x1 := 'A'x2 := "A"x3 := '关'// 拓展// 编码表 ASCII 字符码// 所有的中国字的编码表：GBK// 全世界的编码表：Unicode 编码表fmt.Printf("%T,%d\n", x1, x1)fmt.Printf("%T,%s\n", x2, x2)fmt.Printf("%T,%s\n", x3, x3)
}

package mainimport "fmt"func main() {var str1, str2, str3 stringstr1 = "hello"str2 = "guan"str3 = ","// 字符串的连接 用 + 号fmt.Println(str1 + str3 + str2)// 转义字符 \fmt.Println("hello\\guan")fmt.Println("hello\"guan")fmt.Println("hello\nguan") // \n 换行fmt.Println("hello\tguan") // \t 制表符
}

输出

4.数据类型的转换

在必要以及可行的情况下,一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明：

valueofTypeA = typeA (valueofTypeB)

类型 A 的值=类型 A(类型 B的值)

func main() {a := 5.0 //  float64b := 8   // int//需求：将int类型的 b 转化为 float64 类型c := float64(b)d := int(a)// 整型不能转换为bool类型//e := bool(b)//fmt.Printf("%T,%f\n", e, e)fmt.Printf("%T,%f\n", c, c)fmt.Printf("%T,%d\n", d, d)}

输出

类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型（将int16 转换为 int32).当从取值范围较大的类型转换到取伯范围较小的类型时(将int32转换为int16或将float32转换为int) ,会发生精度丢失(截断)的情况。

五、运算符

1.算术运算符

下表列出了所有Go语言的算术运算符。假定A值为1, B值为2。

运算符	描述	实例
+	相加	A+B 输出结果 3
-	相减	A-B 输出结果 -1
*	相乘	A*B 输出结果 2
/	相除	A/B 偷出结果 0
%	求余	A % B 输山结果 1
++	自增	A++ 输出结果2
–	自减	A–输出结果 1

package mainimport "fmt"func main() {var a int = 1var b int = 2// + - * / % ++ --fmt.Println(a + b)fmt.Println(a - b)fmt.Println(a * b)fmt.Println(a / b)fmt.Println(a % b)a++fmt.Println(a)a--fmt.Println(a)}

输出

2.关系运算符

下表列出了所有Go语言的关系运算符。假定A值为1, B值为2.

运算符	描述	实例
==	检查两个值是否相等，如果相等返回True，否则返回 False	(A == B) 为 False
!=	检查两个值是否个相等,如果不相等返回True否则返回 False	(A!=B)为True
>	检查左边值是否大于右边值，如果是返回 True，否则返回 False	(A > B) 为 False
<	检查左边值是否小于右边值,如果是返回True，否则返回False	(A < B) 为 True
>=	检查左边值是否大于等于右边的值，如果是返回 True，否则返回 False	(A > B) 为 False
<=	检查左边值是否小于右边值,如果是返回True，否则返回False	（A<=B）为 True

package mainimport "fmt"func main() {var a int = 1var b int = 2// ==等于  =赋值// 关系运算符 返回结果都是 bool值fmt.Println(a == b)fmt.Println(a != b)fmt.Println(a > b)fmt.Println(a < b)fmt.Println(a >= b)fmt.Println(a <= b)}

输出结果

3.逻辑运算符

下表列出了所有Go语言的逻辑运算符。假设A值为True, B值为False。

运算符	描述	实例
&&	逻辑 AND 运算符。如果两边的操作数都是 True，则条件 True，否则为 False	(A && B) 为 False
||	逻辑 OR 运算符。如果两边的操作数有一个 True，则条件 True，否则为 False。	(A || B)为True
!	逻辑 NOT 运算符。如果条件为 True，则逻辑 NOT 条件 False，否则为 True。	!(A && B) 为True

package mainimport "fmt"func main() {var a bool = truevar b bool = false// 逻辑与 && 要左右两边的表达式同时为真，才执行，结果才为真，否则为假// 关系运算符 返回结果都是 bool值fmt.Println(a && b)// 逻辑或 || 只要其中有一个为真，则为真，全为假则为假fmt.Println(a || b)// !为逻辑非，即取反，结果相反// a = true// b = falsefmt.Println(!a) fmt.Println(!b)}

输出结果

4.位运算符

Go语言文持的位运算符如下表所示。倭定A为60, B为13:

运算符	描述	实例
&	按位与运算符"&"是双目运算符。都足1结果为1，否则足0	（A & B） 结果为 12，二进制为0000 1100
|	按位或运算符"|"是双月运算符。都是0结果为0,否则是1	（A|B）结果为 61，二进制为 0011 1101
^	按位异或运算符"^"是双目运算符。不同则为1，机同为0	(A^B)结果为49，二进制为 0011 0001
&^	位清空,a&^b，对于b上的每个数值，如果为0,则取a对应位上的数值,如果为1,则取0	(A &^ B) 结果为 48，二进制为 0011 0000
<<	左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。其功能把”<<“左边的运算数的各二进位全部左移若干位,由”<<"右边的数指定移动的位数,高位丢弃,低位补0	A<<2 结果为 240，二进制为 1111 0000
>>	右移认算符">>“是双目运算符。右移n位就是除以2的n次方。其功能是把”>>“左边的运算数的各二进制文全部右移若干位，”>>"右边的数指定移动的位数	A >> 2 结果为 15，二进制为0000 1111

package mainimport "fmt"func main() {// 二进制 0 1 逢二进一// 位运算：二进制上的 0 false 、 1 true// 逻辑运算符： && 只要有一个为假，则为假、 || 只要有一个为真，则为真// a 60 0011 1100// b 13 0000 1101// --------------------------// & 0000 1100 同时满足// | 0011 1101 一个满足就行// ^ 0011 0001 不同为1，相同为0// << 2// >> 2var a uint = 60var b uint = 13// 位运算var c uint = 0c = a & b                       //位运算fmt.Printf("%d,二进制%b", c, c) // 0000 1100fmt.Println()c = a | b                       //位运算fmt.Printf("%d,二进制%b", c, c) // 0011 1101fmt.Println()c = a ^ b                       //位运算fmt.Printf("%d,二进制%b", c, c) // 0011 0001fmt.Println()// 60 0011 1100c = a << 2fmt.Printf("%d,二进制%b", c, c) //fmt.Println()a = 60c = a >> 2fmt.Printf("%d,二进制%b", c, c) //
}

输出

5.赋值运算符

下表列出了所有Go语言的赋值认算符。

运算符	描述	实例
=	简单的赋值运算符,将一个表达式的值赋给一个左值	C=A+B将 A+B表达式结果赋值给C
+=	相加后赋值	B+=A等于B=B+A
-=	相减后再赋值	B-=A 等于 B=B-A
*=	相乘后再赋值	C*=A等于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

package mainimport "fmt"func main() {var a int = 21var c int//  将等号右边的值，赋值给左边c = afmt.Printf("第 1 行  = 运算符实例,c 值为 = %d\n", c)c += afmt.Printf("第 2 行  += 运算符实例,c 值为 = %d\n", c)c -= afmt.Printf("第 3 行  -= 运算符实例,c 值为 = %d\n", c)c *= afmt.Printf("第 4 行  *= 运算府实例,c 值为 = %d\n", c)c /= afmt.Printf("第 5 行  /= 运算符实例,c 值为 = %d\n", c)c = 200c <<= 2fmt.Printf("第 6行  <<= 运算符实例,c值为 = %d\n", c)c >>= 2fmt.Printf("第 7 行 >>= 运算符实例,c 值为 = %d\n", c)c &= 2fmt.Printf("第 8 行  &= 运算符实例,c  值为 = %d\n", c)c ^= 2fmt.Printf("第 9 行  ^= 运算符实例,c 值为 = %d\n", c)c |= 2fmt.Printf("第 10 行 |= 运算符实例,c 值为 =%d\n", c)
}

输出

6.其他运算符

下表列出了Go语言的其他运算符

运算符	描述	实例
&	返回变量存储地址	&a；将给出变量的实际地址
*	指针变量	*a；是一个指针变量

package mainimport "fmt"func main() {var a int = 6var b int32var c float32var ptr *int/* 运算符实例 */fmt.Printf("第 1 行 a 变量类型为 = %T\n", a)fmt.Printf("第 2 行 b 变量类型为 = %T\n", b)fmt.Printf("第 3 行 c 变量类型为 = %T\n", c)/* & 和 * 运算符实例 */ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */fmt.Printf("a 的值为 = %d\n", a)fmt.Printf("ptr 的值为 = %p\n", ptr)fmt.Printf("ptr 的值为 = %d\n", *ptr)}

输出

六、键盘的输入和输出

package mainimport "fmt"func main() {var name stringvar phoneNumber string// 定义了两个变量，想用键盘来输入这两个变量//fmt.Println()  //打印并换行//fmt.Printf()  //格式化输出//fmt.Print()  //打印输出fmt.Println("请输入姓名和手机号码：")// 变量去地址 &变量// 指针、地址来修改和操作变量// Scanln 阻塞等待从键盘输入fmt.Scanln(&name, &phoneNumber)fmt.Println("name:", name)fmt.Println("phoneNumber:", phoneNumber)// fmt.Scanln() //接收输入并换行// fmt.Scanf()  // 接收输入，格式化输入// fmt.Scan()   // 接收输入}

输出

---