第1节 变量的使用 1.1 什么是变量 变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。 所以变量的本质就是一小块内存，用于存储数据，在程序运行过程中数值可以改变。
1.2 声明变量 var名称类型是声明单个变量的语法。 以字母或下划线开头，由一个或多个字母、数字、下划线组成 声明一个变量
第一种，指定变量类型，声明后若不赋值，使用默认值 var name type name = value 1 2 第二种，根据值自行判定变量类型(类型推断Type inference) 如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。因此，如果变量具有初始值，则可以省略变量声明中的类型。 var name = value 1 第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量)，否则会导致编译错误(简短声明) name := value // 例如 var a int = 10 var b = 10 c : = 10 1 2 3 4 5 这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值 示例代码：
package main var a = "Hello" var b string = "World" var c bool func main(){ println(a, b, c) } 1 2 3 4 5 6 7 运行结果：
Hello World false 1 多变量声明 第一种，以逗号分隔，声明与赋值分开，若不赋值，存在默认值
var name1, name2, name3 type name1, name2, name3 = v1, v2, v3 1 2 第二种，直接赋值，下面的变量类型可以是不同的类型
var name1, name2, name3 = v1, v2, v3 1 第三种，集合类型
var ( name1 type1 name2 type2 ) 1 2 3 4 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") } 1 2 3 4 尝试编译这段代码将得到错误 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) } 1 2 3 4 5 6 7 8 9 10 11 运行结果：
0xc04200a2b0 0xc04200a2b0 200 abc 1 2 3 第2节 常量的使用 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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
运行结果：
面积为 : 50 1 false str 1 2 常量可以作为枚举，常量组
const ( Unknown = 0 Female = 1 Male = 2 ) 1 2 3 4 5 常量组中如不指定类型和初始化值，则与上一行非空常量右值相同
package main import ( "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 1 2 常量的注意事项：
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型 不曾使用的常量，在编译的时候，是不会报错的 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值 2.2 iote iota，特殊常量，可以认为是一个可以被编译器修改的常量 iota 可以被用作枚举值：
const ( a = iota b = iota c = iota ) 1 2 3 4 5 第一个 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 1 如果中断iota自增，则必须显式恢复。且后续自增值按行序递增 自增默认是int类型，可以自行进行显示指定类型 数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址。
第3节 基本数据类型 以下是go中可用的基本数据类型
3.1 布尔型bool 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true
3.2 数值型 1、整数型
int8 有符号 8 位整型 (-128 到 127) 长度：8bit int16 有符号 16 位整型 (-32768 到 32767) int32 有符号 32 位整型 (-2147483648 到 2147483647) int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) uint8 无符号 8 位整型 (0 到 255) 8位都用于表示数值： uint16 无符号 16 位整型 (0 到 65535) uint32 无符号 32 位整型 (0 到 4294967295) uint64 无符号 64 位整型 (0 到 18446744073709551615) int和uint:根据底层平台，表示32或64位整数。除非需要使用特定大小的整数，否则通常应该使用int来表示整数。 大小:32位系统32位，64位系统64位。
范围:-2147483648到2147483647的32位系统和-9223372036854775808到9223372036854775807的64位系统。 2、浮点型
float32 IEEE-754 32位浮点型数 float64 IEEE-754 64位浮点型数 complex64 32 位实数和虚数 complex128 64 位实数和虚数 3、其他
byte 类似 uint8 rune 类似 int32 uint 32 或 64 位 int 与 uint 一样大小 uintptr 无符号整型，用于存放一个指针 3.3 字符串型 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本
var str string str = "Hello World" 1 2 3.4 数据类型转换：Type Convert 语法格式：Type(Value) 常数：在有需要的时候，会自动转型 变量：需要手动转型 T(V) 注意点：兼容类型可以转换
3.5 复合类型(派生类型) 1、指针类型（Pointer） 2、数组类型 3、结构化类型(struct) 4、Channel 类型 5、函数类型 6、切片类型 7、接口类型（interface） 8、Map 类型
第4节 运算符 4.1 算术运算符
-
-
- / %(求余) ++ -- 1 4.2 关系运算符 == != > < >= <= 1 4.3 逻辑运算符 运算符 描述 && 所谓逻辑与运算符。如果两个操作数都非零，则条件变为真 || 所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真 ! 所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假 4.4 位运算符 运算符 描述 示例 & 二进制与操作副本位的结果，如果它存在于两个操作数 (A & B) = 12, 也就是0000 1100 | 二进制或操作副本，如果它存在一个操作数 (A｜B) = 61, 也就是0011 1101 ^ 二进制异或操作副本，如果它被设置在一个操作数就是按位取非 (A ^ B) = 49，也就是0011 0001 &^ 二进制位清空&^ (A&^B)=48，也就是0011 0000 << 二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数 A << 2 =240，也就是1111 0000
-
二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动 A >> 2 = 15，也就是0000 1111 4.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 4.6 优先级运算符优先级 有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：
优先级 运算符 7 ~ ! ++ – 6 * / % << >> & &^ 5 + - ^ 4 == != < <= >= > 3 <- 2 && 1 || 当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。
第5节 键盘输入和打印输出 5.1 fmt包 fmt包实现了类似C语言printf和scanf的格式化I/O。格式化verb（’verb’）源自C语言但更简单。 详见官网fmt的API：golang.google.cn/pkg/fmt/
导入包：
import "fmt" 1 5.2 常用打印函数 打印：func Print(a …interface{}) (n int, err error) 格式化打印：func Printf(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.Println("-----------------------") 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) }
5.3 fmt包读取键盘输入 常用方法： 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.Printf("x的数值：%d，y的数值：%f\n",x,y) fmt.Scanf("%d,%f",&x,&y) fmt.Printf("x:%d,y:%f\n",x,y) } 1 2 3 4 5 6 7 8 9 10 11 12 13 运行结果：
5.4 bufio包读取 golang.google.cn/pkg/bufio/ bufio包中都是IO操作的方法： 先创建Reader对象：
然后就可以各种读取了：
示例代码：
package main import ( "fmt" "os" "bufio" ) func main() { fmt.Println("请输入一个字符串：") reader := bufio.NewReader(os.Stdin) s1, _ := reader.ReadString('\n') fmt.Println("读到的数据：", s1) }
