linuxea:go流程控制之switch(13) switch和if很相似。这里分为switch单值和表达式。我们仍然借用上一篇中if中的实例"老婆老公买西瓜包子"来做switch老婆的想法：package main import "fmt" func main(){ var yes string fmt.Print("是否看到卖西瓜的?") fmt.Scan(&yes) fmt.Print("老婆的想法:") fmt.Println("买10个包子") switch yes { case "y": fmt.Println("买一个西瓜y") case "Y": fmt.Println("买一个西瓜Y") } }输入小y:[root@marksugar /opt/Golang]# go run switch.go 是否看到卖西瓜的?y 老婆的想法:买10个包子 买一个西瓜y输入大Y:[root@marksugar /opt/Golang]# go run switch.go 是否看到卖西瓜的?Y 老婆的想法:买10个包子 买一个西瓜Y输入n：[root@marksugar /opt/Golang]# go run switch.go 是否看到卖西瓜的?n 老婆的想法:买10个包子!!! note这里的switch可以写成一条 case "y","Y": fmt.Println("买一个西瓜") } 老公的想法switch defaultpackage main import "fmt" func main(){ var yes string fmt.Print("是否看到卖西瓜的?") fmt.Scan(&yes) fmt.Print("老公的想法:") fmt.Println("买10个包子") switch yes { case "y","Y": fmt.Println("买一个包子") default: fmt.Println("买十个包子") } }看到卖西瓜的:[root@marksugar /opt/Golang]# go run switch.go 是否看到卖西瓜的?y 老公的想法:买10个包子 买一个包子没看到买西瓜的:[root@marksugar /opt/Golang]# go run switch.go 是否看到卖西瓜的?n 老公的想法:买10个包子 买十个包子在用switch的方式修改，如果输入大于等于90就打印A，大于等于80打印B，大于等于70打印C，大于等于60打印D，小于60就打印D-不及格。如下: var score int fmt.Print("请输入成绩:") fmt.Scan(&score) switch { case score >= 90: fmt.Println("A") case score >= 80: fmt.Println("B") case score >= 70: fmt.Println("C") case score >= 60: fmt.Println("D") default: fmt.Println("D-,不及格") }运行[root@marksugar /opt/Golang]# go run switch.go 请输入成绩:90 A [root@marksugar /opt/Golang]# go run switch.go 请输入成绩:80 B [root@marksugar /opt/Golang]# go run switch.go 请输入成绩:70 C [root@marksugar /opt/Golang]# go run switch.go 请输入成绩:60 D [root@marksugar /opt/Golang]# go run switch.go 请输入成绩:50 D-,不及格

linuxea:go流程控制之if else(12) 通常我们需要代码在满足一定条件时候进行执行，或者需要重复执行代码，此时条件语句(if-else if -else)或者选择语句（swicth case）及循环语句(for)12.流程控制!!! note老婆给老公打电话，下班顺路买十个包子，如果看到买西瓜的，买一个。当晚老公拿着一个包子回家。老婆问道：你怎么只买了一个包子？老公回答：因为我看到卖西瓜的了。 if else老婆的想法，如果看到买西瓜的，买一个西瓜，代码：package main import "fmt" func main(){ fmt.Print("老婆的想法:") fmt.Println("买10个包子") var yes string fmt.Print("是否有卖西瓜的?") fmt.Scan(&yes) if yes == "Y"|| yes == "y" { fmt.Println("买一个西瓜") } }看到卖西瓜的，买一个西瓜，运行:[root@marksugar /opt/Golang]# go run if1.go 老婆的想法:买10个包子 是否看到卖西瓜的?y 买一个西瓜如果没看到就买10个包子：[root@marksugar /opt/Golang]# go run if1.go 老婆的想法:买10个包子 是否看到卖西瓜的?n老公的想法是，如果看到买西瓜的，就买一个包子，否则就买10个包子。代码如下：package main import "fmt" func main(){ fmt.Print("老婆的想法:") fmt.Println("买10个包子") var yes string fmt.Print("是否看到卖西瓜的?") fmt.Scan(&yes) if yes == "Y"|| yes == "y" { fmt.Println("买一个西瓜") } fmt.Print("老公的想法:") if yes == "y"|| yes == "Y" { fmt.Println("买一个包子") }else { fmt.Println("买10个包子") } }如果看到了买西瓜的，买一个包子:[root@marksugar /opt/Golang]# go run if1.go 老婆的想法:买10个包子 是否看到卖西瓜的?y 买一个西瓜 老公的想法:买一个包子如果没看到，就买10个包子:[root@marksugar /opt/Golang]# go run if1.go 老婆的想法:买10个包子 是否看到卖西瓜的?n 老公的想法:买10个包子if else if如果输入大于等于90就打印A，大于等于80打印B，大于等于70打印C，大于等于60打印D，小于60就打印D-不及格。如下 var score int fmt.Print("请输入成绩:") fmt.Scan(&score) if score >= 90 { fmt.Println("A") } else if score >= 80 { fmt.Println("B") } else if score >= 70 { fmt.Println("C") } else if score >= 60 { fmt.Println("D") } else { fmt.Println("D-,不及格") }运行[root@marksugar /opt/Golang]# go run if1.go 请输入成绩:70 C

linuxea:go指针简述(11) 通常而言，在go中，元素赋值一个变量A后，A变量如果在赋值给另外一个变量B，相当于一次复制。对于底层内存地址来讲，对于二次赋值的变量B修改元素，是不会修改到A变量的值，这是因为变量B的内存地址以及发生改变，如果需要修改到变量A，A就需要使用指针调用来赋值给B，大致意思是A和B使用同一个内存地址。认识指针通常变量存储在内存空间，如下图A存储在2，而后赋值B=A此刻，设置B赋值3，那么赋值是否对A有影响package main import "fmt" func main(){ A := 2 B := A B = 3 fmt.Printf("A:%d B:%d",A,B) }运行[root@marksugar /opt/Golang]# go run zhizhen.go A:2 B:3上述A是2，B是3，说明赋值给B的3是没有影响到A的值，B是单独的一个值，如下：如果我一定要通过赋值修改A的值，就可以使用指针来进行修改。如上述中。假如，A赋值的2存储在内存中的地址编号是0DSA6W3，此刻要修改就需要使用A存储的的内存地址进行修改。如下：定义指针使用&符号取变量地址，而这个类型也是*int,这个类型就是指针类型。!!! 如果是一个字符串就是*string，如果是bool就是*bool,如果是浮点数就是*float64.我们定义一个C的指针var C *int简短声明 A := 2 B := A B = 3 fmt.Printf("A:%d B:%d\n",A,B) C := &A fmt.Printf("%T",C)运行[root@marksugar /opt/Golang]# go run zhizhen.go A:2 B:3 *int获取指针值如果要获取指针的值就需要使用*变量。如：\*cA := 2 C := &A fmt.Printf("%T %p",C,*C)[root@marksugar /opt/Golang]# go run zhizhen.go A:2 B:3 *int 2修改指针值 A := 2 C := &A *C = 666 fmt.Print(*C)[root@marksugar /opt/Golang]# go run zhizhen.go 666golang中的指针没有复杂的运算，相对来讲是安全的。指针的应用使用指针package main import "fmt" func main(){ var name string var age int var height float64 fmt.Print("请输入你的名字: ") fmt.Scan(&name) fmt.Print("请输入你的年龄: ") fmt.Scan(&age) fmt.Print("请输入你的身高: ") fmt.Scan(&height) fmt.Printf("你输入的是名字是: [%s]\n输入的年龄是: [%d]\n输入的身高是: [%f]",name,age,height) }运行后输入：[root@marksugar /opt/Golang]# go run zhizhen2.go 请输入你的名字: mark 请输入你的年龄: 18 请输入你的身高: 1.7 你输入的是名字是: [mark] 输入的年龄是: [18] 输入的身高是: [1.700000]现在你必须按照类型输入。!!! Warning指针的空值是nil

linuxea:go字符串string类型简述(10) 字符串也可以作为算数运算，比如拼接。字符串也可以作为关系运算。赋值运算。可以通过索引获取。字符串定义内容必须是ascii，可以作为切片。而切片必须配置一个start和end。通常，我们可以使用len来获取字符串长度，并且可以使用len(string)-1来获取字符串最后一位定义字符串我们在定义字符串的时候，使用双引号和反引号来赋值 var name string = "mark" var desc string = `我是字符串` fmt.Println(name,desc)双引号是可解释的字符串，反引号是原生字符串[root@marksugar /opt/Golang]# go run string.go mark 我是字符串在字符串中有一些特殊字符，如:\n,\f,\t,\r,\b,\v var name string = "ma\trk" var desc string = `我是\t字符串` fmt.Println(name,desc)这里的\t是一个tab,也就是4个空格[root@marksugar /opt/Golang]# go run string.go ma rk 我是\t字符串算数运算可以使用+进行字符串的链接 var name string = "mark" var desc string = `是字符串` fmt.Println(name+desc)运行[root@marksugar /opt/Golang]# go run string.go mark是字符串关系运算关系运算分为：==,!=,>,>=,<,<= fmt.Println("a" == "b") 是否等于 fmt.Println("a" != "b") 是否不等于 fmt.Println("a" < "b") 是否小于 fmt.Println("a" > "b") 是否大于 fmt.Println("aa" <= "b") 是否小于等于 fmt.Println("a" >= "bb") 是否大于等于运算大小比较是根据ASCII 码，从左到右进行比较：[root@marksugar /opt/Golang]# go run string.go false true true false true false赋值运算 s := "my name is " s += "mark" fmt.Println(s)运算[root@marksugar /opt/Golang]# go run string.go my name is mark索引索引计算是0-n-1，n是字符串长度. desc = "abcdefg" fmt.Printf("%T %c\n",desc[0],desc[0])desc[0]，0对应a，从左到右，索引类型是uint8，这里打印使用的是%c运行[root@marksugar /opt/Golang]# go run string.go uint8 a切片字符串定义内容必须是ascii切片是从哪里到哪里，比如：从1到3--desc = "abcdefg"，从左到右，1到3则是bc，切片类型string，这里打印使用的是%s fmt.Printf("%T %s\n",desc[start:end],desc[start:end]) end不能超过字符串的长度fmt.Printf("%T %s\n",desc[1:3],desc[1:3])运行[root@marksugar /opt/Golang]# go run string.go string bc!!! 字符串定义内容必须是ascii是因为在切片或者索引的时候会出现乱码，特别是在中文字符的时候。如下： desc = "我我我" fmt.Printf("%T %c\n",desc[0],desc[0]) fmt.Printf("%T %s\n",desc[1:3],desc[1:3])运行:[root@marksugar /opt/Golang]# go run string.go uint8 æ string 字符串长度字符串长度也需要是ascii码，才能精准计算，而中文字符可能使用到三到四个字节。 desc = "abcdefg" fmt.Println(len(desc)) desc = "我我我" fmt.Println(len(desc))运行[root@marksugar /opt/Golang]# go run string.go 7 9所以这里desc = "我我我"len计算是9。而中文字符串有其他方式。去掉最后一位如果你要取最后一位则是len(desc)-1) desc = "abcdefg" fmt.Println("desc:",len(desc)) fmt.Println("desc:",len(desc)-1)如下：[root@marksugar /opt/Golang]# go run string.go desc: 7 desc: 6

linuxea:go浮点数float类型简述(9) 在go中浮点有两种类型，一种是float64，一种是float32。一般使用float64即可定义与赋值默认是0值package main import "fmt" func main(){ var floatt float64 fmt.Println(floatt) }运行[root@LinuxEA /opt/Golang]# go run float.go 0赋值 var floatt float64 floatt = 1.666package main import "fmt" func main(){ var floatt float64 floatt = 1.666 fmt.Printf("%T %f",floatt,floatt) }运行[root@LinuxEA /opt/Golang]# go run float.go float64 1.666000字面量字面量 也分为十进制表示法和科学技术表述法十进制表示法如：1.666 ,2.666floatt = 1.666科学技术表述法如:floatt = 12.02E1这需要换算算数运算+，-，*，/,++,--。在float中通常不进行自增和自减，而且也不支持(%)余运算fmt.Println(1.11 + 1.2) fmt.Println(1.11 - 1.2) fmt.Println(1.11 * 1.2) fmt.Println(1.11 / 1.2)运行结果[root@LinuxEA /opt/Golang]# go run float.go 2.31 -0.09 1.332 0.925与整数一样，被除数的不能为0自增和自减floatt = 1.063 floatt++ fmt.Println(floatt) floatt-- fmt.Println(floatt)运行结果[root@LinuxEA /opt/Golang]# go run float.go 2.0629999999999997 1.0629999999999997!!! note> 浮点数不是精确存储，在加减过程中会有一定的精度损耗。 > 如上述中的 1.063在运算后精度损耗会变大，打印时候是1.0629999999999997 关系运算由于有精度损耗，对于浮点数来说，不计算等于和不等于。 一般来讲之计算大于>，大于等于>=，小于<，小于等于<=，或者约等于~=fmt.Println(1.11 > 1.2) fmt.Println(1.11 >= 1.2) fmt.Println(1.11 < 1.2) fmt.Println(1.11 <= 1.2)运行结果[root@LinuxEA /opt/Golang]# go run float.go false false true true等于判断判断浮点数是否等于，可以先进行相减，而后在做比较区间值。如下：最终的判断取决于精确到的位数fmt.Println(1.11 - 1.2 <= 0.005)运行结果[root@LinuxEA /opt/Golang]# go run float.go true浮点数是没有位运算的，直接看赋值运算赋值运算等于=，加等于+=，减等于-=，乘等于*=，除等于/= floatt = 1.063 floatt += 2.25 fmt.Println(floatt) floatt -= 2.25 fmt.Println(floatt) floatt *= 2 fmt.Println(floatt) floatt /= 2 fmt.Println(floatt)运行结果[root@LinuxEA /opt/Golang]# go run float.go 3.3129999999999997 1.0629999999999997 2.1259999999999994 1.0629999999999997类型转换我们知道，默认的是float64。现在转到float32。float32(zsh) 转换到float32zsh := 1.16389366 fmt.Printf("%T %T\n",zsh,float32(zsh)) fmt.Println(zsh,float32(zsh))运行[root@LinuxEA /opt/Golang]# go run float.go float64 float32 1.16389366 1.1638937!!! Warning>如果数据太大，转换后会进行截断 保留数比如，现在我要保留五位，并且包含3个小数点-%5.3f。如下：如果小数点和位数不满足，将用空格替代fmt.Printf("%5.3f\n",zsh)运行[root@LinuxEA /opt/Golang]# go run float.go 1.164complex复数Go提供了两种大小的复数类型：complex64和complex128，分别由float32和float64组成。内置函数complex从指定的实部和虚部构建复数，内置函数real和imag用来获取复数的实部和虚部：如果一个浮点数的字面量后面跟着一个i，例如2i，那么它将变成一个复数的虚部，这个复数的实部是0： ii := 1 + 2i fmt.Printf("%T %v",ii,ii)运行[root@marksugar /opt/Golang]# go run float.go complex128 (1+2i)complex128是指实部和虚部都使用的是float64

linuxea:go数值类型(8) 整型，go提供了5种有符号，5种无符号，1种指针，1种单字节，一种单个unicode字符(unicode码点)，共13种整数类型，零值均为0.标识符：int,uint,rune,int8,int16,int32,int64,uint8,uint16,uint32,uint64,byte,uintptr,其中最为常用的是int类型，rune是单个unicode字符(unicode码点),int8表示8位的Int类型，int16表示int 16位等等。u开头的是无符号，uint8是无符号int8位，uint16是无符号int16位等等。byte一个字节，八位。uintptr是指针类型，与系统有关。有符号的，0表示正数，1表示负数。表示范围8字节是2^7-2^7-1；无符号表示正数，表示范围是0-2^8-1是256.intpackage main import "fmt" func main(){ var age int = 18 fmt.Printf("%T %d",age,age) // int 18 }打印类型和数值%T和%d。fmt.Printf("%T %d",age,age)算数运算加减乘除余除数不能为0 fmt.Println(9 - 5) //4 fmt.Println(3 * 3) //9 fmt.Println(3 + 3) //6 fmt.Println(9 / 2) //4 fmt.Println(9 % 2) //1自增和自减++加1，-- 减1package main import "fmt" func main(){ var age int = 18 age = 18 age++ fmt.Printf("age++:%d\n",age) age-- fmt.Printf("age--:%d\n",age) }运行[root@LinuxEA /opt/Golang]# go run int.go age++:19 age--:18关系运算==等于，!=不等于,>大于，>=大于等于,<小于,<=小于等于package main import "fmt" func main(){ fmt.Println(1 == 1) fmt.Println(2 != 1) fmt.Println(2 > 3) fmt.Println(2 >= 3) fmt.Println(2 < 3) fmt.Println(2 <= 3) }运行结果true true false false true true位运算位运算实际上是对二进制进行计算，10进制需要转换成二进制进行计算& 与 ，|或 ，^亦或， <<左移，>>右移，&^按位清空 fmt.Println(7 & 2) // 2 fmt.Println(7 | 2) // 7 fmt.Println(7 ^ 2) // 5 fmt.Println(7 << 2) // 28 fmt.Println(7 >> 2) // 1 fmt.Println(7 &^ 2) // 5这里使用了辗转相除法也可以运算。赋值运算赋值同时可以进行计算，如,=,+=，-=，*=，/=，%=，&=，|=，<<=,>>==,&^=a+b 等于 a = a+b age = 1 age += 3 fmt.Println(age) // 1+3=4 age -= 2 fmt.Println(age) // 4-2=2 类型转换如果两个不同的类型进行运算的时候就需要进行强转换。如果不进行转换就会出错 var int1 int = 10 var int2 uint = 2 fmt.Println(int1 + int2)当运行时候会抛出错误[root@LinuxEA /opt/Golang]# go run int.go # command-line-arguments ./int.go:44:19: invalid operation: int1 + int2 (mismatched types int and uint)这时候必须将两个变量的类型转换一致，且不管是int或者uint，只要一致即可。如下： var int1 int = 10 var int2 uint = 2 fmt.Println(int1 + int(int2)) // int2的uint转换成int fmt.Println(uint(int1) + int2) // int1的int转换成uint fmt.Printf("%T %T",int1,int2) // int uint运行[root@LinuxEA /opt/Golang]# go run int.go 12 12 int uint注意我们需要注意的是，当一个int32转换成int8的时候，可能会出现溢出。或者如下的16进制转换： var int3 int = 0XFFFF fmt.Println(int3) // 65535 fmt.Println(uint8(int3)) // 255 fmt.Println(int8(int3)) // -1 fmt.Printf("%T",int3) // int从大向小转换的时候就可能会出现溢出的问题。字节与码点byte是字节，rune表示码点。这两个在赋值的时候可以使用单引号，而int也可以实现，不过int使用的是十进制。当然，byte和rune也是int类型 var a byte = 'A' var b rune = '测' fmt.Println(a,b) // 65 27979 fmt.Printf("%T %T",a,b) // uint8 int32对于码点的打印使用%U，使用%q打印字面量的值fmt.Printf("%q %q",a,b) // 'A' U+6D4B这里可以做个简单的转换，二进制使用%b,八进制%o，十六进制%xage = 17 fmt.Printf("%T %d %b %o %x\n",age,age,age,age,age) // int 17 10001 21 11

linuxea:go布尔类型(7) 布尔类型用于表示真假，类型名为bool，只有两个值,分别是true和false。0值默认是falsepackage main import "fmt" func main(){ var hhlo bool helo := true hell := false fmt.Println(hhlo,helo,hell) }运行[root@LinuxEA /opt/Golang]# go run bool.go false true falsetrue表示真，false表示假，零值为false，字面量也是true/false布尔操作逻辑运算逻辑运算有三个，与，或，非。与&&，或||，非！与：abool && bbool，当两个都为true的时候，结果为true。如果有一个结果为false就不是true.或：abool || bbool，只要有一个为true的时候，结果就为true。非：!true，取反。!true非true，也就是false；!false非false，也就是true；可以是字面量，也可以是变量。关系运算关系运算的结果也是true和false. (==,!=)，等于和不等于。 helo := true hell := false fmt.Println(helo != hell) // true fmt.Println(helo == hell) // false