go build：对源代码和依赖的文件进行打包，生成可执行文件go build -o my_first_go_exe entrance_class/demo.go
go install：编译并安装包或依赖，安装到$GOPATH/bin下go install entrance_class/demo.go
go get：把依赖库添加到当前module中
如果本机之前从未下载过则先下载go get github.com/tinylib/msgp命令会在$GOPATH/pkg/mod目录下会生成github.com/tinylib/msgp目录
go install github.com/tinylib/msgp@latest命令会在$GOPATH/bin下生成msgp可执行文件
go mod init module_name：初始化一个Go项目
go mod tidy：go mod tidy通过扫描当前项目中的所有代码来添加未被记录的依赖至go.mod文件或从go.mod文件中删除不再被使用的依赖
go fmt：对代码文件进行格式化，如果用了IDE这个命令就不需要了go fmt entrance_class/demo.go
go doc：查看go标准库或第三方库的帮助文档
库和二进制文件的位置：
下载的第三方依赖存储在$GOPATH/pkg/mod下
go install生成的可执行文件存储在$GOPATH/bin下
Go Modules依赖包的查找顺序
①.工作目录
②.$GOPATH/pkg/mod
③.$GOROOT/src
三、运算符
算法术运算符
运算符
描述
+
相加
-
相减
*
相乘
/
相除
%
求余
//arithmetic 算术运算
func arithmetic() {
var a float32 = 8
var b float32 = 3
var c float32 = a + b
var d float32 = a - b
var e float32 = a * b
var f float32 = a / b
fmt.Printf("a=%.3f, b=%.3f, c=%.3f, d=%.3f, e=%.3f, f=%.3f\n", a, b, c, d, e, f)
// a=8.000, b=3.000, c=11.000, d=5.000, e=24.000, f=2.667
}
关系运算符
运算符
描述
==
检查两个值是否相等，如果相等返回 True 否则返回 False
!=
检查两个值是否不相等，如果不相等返回 True 否则返回 False
>
检查左边值是否大于右边值，如果是返回 True 否则返回 False
>=
检查左边值是否大于等于右边值，如果是返回 True 否则返回 False
<
检查左边值是否小于右边值，如果是返回 True 否则返回 False
<=
检查左边值是否小于等于右边值，如果是返回 True 否则返回 False
//relational 关系运算符funcrelational(){
var a float32=8var b float32=3var c float32=8
fmt.Printf("a==b吗 %t\n", a == b)//false
fmt.Printf("a!=b吗 %t\n", a != b)//true
fmt.Printf("a>b吗 %t\n", a > b)//true
fmt.Printf("a>=b吗 %t\n", a >= b)//true
fmt.Printf("a<c吗 %t\n", a < b)//false
fmt.Printf("a<=c吗 %t\n", a <= c)//true}
逻辑运算符
运算符
描述
&
逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False
||
逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False
!
逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True
//logistic 逻辑运算符funclogistic(){
var a float32=8var b float32=3var c float32=8
fmt.Printf("a>b && b>c吗 %t\n", a > b && b > c)//false
fmt.Printf("a>b || b>c吗 %t\n", a > b || b > c)//true
fmt.Printf("a>b不成立，对吗 %t\n",!(a > b))//false
fmt.Printf("b>c不成立，对吗 %t\n",!(b > c))//true}
// 输出一个int32对应的二进制表示funcBinaryFormat(n int32)string{
a :=uint32(n)
sb := strings.Builder{
}
c :=uint32(math.Pow(2,31))//最高位上是1，其他位全是0for i :=0; i <32; i++{
if a&c !=0{
//判断n的当前位上是否为1
sb.WriteString("1")}else{
sb.WriteString("0")}
c >>=1//"1"往右移一位}return sb.String()}// bit_op 位运算funcbit_op(){
//int是4字节还是8字节，取决于操作系统是32位还是64位
fmt.Printf("os arch %s, int size %d\n", runtime.GOARCH, strconv.IntSize)var a int32=260
fmt.Printf("260 %s\n",BinaryFormat(a))//260 00000000000000000000000100000100//负数用补码表示。在对应正数二进制表示的基础上，按拉取反，再末位加1//另外一种办法：正数的二进制从右往左，在遇到第1个时都保持不变，之后的0转1，1转0，就可以算出负数补码
fmt.Printf("-260 %s\n",BinaryFormat(-a))//-260 11111111111111111111111011111100
fmt.Printf("260&4 %s\n",BinaryFormat(a&4))//260&4 00000000000000000000000000000100
fmt.Printf("260|3 %s\n",BinaryFormat(a|3))//260|3 00000000000000000000000100000111//^作为二元运算符时表示异或
fmt.Printf("260^7 %s\n",BinaryFormat(a^7))//260^7 00000000000000000000000100000011//^作为一元运算符时表示按位取反，符号位也跟着变
fmt.Printf("^-260 %s\n",BinaryFormat(^-a))//^-260 00000000000000000000000100000011//正数高位补0，负数高位补1
fmt.Printf("-260>>10 %s\n",BinaryFormat(-a>>10))//-260>>10 11111111111111111111111111111111//负数左移，可能变成正数
fmt.Printf("-260<<3 %s\n",BinaryFormat(-a<<3))//-260<<3 11111111111111111111011111100000}
四、变量
go的变量类型
%e：科学计数法
%g：在f和e中自动选择最合适的
类型
go变量类型
fmt输出
整型
int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64
%d
浮点型
float32 float64
%f %e %g
复数
complex128 complex64
%v
布尔型
bool
%t
指针
uintptr
%p
引用
map slice channel
%v
字节
byte
%c
任意字符
rune
%c
字符串
string
%s
错误
error
%v
package main
import"fmt"funcmain(){
a :=500000000000.0
fmt.Printf("%f\n", a)// 500000000000.000000
fmt.Printf("%e\n", a)// 5.000000e+11
fmt.Printf("%g\n", a)// 5e+11}
%v占位符
package main
import"fmt"funcmain(){
type User struct{
Name string
Age int}
user :=&User{
"zhang san",4}
fmt.Printf("%v\n", user)//&{zhang san 4}
fmt.Printf("%+v\n", user)//&{Name:zhang san Age:4}
fmt.Printf("%#v\n", user)//&main.User{Name:"zhang san", Age:4}}
%在fmt中的转义
package main
import("fmt")funcmain(){
a :=1
b :=2
fmt.Printf("a%%=b %d\n", a%b)//%在fmt里有特殊含意，所以需要前面再加个%转义一下}
变量初始化：如果声明后未显式初始化
数值型初始化0
字符串初始化为空字符串
布尔型初始化为false
引用类型、函数、指针、接口初始化为nil
var a string="china"//初始化一个变量var a="china"//类型推断为stringvar a,b int=3,7//初始化多个变量var a,b="china",7//初始化多个变量，每个变量都单独地执行类型推断
函数内部的变量(非全局变量)可以通过:=声明并初始化：a:=3
下划线表示匿名变量。匿名变量不占命名空间，不会分配内存，因此可以重复使用：_=2+4
go中的++和--运算符要求
只能使用后置的++或--
只能独立一行，不能放在表达式中
funcmain(){
a :=1
a++//right
fmt.Println(a++)//wrong}
package main
import"fmt"funcmain(){
const a =iotaconst b =iota
fmt.Println(a, b)//0 0const(
c =iota
d
e
)
fmt.Println(c, d, e)//0 1 2const(
l =iota__
m
)
fmt.Println(l, m)//0 3const(
x =iota
y
z =iota
u
)
fmt.Println(x, y, z, u)//0 1 2 3const(
i =iota_
j =iota+10
k
)
fmt.Println(i, j, k)//0 12 13const(
v =10
h
n =iota//批量中的iota总是从0开始)
fmt.Println(v, h, n)// 10 10 2const(
o =iota
p =10
q
r =iota//批量里面的iota都是同一个)
fmt.Println(o, p, q, r)//0 10 10 3const(
a,b=iota+1,iota+2//1,2 iota =0
c,d //2,3 iota =1
e,f //3,4 iota =2)}
使用iota定义偶数和奇数
funcmain(){
const(
a =iota*2
b
c
d
)
fmt.Println(a, b, c, d)//0 2 4 6const(
l =iota*2+1
m
n
o
)
fmt.Println(l, m, n, o)//1 3 5 7}
