50天精通Golang（第3天）

一、变量的使用

1.1什么是变量

变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。
所有的变量本质就是一小块内存，用于存储数据，在程序运行过程中数值可以改变。

1.2声明变量

var名称类型是声明单个变量的语法。

以字母或下划线开头，由一个或多个字母、数字、下划线组成

声明一个变量
第一种，指定变量类型，声明后不赋值，使用默认值

var name type
name = value

第二种，根据值自行判定变量类型（类型推断Type interence）
如果一个变量由一个初始值，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 bool

func 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
)

1.3注意事项

• 变量必须先定义才能使用
• go语言是静态语言，要求变量的类型和赋值的类型必须一致
• 变量名不能冲突（同一个作用于域内不能冲突）
• 简短定义方式，左边的变量名至少有一个是新的
• 简短定义方式，不能定义全局变量
• 变量的零值，也叫默认值
• 变量定义了就要使用，否则无法通过编译

如果在相同的代码块中，我们不可以再次对于相同名称的便便使用初始化声明，例如： 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 main

import (
	"fmt"
)

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

运行结果

0xc04200a2b0
0xc04200a2b0 200
abc

二、常量的使用

2.1常量声明

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

const identifier [type] = value

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

package main

import "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 main
impot (
	"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

常量的注意事项：

• 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
• 不曾使用的常量，在编译的时候，是不会报错的
• 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量可以是不同的类型值

2.2iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量
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 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

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

三、基本数据类型

3.1布尔型bool

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

3.2数值型

3.2.1整数型

1.整数型

• int8有符号8位整型（-128到127）长度：8bit
• int16有符号16位整型（-32768到32767）
• int32有符号32位整型（-2147483648到2147483647）
• int64有符号64位整型
• uint8无符号8位整型（0到255）
• uint16无符号16位整型（0到65535）
• uint32无符号32位整型
• uint64无符号64位整型

int和uint:根据底层平台，表示32或64位整数。除非需要使用特定大小的整数，否则通常应该使用int来了事整数。大小：32位系统32位，64位系统64位。

2.浮点型

• float32
• float64
• complex64
• comples128
  3.其他
• byte，类似uint8
• rune，类似int32
• uint，32或64
• int，与uint一样大小
• uintptr，无符号整型，用于存放一个指针

3.3字符串型

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本

var str string
str = “Hello World”

3.4数据类型转换：Type Convert

语法格式：Type（value）
常数：在有需要的时候，会自动转型
变量：需要手动转型T（V）
注意点：兼容类型可以转换

四、复合类型（派生类型）

1. 指针类型(Pointer)
2. 数组类型
3. 结构化类型（struct）
4. Channel类型
5. 函数类型
6. 切片类型
7. 接口类型（interface）
8. Map类型

五、运算符

表达式：（a + b）* c

a,b,c叫做操作数
+，*，叫做运算符

5.1算术运算符

• • • / %(求余) ++ –

5.2关系运算符

== != > < >= <=

5.3逻辑运算符

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

5.4位运算符

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为60，B为13

运算	描述	实例
&	二进制与操作副本位的结果，如果它存在于两个操作数	（A&B）=12，也就是0000 1100
|	二进制或操作副本，如果它存在一个操作数	（A|B）=61，也就是0011 1101
^	二进制异或操作副本，如果它被设置在一个操作数就是按位取非	（A^B）= 49，也就是0011 0001
&^	二进制位清空&^	(A&^B)=48,也就是110000
<<	二进制左移运算符。左边的操作数的值向左移动由右操作数指定的位数	A<<2=240也就是1111 0000
>>	二进制向右移位运算符。左半边的操作数的值由右操作数指定的位数向右移动	A>>2=15也就是0000 1111

5.5赋值运算符

运算符	描述	示例
=	简单的赋值操作符，分配值从右边的操作数左侧的操作数	C = A + B 将分配A + B的值到C
+=	相加并赋值运算符，它增加了右操作数左操作数和分配结果左操作数	C += A 相当于 C = C + A
-=	减和赋值运算符，它减去右操作数从左侧的操作数和分配结果左操作数	C -= A 相当于 C = C - 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

5.6优先级运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由低到高：

优先级	运算符
7	~ ! ++ –
6	* / % << >> & &^
5	+ - ^
4	== != < <= >= >
3	<-
2	&&
1	||
我们也可以使用括号来临时提升某个表达式的整体运算优先级。

六、键盘输入和打印输出

6.1fmt包

fmt包实现了类似C语言print和scanf的格式化I/O。格式化verb(‘verb’)源自C语言但更简单。

6.2导入包

import "fmt"

6.3常用打印函数

打印：

func Print(a …interface{})(n int, err error)

格式化打印：

func Print(format string, a …interface{})(n int, err error)

打印后换行

func Println(a …interface{})(n int, err error)

格式化打印中的常用占位符：

格式化打印占位符：
%v，原样输出
%T，打印类型
%t，bool类型
%s，字符串
%f，浮点
%d，10进制的整数
%b，2进制的整数
%o，8进制
%x，%X，16进制
%x：0~9,a~f
%X:0~9,A~F
%c，打印字符
%p，打印地址

实例代码：

package main
import(
	"fmt"
)
func main(){
	a := 100 //int
	b := 3.14 //float64
	c := true //bool
	d := "Hello World"//string
	e := 'Ruby' //string
	f := 'A'
	fmt.Printf("%T,%b\n", a, a)
	fmt.Printf("%T,%f\n", b, b)
	fmt.Printf("%T,%t\n", c, c)
	fmt.Printf("%T,%s\n", d, d)
	fmt.Printf("%T,%s\n", e, e)
	fmt.Printf("%T,%d,%c\n", f, f, f)
	fmt.Printf("%v\n", a)
	fmt.Printf("%v\n", b)
	fmt.Printf("%v\n", c)
	fmt.Printf("%v\n", d)
	fmt.Printf("%v\n", e)
	fmt.Printf("%v\n", f)
}

运算结果：
int,1100100
float64,3.140000
bool,true
string,Hello World
string,Ruby
int32,65,A
100
3.14
true
Hello World
Ruby
65

6.4fmt包读取键盘输入

常用方法：
func Scan(a …interface{})(n int, err error)
func Scanf(format string,a …interface{})(n int , err error)
func Scanln(a …interface{})(n int, err error)

package main
import (
	"fmt"
)
func main(){
	var x int
	var y float64
	fmt.Println("请输入一个整数，一个浮点类型：")
	fmt.Scanln(&x,&y)//读取键盘的输入，通过操作地址，赋值给x和y   阻塞式
	fmt.Print("x的数值：%d，y数值：%f\n",x,y)

	fmt.Scanf("%d,%f",&x,&y)
	fmt.Printf("x:%d,y:%f\n",x,y)
}

运算结果：

请输入一个整数，一个浮点类型：
7 8.9
x的数值：7，y数值：8.900000
8,9.6
x:8,y:9.600000