GO语言的进阶之路-Golang字符串处理以及文件操作

　　　　　　　　　　　　　　　　　　　GO语言的进阶之路-Golang字符串处理以及文件操作

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

 

　　我们都知道Golang是一门强类型的语言，相比Python在处理一些并发问题也是有过之而无不及，甚至可以说远远的甩python几条街。学过python基础或是shell的童鞋应该知道我们在定义一个变量的时候是不需要指定其所属数据类型的，直接让其等于一个变量即可，他们的解释器会自动识别你定义的是个整数，浮点数，字符串，还是数组或是函数。而Golang在定义每个变量的时候都被指定了数据类型，如果你给这个变量定义的是数字类型，你把它的指针指向字符串的话就会报错！接下来，让我们先看看，整数，常量，字符串，运算符等基础的数据类型吧，本文还会介绍Golang的循环控制以及文件处理等常用的操作。

 　　当然我这里只是介绍了Golang的冰山一角，对Golang感兴趣的小伙伴，可以看一下Golang官网的文档说明。毕竟官方才是最权威的，给出国内地址：https://golang.org/pkg/

 

一.整数

1.int与uint的初值比较以及其大小。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 '''
 9 [root@yinzhengjie day3]# more myint.go
10 package main
11 
12 import (
13         "fmt"
14         "unsafe"
15 )
16 
17 func main()  {
18         var  (
19                 a int //包括所有的整数
20                 b int8 //取值个数2^8,取之范围（-128）-(127)
21                 c int16
22                 d int32 //取值个数：2^32，取值范围：(-2^16)-(2^16-1)
23                 e int64
24                 x uint  //其中这个"u"，即：unsigned。表示无符号，即只能表示0和所有的正整数。
25                 y uint8
26                 z uint16
27                 p uint32 //取之个数：2^32，取之范围0-2^32-1
28                 q uint64
29         )
30         fmt.Println("A=",a,"size=",unsafe.Sizeof(a))
31         fmt.Println("B=",b,"size=",unsafe.Sizeof(b))
32         fmt.Println("C=",c,"size=",unsafe.Sizeof(c))
33         fmt.Println("D=",d,"size=",unsafe.Sizeof(d))
34         fmt.Println("E=",e,"size=",unsafe.Sizeof(e))
35         fmt.Println("X=",x,"size=",unsafe.Sizeof(x))
36         fmt.Println("Y=",y,"size=",unsafe.Sizeof(y))
37         fmt.Println("Z=",z,"size=",unsafe.Sizeof(z))
38         fmt.Println("P=",p,"size=",unsafe.Sizeof(p))
39         fmt.Println("Q=",q,"size=",unsafe.Sizeof(q))
40 }
41 
42 [root@yinzhengjie day3]#
43 [root@yinzhengjie day3]# go run myint.go 
44 A= 0 size= 8
45 B= 0 size= 1
46 C= 0 size= 2
47 D= 0 size= 4
48 E= 0 size= 8
49 X= 0 size= 8
50 Y= 0 size= 1
51 Z= 0 size= 2
52 P= 0 size= 4
53 Q= 0 size= 8
54 [root@yinzhengjie day3]# 
55 
56 '''

 2.常量(关键字：const )的定义

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12 )
13 
14 const (  //"const"关键字是定义一个常量。
15     PI = 3.1415926
16     E = 2.0
17     g = 9.8
18 )
19 
20 const  (
21     RED = 10 * iota //"iota"关键字帮你自动从0，1,2......依次开始递增
22     GREEN
23     BLUE
24 )
25 
26 func main()  {
27     fmt.Println(RED,GREEN,BLUE)
28     var (
29         n int
30         f float32
31         f_1 float32
32     )
33     n = 10
34     f = float32(n) / 3 //"n=10"属于“int”类型，int是整数类型，float32是浮点数类型，两者必须转换成一致的，不然会报错。因为Golang是强类型语言。这也是它的特点之一。
35     fmt.Println(f,n)
36     f_1 = float32(n / 3)  //"n / 3"的结果是"3",因为int的类型是个整数，所以被整数三除了之后应该还是整数。
37     fmt.Println(f_1)
38     fmt.Println(f_1 * 3)
39     n = int(f_1 * 3) //同左不同右，我们可以把右边的float32类型转换成int类型
40     fmt.Println(n)
41     var  (
42         n1 int64
43         n2 int8
44     )
45     n1 = 2222222221024004
46     n2 = int8(n1) //要注意的是int8的取值范围是[-128到127]，总共255个数字。它会从这个数组的从右往左取数字，最多也就占3位，尽管你前面有再多的数字对其都是无用的。
47     fmt.Println(n1,n2)
48 
49     n1 = 1024129
50     n2 = int8(n1) //看完上面的例子你也，你也应该明白了，在其取值范围是会取得这个数字，如果不在的话渠道的数字也是有问题的！(数字128已经超出其正数的取值范围，它又从-128到0这个段开始取值。)因此在转换的时候要留心哟。
51     fmt.Println(n1,n2)
52 }
53 
54 
55 #以上代码输出结果如下：
56 0 10 20
57 3.3333333 10
58 3
59 9
60 9
61 2222222221024004 4
62 1024129 -127

3.关于int的取值范围扩充。

4.将数字转换成字符串

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12     "strconv"
13     "reflect"
14 )
15 
16 
17 func main()  {
18 
19     var (
20         s string
21         x = 100
22     )
23     s = strconv.Itoa(x) //将一个整数转换成字符串的方法
24     fmt.Println("转换前的类型",reflect.TypeOf(x))
25     fmt.Println("我是转换后的字符串：",s)
26     fmt.Println("转换后的类型",reflect.TypeOf(s))
27 
28 }
29 
30 
31 #以上代码输出结果如下：
32 转换前的类型 int
33 我是转换后的字符串： 100
34 转换后的类型 string

 5.生成随机字符串案例

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 //世界上只有10种人，一种是懂二进制，一种是不懂二进制。
 9 package main
10 
11 import (
12     "math/rand"
13     "time"
14     "strconv"
15     "fmt"
16 )
17 
18 var  x int64
19 var  s string
20 
21 func main()  {
22     rand.Seed(time.Now().Unix())
23     x = rand.Int63()
24     s = strconv.FormatInt(x,36) //表示用36进制来计算x的值。
25     fmt.Println(s) //我们可以在这里对字符串做切片操作，这样就可以随机获取到我们想要到字符了。
26 }
27 
28 
29 
30 #以上代码直接结果如下：
31 p7d8bbl6rjy4

 

二.字符串

1.字符串花式定义玩法以及注释操作

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 '''
 9 [root@yinzhengjie day3]# more str_note.go 
10 package main
11 
12 import (
13         "fmt"
14 )
15 
16 func main()  {
17         str1 := "yinzhengjie\thave a apple!" //"\t"表示制表符，会根据操作系统自动空出几个空格。
18         doc :=`  //定义多行注释
19 111
20         222
21         3333
22         `
23         x := "hello\\world" //转移用"／"
24         y := "您好，尹正杰！\a" //在终端执行电脑会响.在IDE上执行可能不会有声音哟！
25         z := "####1\b2222" //"\b"表示退格键，会把"\b"前面的一个字符给删除掉，即打印的时候会删除数字"1"
26         fmt.Println(str1)
27         fmt.Println(doc)
28         fmt.Println(x)
29         fmt.Println(y)
30         fmt.Println(z)
31 }
32 
33 //本行是单行注释，下面到结尾是多行注释。
34 /*
35 I have a pen
36 I have an apple
37 I have a pen and i have an apple!
38 */
39 
40 [root@yinzhengjie day3]# 
41 [root@yinzhengjie day3]# go run str_note.go  //如果你是在终端执行的话，或者windows用crt远程linux服务器，每次执行该脚本的时候都会出现系统提示音，前提是你的声卡要正常！
42 yinzhengjie     have a apple!
43   //定义多行注释
44 111
45         222
46         3333
47 
48 hello\world
49 您好，尹正杰！
50 ####2222
51 [root@yinzhengjie day3]# 
52 
53 '''

2.字符串操作

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 '''
 9 [root@yinzhengjie day3]# more str_manipulation.go 
10 package main
11 
12 
13 
14 /*
15 字符串修改：
16 1.单引号是字符，双引号是字符串；
17 2.字符串本身不可以修改；
18 3.通过跟"[]byte"数组相互转换来修改；
19 */
20 
21 import (
22         "fmt"
23 )
24 
25 func main()  {
26         str1 := "yinzhengjie" + "world" //拼接
27         fmt.Println(str1)
28 
29         var  str2 byte  //1个字节（byte）=8个比特位（bits），因此byte = uint8
30         str2 = str1[0] //取字符
31         fmt.Println(str2)
32         fmt.Printf("数字：%d 字符：%c\n",str2,str2) //表示字符"y"在ASCII表中对应的数字。printf不会换行但是prin
33 tln会自动换行。
34 
35         str3 := str1[0:11] //切片,顾左不顾右，取0-10共11个字符，不会去知道第12个字符，即不会取到下标为11第字符
36 "w"
37         fmt.Println(str3)
38 
39         str4 := str1[11:len(str1)]
40         fmt.Println(str4)
41 
42         var b uint8 //我们这里也可以把unit8写成byte，其实是等效的。
43         for b = 0;b < 177 ;b++  {
44                 fmt.Printf("%d %c\n",b,b)
45         }
46         array := []byte(str1) //将字符串转换成byte数组，可以理解成为python中的list.
47         fmt.Println(array)
48         array[0] = 72 //也可以写字符'H',在ASCII中他们是一一对应的
49         str1 = string(array)
50         fmt.Println(str1)
51 
52         fmt.Println('a' + ('H' - 'h')) //其实就是这些字符在ASCII中的数字相加减，得到的数字为65。
53         fmt.Println(0xa) //表示16进制数字a在ASCII所对应的数字
54 
55 
56 }
57 [root@yinzhengjie day3]# 
58 
59 '''

3.判断变量的数据类型

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[email protected]
*/

package main

import (
    "fmt"
    "reflect"
)

func main()  {
    str1 := "yinzhengjie" + " hello"
    fmt.Println(reflect.TypeOf(str1))  //判断变量“str1”的数据类型
    fmt.Println(str1)
    var   str2 byte
    str2 = str1[0] //让str2=字母"y"在ASCII编码中所对应的数字"121"(我说的说的是十进制的哟)
    fmt.Println(str2)
    fmt.Println(reflect.TypeOf(str2))  //判断变量"str2"的数据类型
}


/*
string
yinzhengjie hello
121
uint8

*/

 

4.提升逼格的linux命令

　　这个知识点大家可以不看，如果对linux不感兴趣的话，可以直接跳过，直接看下面的小试牛刀。如果你看到了一堆“10”你会想到是什么呢？在不眼里可能就是一个数字“10”，但是在一些程序员或者说在黑客眼里，这个“10”是2个数字，即“1”和“0”，是二进制的两个数字。在unix操作系统中，包括所有的Linux发现版本和mac都是可以用一个命令来查看文件内容的，他能把文件中的内容翻译成“1001010”类似这种的代码，也是一些开发人员的装逼利器：“xxd”，如果用这个命令呢?展示方法如下：

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 '''
 9 [root@yinzhengjie day3]# xxd str_manipulation.go 
10 0000000: 7061 636b 6167 6520 6d61 696e 0a0a 0a0a  package main....
11 0000010: 2f2a 0ae5 ad97 e7ac a6e4 b8b2 e4bf aee6  /*..............
12 0000020: 94b9 efbc 9a0a 312e e58d 95e5 bc95 e58f  ......1.........
13 0000030: b7e6 98af e5ad 97e7 aca6 efbc 8ce5 8f8c  ................
14 0000040: e5bc 95e5 8fb7 e698 afe5 ad97 e7ac a6e4  ................
15 0000050: b8b2 efbc 9b0a 322e e5ad 97e7 aca6 e4b8  ......2.........
16 0000060: b2e6 9cac e8ba abe4 b88d e58f afe4 bba5  ................
17 0000070: e4bf aee6 94b9 efbc 9b0a 332e e980 9ae8  ..........3.....
18 0000080: bf87 e8b7 9f22 5b5d 6279 7465 22e6 95b0  ....."[]byte"...
19 0000090: e7bb 84e7 9bb8 e4ba 92e8 bdac e68d a2e6  ................
20 00000a0: 9da5 e4bf aee6 94b9 efbc 9b0a 2a2f 0a0a  ............*/..
21 00000b0: 696d 706f 7274 2028 0a09 2266 6d74 220a  import (.."fmt".
22 00000c0: 290a 0a66 756e 6320 6d61 696e 2829 2020  )..func main()  
23 00000d0: 7b0a 0973 7472 3120 3a3d 2022 7969 6e7a  {..str1 := "yinz
24 00000e0: 6865 6e67 6a69 6522 202b 2022 776f 726c  hengjie" + "worl
25 00000f0: 6422 202f 2fe6 8bbc e68e a50a 0966 6d74  d" //........fmt
26 0000100: 2e50 7269 6e74 6c6e 2873 7472 3129 0a0a  .Println(str1)..
27 0000110: 0976 6172 2020 7374 7232 2062 7974 6520  .var  str2 byte 
28 0000120: 202f 2f31 e4b8 aae5 ad97 e88a 82ef bc88   //1............
29 0000130: 6279 7465 efbc 893d 38e4 b8aa e6af 94e7  byte...=8.......
30 0000140: 89b9 e4bd 8def bc88 6269 7473 efbc 89ef  ........bits....
31 0000150: bc8c e59b a0e6 ada4 6279 7465 203d 2075  ........byte = u
32 0000160: 696e 7438 0a09 7374 7232 203d 2073 7472  int8..str2 = str
33 0000170: 315b 305d 202f 2fe5 8f96 e5ad 97e7 aca6  1[0] //.........
34 0000180: 0a09 666d 742e 5072 696e 746c 6e28 7374  ..fmt.Println(st
35 0000190: 7232 290a 0966 6d74 2e50 7269 6e74 6628  r2)..fmt.Printf(
36 00001a0: 22e6 95b0 e5ad 97ef bc9a 2564 20e5 ad97  ".........%d ...
37 00001b0: e7ac a6ef bc9a 2563 5c6e 222c 7374 7232  ......%c\n",str2
38 00001c0: 2c73 7472 3229 202f 2fe8 a1a8 e7a4 bae5  ,str2) //.......
39 00001d0: ad97 e7ac a622 7922 e59c a841 5343 4949  ....."y"...ASCII
40 00001e0: e8a1 a8e4 b8ad e5af b9e5 ba94 e79a 84e6  ................
41 00001f0: 95b0 e5ad 97e3 8082 7072 696e 7466 e4b8  ........printf..
42 0000200: 8de4 bc9a e68d a2e8 a18c e4bd 86e6 98af  ................
43 0000210: 7072 696e 746c 6ee4 bc9a e887 aae5 8aa8  println.........
44 0000220: e68d a2e8 a18c e380 820a 0a09 7374 7233  ............str3
45 0000230: 203a 3d20 7374 7231 5b30 3a31 315d 202f   := str1[0:11] /
46 0000240: 2fe5 8887 e789 872c e9a1 bee5 b7a6 e4b8  /......,........
47 0000250: 8de9 a1be e58f b3ef bc8c e58f 9630 2d31  .............0-1
48 0000260: 30e5 85b1 3131 e4b8 aae5 ad97 e7ac a6ef  0...11..........
49 0000270: bc8c e4b8 8de4 bc9a e58e bbe7 9fa5 e981  ................
50 0000280: 93e7 acac 3132 e4b8 aae5 ad97 e7ac a6ef  ....12..........
51 0000290: bc8c e58d b3e4 b88d e4bc 9ae5 8f96 e588  ................
52 00002a0: b0e4 b88b e6a0 87e4 b8ba 3131 e7ac ace5  ..........11....
53 00002b0: ad97 e7ac a622 7722 0a09 666d 742e 5072  ....."w"..fmt.Pr
54 00002c0: 696e 746c 6e28 7374 7233 290a 0a09 7374  intln(str3)...st
55 00002d0: 7234 203a 3d20 7374 7231 5b31 313a 6c65  r4 := str1[11:le
56 00002e0: 6e28 7374 7231 295d 0a09 666d 742e 5072  n(str1)]..fmt.Pr
57 00002f0: 696e 746c 6e28 7374 7234 290a 0a09 7661  intln(str4)...va
58 0000300: 7220 6220 7569 6e74 3820 2f2f e688 91e4  r b uint8 //....
59 0000310: bbac e8bf 99e9 878c e4b9 9fe5 8faf e4bb  ................
60 0000320: a5e6 8a8a 756e 6974 38e5 8699 e688 9062  ....unit8......b
61 0000330: 7974 65ef bc8c e585 b6e5 ae9e e698 afe7  yte.............
62 0000340: ad89 e695 88e7 9a84 e380 820a 0966 6f72  .............for
63 0000350: 2062 203d 2030 3b62 203c 2031 3737 203b   b = 0;b < 177 ;
64 0000360: 622b 2b20 207b 0a09 0966 6d74 2e50 7269  b++  {...fmt.Pri
65 0000370: 6e74 6628 2225 6420 2563 5c6e 222c 622c  ntf("%d %c\n",b,
66 0000380: 6229 0a09 7d0a 0961 7272 6179 203a 3d20  b)..}..array := 
67 0000390: 5b5d 6279 7465 2873 7472 3129 202f 2fe5  []byte(str1) //.
68 00003a0: b086 e5ad 97e7 aca6 e4b8 b2e8 bdac e68d  ................
69 00003b0: a2e6 8890 6279 7465 e695 b0e7 bb84 efbc  ....byte........
70 00003c0: 8ce5 8faf e4bb a5e7 9086 e8a7 a3e6 8890  ................
71 00003d0: e4b8 ba70 7974 686f 6ee4 b8ad e79a 846c  ...python......l
72 00003e0: 6973 742e 0a09 666d 742e 5072 696e 746c  ist...fmt.Printl
73 00003f0: 6e28 6172 7261 7929 0a09 6172 7261 795b  n(array)..array[
74 0000400: 305d 203d 2037 3220 2f2f e4b9 9fe5 8faf  0] = 72 //......
75 0000410: e4bb a5e5 8699 e5ad 97e7 aca6 2748 272c  ............'H',
76 0000420: e59c a841 5343 4949 e4b8 ade4 bb96 e4bb  ...ASCII........
77 0000430: ace6 98af e4b8 80e4 b880 e5af b9e5 ba94  ................
78 0000440: e79a 840a 0973 7472 3120 3d20 7374 7269  .....str1 = stri
79 0000450: 6e67 2861 7272 6179 290a 0966 6d74 2e50  ng(array)..fmt.P
80 0000460: 7269 6e74 6c6e 2873 7472 3129 0a0a 0966  rintln(str1)...f
81 0000470: 6d74 2e50 7269 6e74 6c6e 2827 6127 202b  mt.Println('a' +
82 0000480: 2028 2748 2720 2d20 2768 2729 2920 2f2f   ('H' - 'h')) //
83 0000490: e585 b6e5 ae9e e5b0 b1e6 98af e8bf 99e4  ................
84 00004a0: ba9b e5ad 97e7 aca6 e59c a841 5343 4949  ...........ASCII
85 00004b0: e4b8 ade7 9a84 e695 b0e5 ad97 e79b b8e5  ................
86 00004c0: 8aa0 e587 8fef bc8c e5be 97e5 88b0 e79a  ................
87 00004d0: 84e6 95b0 e5ad 97e4 b8ba 3635 e380 820a  ..........65....
88 00004e0: 0966 6d74 2e50 7269 6e74 6c6e 2830 7861  .fmt.Println(0xa
89 00004f0: 2920 2f2f e8a1 a8e7 a4ba 3136 e8bf 9be5  ) //......16....
90 0000500: 88b6 e695 b0e5 ad97 61e5 9ca8 4153 4349  ........a...ASCI
91 0000510: 49e6 8980 e5af b9e5 ba94 e79a 84e6 95b0  I...............
92 0000520: e5ad 970a 0a0a 7d0a                      ......}.
93 [root@yinzhengjie day3]# 
94 
95 '''

xxd命令用法展示

5.小试牛刀

A.用Golang语言实现将小写字母转换成大写字母。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 '''
 9 [root@yinzhengjie day3]# more uppercase.go
10 package main
11 
12 import "fmt"
13 
14 func main() {
15         topper("yinzhengjie") //我们在调用函数的时候输入的是小写字母
16 }
17 
18 func topper(s string) string { //后面的string表示返回值的类型。
19         array := []byte(s) //将字符串转换成字节
20         var (
21                 i   int
22                 res string
23         )
24         for i = 0; i < len(s); i++ {
25                 fmt.Printf(string(array[i] - 32)) //格式化输出，将每一次循环的变量i都保存下来。如果不敲击这一
26 行默认只会保留最后一次循环的值.
27                 res = string(array[i] - 32) //将字节转换成字符串并赋值给res字符串.
28         }
29         fmt.Println(res)
30         return res
31 }
32 [root@yinzhengjie day3]#
33 [root@yinzhengjie day3]#
34 [root@yinzhengjie day3]# go run uppercase.go  //实现结果如下
35 YINZHENGJIEE
36 [root@yinzhengjie day3]#
37 '''

　　以上代码你看起来可能特别简单，而且思路不严谨，没有判断字母大小写就同意转换成大写的操作！那么如何优化呢？请看下面的代码，稍微做了一下优化的代码风格就有所改变。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 '''
 9 [root@yinzhengjie day3]# more lower_upper.go 
10 package main
11 
12 import "fmt"
13 
14 func main() {
15         topper("yinzhengjie") //我们在调用函数的时候输入的是小写字母
16 
17 }
18 
19 func topper(s string) string {
20         num := []byte(s) //将传入的字符串转换成字节所对应的数字的数组。
21         for i,v := range num { //循环这个数组
22                 if v >= 'a' && v <= 'z' { //判断这个数字的值是否为小写
23                         num[i] = v - 32  //如果是小姐，就根据ASCII编码表的位置关系，将其转换成大写。
24                 }
25         }
26         fmt.Println(string(num)) 
27         return string(num)  //返回这个数组，通过ASCII编码表中的数字找到对应的字符串并返回。
28 }
29 [root@yinzhengjie day3]# 
30 [root@yinzhengjie day3]# 
31 [root@yinzhengjie day3]# go run lower_upper.go 
32 YINZHENGJIE
33 [root@yinzhengjie day3]# 
34 '''

B.用Golang语言试下将字母的顺序颠倒，专业术语叫反转。

 　　在写这个小程序之前我们需要了解一下rune这个包，大家都知道byte,众所周知的字节，一个字节等于八个比特位，一个比特位存着响应的字母或是数字以及一些特殊符号等等，但是存取中国的汉字一个字节是远远不够的，可能用到三到四个字节进行存取的，所以我们之前将字母小写转换成大写就不好使了。因为你会发现自己是取不到下表的，一个汉字需要三个字节存取，你想读取汉字的时候必须也得取三个字节才能读到这个汉字，如果只取一个字节的话就会乱码。当然知道这个原理后我用byte也实现了反转的功能，但是真的太麻烦了（随着汉字的数量不同，我得判断字节循环的起点数量）。我找到了rune这个包，真的很好使，话不多说，我们直接上代码对比一下输出结果您就清楚了。代码请点击下面的小标题。

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "reflect"
 6 )
 7 
 8 func main() {
 9     yzj := "尹正杰ABCD"
10     yzj2 := []rune(yzj) //rune类型
11     yzj3 := []byte(yzj) //byte类型
12     for k, v := range yzj {
13         fmt.Println(k, "=字符串遍历=>", v)
14     }
15     for k, v := range yzj2 {
16         fmt.Println(k, "=rune遍历=>", v)
17     }
18     for k, v := range yzj3 {
19         fmt.Println(k, "=byte遍历=>", v)
20     }
21     fmt.Println("让我们来一起看看'byte'的数据类型吧：",reflect.TypeOf(yzj3))
22     fmt.Println("让我们来一起看看'rune'的数据类型吧：",reflect.TypeOf(yzj2))
23 }
24 
25 
26 
27 
28 #以上代码执行结果如下：
29 0 =字符串遍历=> 23609
30 3 =字符串遍历=> 27491
31 6 =字符串遍历=> 26480
32 9 =字符串遍历=> 65
33 10 =字符串遍历=> 66
34 11 =字符串遍历=> 67
35 12 =字符串遍历=> 68
36 0 =rune遍历=> 23609
37 1 =rune遍历=> 27491
38 2 =rune遍历=> 26480
39 3 =rune遍历=> 65
40 4 =rune遍历=> 66
41 5 =rune遍历=> 67
42 6 =rune遍历=> 68
43 0 =byte遍历=> 229
44 1 =byte遍历=> 176
45 2 =byte遍历=> 185
46 3 =byte遍历=> 230
47 4 =byte遍历=> 173
48 5 =byte遍历=> 163
49 6 =byte遍历=> 230
50 7 =byte遍历=> 157
51 8 =byte遍历=> 176
52 9 =byte遍历=> 65
53 10 =byte遍历=> 66
54 11 =byte遍历=> 67
55 12 =byte遍历=> 68
56 让我们来一起看看'byte'的数据类型吧： []uint8
57 让我们来一起看看'rune'的数据类型吧： []int32

对比string，byte，rune存取汉字的方式

 

姿势一：用rune实现将字符倒着打印即可完成反转功能

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import "fmt"
11 
12 func main()  {
13     yzj := "尹正杰world欢迎你"
14     yzj2 := []rune(yzj) //rune类型
15     for i := len(yzj2) - 1; i >= 0; i-- {  //从最后一个字符开始倒着打印
16         fmt.Printf(string(yzj2[i]))
17     }
18 }
19 
20 
21 
22 
23 #以上代码执行结果如下：
24 你迎欢dlrow杰正尹

姿势二:思路和姿势一一样，知识角度不同（咳咳，我说的角度知识换了一个循环方式而已）

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import "fmt"
11 
12 func main()  {
13     yzj := "尹正杰Glang"
14     yzj2 := []rune(yzj) //rune类型
15     for k := range yzj2 { //利用数字循环倒着打印，思路跟姿势一一样
16         fmt.Printf(string(yzj2[len(yzj2)-k-1]))
17     }
18 }
19 
20 
21 #以上代码执行结果如下：
22 gnalG杰正尹

姿势三：“69”互换，“咳咳，严格的来说应该是首末互换”，有两行代码被我注释掉了，大家可以把它注释取消掉，然后就能亲手体会这种感觉了。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 
 9 package main
10 
11 import (
12     "fmt"
13 )
14 
15 func main()  {
16     strs := "北京欢迎你"
17     num  := []rune(strs)
18     lang := len(num)
19     //fmt.Println(num)
20     for i,j := 0,lang-1;i这种思路就是把最后一个字符和第一个字符互换，循环到最中间的那个就不做任何操作
21         //fmt.Println(i,j)
22         num[i],num[j] = num[j],num[i]
23     }
24     fmt.Println(string(num))
25 }
26 
27 
28 
29 #以上代码执行结果如下：
30 你迎欢京北

　　相比通过这个小程序，发现Golang的for循环很好玩吧。下面跟着我一起来学习一下Golang的for循环吧。

 

三.循环语句

　　说道循环，那Golang里面的姿势可多了，得给你涨涨经验了，光我所知道的就有4种，别问我最喜欢那种姿势，这个你得用手去感受，用心去体会，别想歪啊，我是说用手去敲代码感受，用心去研究那种循环的姿势最适合你。话不多收我们开干吧！

1.姿势一：这种循环玩shell的童鞋一看便知。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 
11 import (
12     "fmt"
13 )
14 
15 func main()  {
16     for i := 0;i <= 5 ;i++  {
17         fmt.Println(i)
18     }
19 }
20 
21 
22 
23 
24 
25 #以上代码输出结果如下：
26 0
27 1
28 2
29 3
30 4
31 5

2.姿势二:类似python中的while循环

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 
11 import (
12     "fmt"
13 )
14 
15 func main()  {
16     i := 1
17     for i < 10 {
18         fmt.Println(i)
19         i = i + 2
20     }
21 }
22 
23 
24 #以上代码执行结果如下：
25 1
26 3
27 5
28 7
29 9

3.姿势三：类似于python中的while循环

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 
11 import (
12 "fmt"
13 )
14 
15 func main()  {
16     i := 8
17     for {
18         i = i + 1
19         fmt.Println(i)
20         if i > 10 {
21             break
22         }
23 
24     }
25 }
26 
27 
28 #以上代码执行结果如下：
29 9
30 10
31 11

 

4.姿势四:遍历数组循环.

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 
11 import (
12     "fmt"
13 
14 )
15 
16 func main()  {
17     s := "尹正杰2017"
18     for i,arg := range s {
19         fmt.Printf("%d %c\n",i,arg)
20     }
21 }
22 
23 
24 
25 
26 #以上代码执行结果如下：
27 0 尹
28 3 正
29 6 杰
30 9 2
31 10 0
32 11 1
33 12 7

 

四.条件判断

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "strconv"
12     "fmt"
13 )
14 //注意："strconv.Atoi"只能讲数字转换成字符串，如果不是纯数字的字符串是没法发转换的哟。
15 func main()  {
16     s := "尹正杰2017"
17     n,err := strconv.Atoi(s) //用"n"和"err"两个参数来接受“strconv.Atoi”的值，如果正常就把值传给变量"n",如果异常就把值传给"err"。
18     if err != nil { //如果错误信息不为空，那么就执行大括号的代码。
19         fmt.Println("'strconv.Atoi'传入的参数有问题哟！看报错内容是>>>:",err) //将接受的错误信息打印出来。
20         return //出现这行代码就不会往下走啦，直接就终止这个函数了。
21     }
22     fmt.Println(n)
23     fmt.Println("1111")
24 }
25 
26 
27 
28 
29 
30 #以上代码执行结果如下：
31 'strconv.Atoi'传入的参数有问题哟！看报错内容是>>>: strconv.Atoi: parsing "尹正杰2017": invalid syntax

 

五.运算符

　　其实运算符，这些知识都是小学三年级的朋友都会的，简单点的无非就是加减乘除，我不打算详细介绍，刚兴趣的童鞋可以去Golang官网去看看关于运算符的，我这里简单的协议一个最low的小程序给大家看最基础的小程序，好了，天黑了，大神请闭眼，小白请睁眼。小白你要跟我一起撸吗？来吧，别克制！

 1 [root@yinzhengjie day3]# gofmt myexpr.go 
 2 /*
 3 #!/usr/bin/env gorun
 4 @author :yinzhengjie
 5 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 6 EMAIL:[email protected]
 7 */
 8 
 9 package main
10 
11 import (
12         "fmt"
13         "os"
14         "strconv"
15 )
16 
17 func main() {
18         var (
19                 x int
20                 y int
21                 //res int
22         )
23         x, _ = strconv.Atoi(os.Args[1]) //将字符串转换成数字
24         y, _ = strconv.Atoi(os.Args[3])
25         switch os.Args[2] {
26         case "+":
27                 fmt.Printf("运算结果是：%d\n", x+y)
28         case "-":
29                 fmt.Printf("运算结果是：%d\n", x-y)
30         case "*":
31                 fmt.Printf("运算结果是：%d\n", x*y)
32         case "/":
33                 fmt.Printf("运算结果是：%d\n", x/y)
34         case "%":
35                 fmt.Printf("运算结果是：%d\n", x%y)
36         }
37         //fmt.Println(os.Args[1])
38 }
39 [root@yinzhengjie day3]# 
40 [root@yinzhengjie day3]# go run myexpr.go 11 + 22
41 运算结果是：33
42 [root@yinzhengjie day3]# go run myexpr.go 11 - 3
43 运算结果是：8
44 [root@yinzhengjie day3]# go run myexpr.go 11 \* 8
45 运算结果是：88
46 [root@yinzhengjie day3]# go run myexpr.go 11 / 3
47 运算结果是：3
48 [root@yinzhengjie day3]# go run myexpr.go 11 % 3
49 运算结果是：2
50 [root@yinzhengjie day3]# 

 

 六.文件操作

 1.文件的写入

a>.打开一个文件，如果没有就创建，如果有这个文件就清空文件内容（相当于python中的"w"）;

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "os"
12     "log"
13 )
14 
15 
16 
17 func main()  {
18     f,err := os.Create("a.txt") //姿势一：打开一个文件，如果没有就创建，如果有这个文件就清空文件内容,需要用两个变量接受相应的参数
19     if err != nil {
20         log.Fatal(err)
21     }
22     f.WriteString("yinzhengjie\n") //往文件写入相应的字符串。
23     f.Close()
24 }

b>.以追加的方式打开一个文件（相当于python中的"a"）;

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "os"
12     "log"
13 )
14 
15 
16 func main()  {
17     f,err := os.OpenFile("a.txt",os.O_APPEND|os.O_CREATE|os.O_RDWR,0644) //表示最佳的方式打开文件，如果不存在就创建，打开的模式是可读可写，权限是644
18     if err    != nil {
19         log.Fatal(err)
20     }
21     f.WriteString("yinzhengjie\n")
22     f.Close()
23 }

c>.修改文件内容-随机写入（自定义插入的位置，相当python重的seek方法）;

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "os"
12     "log"
13 )
14 
15 
16 func main()  {
17     f,err := os.OpenFile("a.txt",os.O_CREATE|os.O_RDWR,0644)
18     if err != nil {
19         log.Fatal(err)
20     }
21     f.WriteString("yinzhengjie\n")
22     f.Seek(1,os.SEEK_SET) //表示文件的其实位置，从第二个字符往后写入。
23     f.WriteString("$$$")
24     f.Close()
25 }

2.文件的读取

A>.顺序读取文件内容

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 
 9 package main
10 
11 import (
12     "os"
13     "bufio"
14     "io"
15     "fmt"
16     "log"
17 )
18 
19 //姿势一：读取文件内容
20 func main()  {
21     //f,err := os.OpenFile("a.txt",os.O_CREATE|os.O_RDWR,0644) //打开该文件，但是不建议用这行命令，用下面的专门用来读取文件的。
22     f,err := os.Open("a.txt") //打开一个文件，如果这个文件不存在的话就会报错。
23     if err != nil {
24         log.Fatal(err)
25     }
26     r := bufio.NewReader(f) //取出文件的内容
27     for {
28         line,err := r.ReadString('\n') //表示以"\n"为分隔符，遇到"\n"就换行。
29         if err == io.EOF{ //读到文件结尾后就终止文件。
30             break
31         }
32         fmt.Print(line)
33     }
34     f.Close()
35 }
36 
37 
38 
39 #以上代码执行结果如下：
40 y$$$hengjie
41 yinzhengjie

B>.随机读取文件内容

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 
 9 package main
10 
11 import (
12     "os"
13     "bufio"
14     "io"
15     "fmt"
16     "log"
17 )
18 
19 
20 func main()  {
21     f,err := os.OpenFile("yinzhengjie.txt",os.O_CREATE|os.O_RDWR,0644)
22     if err != nil {
23         log.Fatal(err)
24     }
25     r := bufio.NewReader(f)
26     for {
27         line,err := r.ReadString('\n') //表示以"\n"为分隔符，遇到"\n"就换行。
28         if err == io.EOF{ //读到文件结尾后就终止文件。因此如果你这么干了的话，你始终只能读取到第一行的内容
29             break
30         }
31         fmt.Print(line)
32     }
33     f.Close()
34 }
35 
36 
37 
38 #以上代码执行结果如下：
39 欢迎来到我的博客：http://www.cnblogs.com/yinzhengjie

C.用ioutil模块读取文件内容；

　　要注意的是ioutil下有个读取文件的方法，但是读取出来的都是bytes,因此你需要将bytes转换成字符串，然后才打印给用户才好使。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12     "io/ioutil"
13     "log"
14 )
15 
16 func main()  {
17     buf,err := ioutil.ReadFile("D:\\Golang环境\\Golang Program\\Golang lesson\\Day4\\单词.txt")
18     if err != nil {
19         log.Fatal(err)
20     }
21     fmt.Println(string(buf))
22 }
23 
24 
25 
26 #以上代码执行结果如下：
27    Scanner provides a convenient interface for reading data such as a file of newline-delimited lines of text Successive
28 calls to the Scan method will step through the tokens of a file skipping the bytes between the tokens The specification
29 of a token is defined by a split function of type SplitFunc the default split function breaks the input into lines with
30 line termination stripped Split functions are defined in this package for scanning a file into lines bytes UTF-8-encoded
31 runes and space-delimited words The client may instead provide a custom split function

 

3.小试牛刀

A.>.用Golang编写99乘法表；

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 
 9 package main
10 
11 import (
12     "fmt"
13     "os"
14     "log"
15 
16 )
17 
18 func main() {
19     var top int = 10
20     //f,err := os.Create("乘法表.txt")
21     f,err := os.OpenFile("乘法表.txt",os.O_CREATE|os.O_RDWR,0644)
22     if err != nil {
23         log.Fatal(err)
24     }
25     for i:=1; i {
26         for j := 1;j<=i;j++ {
27             fmt.Fprintf(f,"%d * %d = %2d\t", i , j, i*j)
28         }
29         fmt.Fprintln(f)
30     }
31     f.Close()
32 }

用Golang将九九乘法表写入到文件中

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 
 9 package main
10 
11 import (
12     "fmt"
13     "os"
14     "log"
15 
16     "bufio"
17     "io"
18 )
19 
20 func main()  {
21     f,err := os.Open("乘法表.txt") //打开一个文件，如果这个文件不存在的话就会报错。
22     if err != nil {
23         log.Fatal(err)
24     }
25     r := bufio.NewReader(f) //取出文件的内容
26     for {
27         line,err := r.ReadString('\n') //表示以"\n"为分隔符，遇到"\n"就换行。
28         if err == io.EOF{ //读到文件结尾后就终止文件。
29             break
30         }
31         fmt.Print(line)
32     }
33     f.Close()
34 }
35 
36 
37 
38 #以上代码执行结果如下：
39 1 * 1 =  1    
40 2 * 1 =  2    2 * 2 =  4    
41 3 * 1 =  3    3 * 2 =  6    3 * 3 =  9    
42 4 * 1 =  4    4 * 2 =  8    4 * 3 = 12    4 * 4 = 16    
43 5 * 1 =  5    5 * 2 = 10    5 * 3 = 15    5 * 4 = 20    5 * 5 = 25    
44 6 * 1 =  6    6 * 2 = 12    6 * 3 = 18    6 * 4 = 24    6 * 5 = 30    6 * 6 = 36    
45 7 * 1 =  7    7 * 2 = 14    7 * 3 = 21    7 * 4 = 28    7 * 5 = 35    7 * 6 = 42    7 * 7 = 49    
46 8 * 1 =  8    8 * 2 = 16    8 * 3 = 24    8 * 4 = 32    8 * 5 = 40    8 * 6 = 48    8 * 7 = 56    8 * 8 = 64    
47 9 * 1 =  9    9 * 2 = 18    9 * 3 = 27    9 * 4 = 36    9 * 5 = 45    9 * 6 = 54    9 * 7 = 63    9 * 8 = 72    9 * 9 = 81    

B>.模拟linux操作系统中的ls基础功能命令；

 1 [root@yinzhengjie day3]# gofmt ls.go 
 2 /*
 3 #!/usr/bin/env gorun
 4 @author :yinzhengjie
 5 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 6 EMAIL:[email protected]
 7 */
 8 
 9 package main
10 
11 import (
12         "fmt"
13         "log"
14         "os"
15 )
16 
17 func main() {
18         f, err := os.Open(os.Args[1]) //表示把该程序的第一个字符串传进去，就好像模拟简单的ls命令
19         if err != nil {
20                 log.Fatal(err)
21         }
22         infos, _ := f.Readdir(-1) //表示列出所有的文件或目录
23         for _, info := range infos {
24                 fmt.Printf("是否为目录：%V ；文件或者目录大小：%d；目录名称是：%s\n", info.IsDir(), info.Size(), info.Name())
25         }
26         f.Close()
27 }
28 [root@yinzhengjie day3]# 
29 [root@yinzhengjie day3]# go run ls.go .
30 是否为目录：%!V(bool=false) ；文件或者目录大小：601；目录名称是：reversal.go
31 是否为目录：%!V(bool=false) ；文件或者目录大小：708；目录名称是：myexpr.go
32 是否为目录：%!V(bool=false) ；文件或者目录大小：641；目录名称是：ls.go
33 [root@yinzhengjie day3]# go run ls.go ~/
34 是否为目录：%!V(bool=false) ；文件或者目录大小：1498；目录名称是：.viminfo
35 是否为目录：%!V(bool=false) ；文件或者目录大小：324；目录名称是：.bash_profile
36 是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：.pki
37 是否为目录：%!V(bool=false) ；文件或者目录大小：129；目录名称是：.tcshrc
38 是否为目录：%!V(bool=false) ；文件或者目录大小：12288；目录名称是：.bash_profile.swp
39 是否为目录：%!V(bool=false) ；文件或者目录大小：12790；目录名称是：.bash_history
40 是否为目录：%!V(bool=false) ；文件或者目录大小：18；目录名称是：.bash_logout
41 是否为目录：%!V(bool=false) ；文件或者目录大小：2856；目录名称是：anaconda-ks.cfg
42 是否为目录：%!V(bool=false) ；文件或者目录大小：56；目录名称是：.gitconfig
43 是否为目录：%!V(bool=false) ；文件或者目录大小：176；目录名称是：.bashrc
44 是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：.ssh
45 是否为目录：%!V(bool=false) ；文件或者目录大小：12480；目录名称是：install.log
46 是否为目录：%!V(bool=false) ；文件或者目录大小：4088；目录名称是：install.log.syslog
47 是否为目录：%!V(bool=false) ；文件或者目录大小：100；目录名称是：.cshrc
48 [root@yinzhengjie day3]# 
49 [root@yinzhengjie day3]# go run ls.go  /tmp/
50 是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：go-build655748897
51 是否为目录：%!V(bool=false) ；文件或者目录大小：1092；目录名称是：ks-script-ddWzzz
52 是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：cactiez
53 是否为目录：%!V(bool=false) ；文件或者目录大小：0；目录名称是：ks-script-ddWzzz.log
54 是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：go-build551514124
55 是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：.ICE-unix
56 是否为目录：%!V(bool=false) ；文件或者目录大小：52475；目录名称是：ins.log
57 是否为目录：%!V(bool=false) ；文件或者目录大小：0；目录名称是：yum.log
58 [root@yinzhengjie day3]# 

C>.模拟操作系统中的ps基础功能命令；

 1 [root@yinzhengjie day3]# more ps.go 
 2 /*
 3 #!/usr/bin/env gorun
 4 @author :yinzhengjie
 5 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 6 EMAIL:[email protected]
 7 */
 8 
 9 
10 package main
11 
12 import (
13         "os"
14         "log"
15         "fmt"
16         "strconv"
17         "io/ioutil"
18 )
19 /*
20 注意：linux操作系统中：/proc存放的进程的PID，基本上都是以数字目录形式记录，而在这些数字目录中的“cmdline”文件则记录着具体进程，当然还有exe记录的信息更加完整！
21 */
22 
23 func main() {
24         filepath := "/proc"
25         f,err := os.Open(filepath) //打开文件路径，如果打开当前路径就输入“.”
26         if err != nil {
27                 log.Fatal(err)
28         }
29         infos,_ := f.Readdir(-1)        //表示最大读取的个数，这个“-1”表示读取该文件的全部内容。
30         for _,info := range infos{
31                 //fmt.Printf("是否是目录：%v 文件大小是：%d 文件名称是：%s\n",info.IsDir(),info.Size(),info.Name())
32                 if info.IsDir() {
33                         n,err := strconv.Atoi(info.Name())              //将字符串转换成数字，但是并不是所有的字符串都能转换成数字哟！除非字符串本分并不包含非数字的元素。
34                         if err != nil {
35                                 //fmt.Println("转换失败：",err)
36                                 continue
37                         }
38                         //fmt.Println(n)
39                         filepath = filepath+"/"+ info.Name()
40                         f1,err := os.Open(filepath)
41                         if err != nil {
42                                 log.Fatal(err)
43                         }
44                         filepath = "/proc"
45                         files,_ := f1.Readdir(-1)
46                         for _,arg := range files{
47                                 if arg.Name()=="cmdline" {
48                         //              fmt.Println(arg.Name())
49                                         buf,err := ioutil.ReadFile(filepath+"/"+ info.Name()+"/"+arg.Name())
50                                         if err != nil {
51                                                 log.Fatal(err)
52                                         }
53                                         fmt.Println(n,string(buf))
54                                 }
55                         }
56                 }
57         }
58         f.Close()
59 }
60 [root@yinzhengjie day3]# 

最初笔记戳这里，下面未折叠的是我优化后的代码

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11         "fmt"
12         "io/ioutil"
13         "log"
14         "os"
15         "strconv"
16 )
17 
18 func catFile(pid string, fileName string) {
19         var s string
20         buf, err := ioutil.ReadFile(fileName) //读取文件内容，即pid/cmdline文件内容
21         if err != nil {
22                 log.Fatal(err) //如果文件不存在或是权限异常就打印出来，并且会附带时间戳效果哟！
23                 return
24         }
25         s = string(buf) //将读取的内容变成字符串。
26         if len(s) > 0 { //如果读取的cmdline文件的内容不为空，就打印其的PID（数字目录）和进程名称。
27                 fmt.Printf("进程的PID是：%v\t进程的名称是：%v\n", pid, s)
28         } else {
29 
30                 fmt.Println("我天，这个PID进程是属于系统的BASH的哟！")
31         }
32 }
33 
34 func main() {
35         var fileName string
36         f, err := os.Open(os.Args[1]) //打开命令行位置参数下表为1的文件。
37         fmt.Println(f)
38         if err != nil {
39                 log.Fatal(err)
40         }
41         infos, _ := f.Readdir(-1) //获取目录下的所有文件和目录。
42         for _, info := range infos {
43                 _, err := strconv.Atoi(info.Name())
44                 if info.IsDir() && err == nil { //判断是否为目录，并且转换成int类型时无报错
45                         fileName = os.Args[1] + info.Name() + "/cmdline" //拼接其绝对路径。
46                         catFile(info.Name(), fileName)                   //将数字的目录和其绝对路径传给函数catFile函数。
47                 }
48         }
49         f.Close()
50 }

　　注意：以上代码仅适用于Linux操作系统，可能你换成MAC就不好使了，WINDOWS也不好使，建议用CentOs对代码进行测试，因为系统都有/proc目录。

  1 [root@yinzhengjie day3]# gofmt -w ps.go 
  2 [root@yinzhengjie day3]# go run ps.go /proc/
  3 &{0xc42006e080}
  4 进程的PID是：1  进程的名称是：/sbin/init
  5 我天，这个PID进程是属于系统的BASH的哟！
  6 我天，这个PID进程是属于系统的BASH的哟！
  7 我天，这个PID进程是属于系统的BASH的哟！
  8 我天，这个PID进程是属于系统的BASH的哟！
  9 我天，这个PID进程是属于系统的BASH的哟！
 10 我天，这个PID进程是属于系统的BASH的哟！
 11 我天，这个PID进程是属于系统的BASH的哟！
 12 我天，这个PID进程是属于系统的BASH的哟！
 13 我天，这个PID进程是属于系统的BASH的哟！
 14 我天，这个PID进程是属于系统的BASH的哟！
 15 我天，这个PID进程是属于系统的BASH的哟！
 16 我天，这个PID进程是属于系统的BASH的哟！
 17 我天，这个PID进程是属于系统的BASH的哟！
 18 我天，这个PID进程是属于系统的BASH的哟！
 19 我天，这个PID进程是属于系统的BASH的哟！
 20 我天，这个PID进程是属于系统的BASH的哟！
 21 我天，这个PID进程是属于系统的BASH的哟！
 22 我天，这个PID进程是属于系统的BASH的哟！
 23 我天，这个PID进程是属于系统的BASH的哟！
 24 我天，这个PID进程是属于系统的BASH的哟！
 25 我天，这个PID进程是属于系统的BASH的哟！
 26 我天，这个PID进程是属于系统的BASH的哟！
 27 我天，这个PID进程是属于系统的BASH的哟！
 28 我天，这个PID进程是属于系统的BASH的哟！
 29 我天，这个PID进程是属于系统的BASH的哟！
 30 我天，这个PID进程是属于系统的BASH的哟！
 31 我天，这个PID进程是属于系统的BASH的哟！
 32 我天，这个PID进程是属于系统的BASH的哟！
 33 我天，这个PID进程是属于系统的BASH的哟！
 34 我天，这个PID进程是属于系统的BASH的哟！
 35 我天，这个PID进程是属于系统的BASH的哟！
 36 我天，这个PID进程是属于系统的BASH的哟！
 37 我天，这个PID进程是属于系统的BASH的哟！
 38 我天，这个PID进程是属于系统的BASH的哟！
 39 我天，这个PID进程是属于系统的BASH的哟！
 40 我天，这个PID进程是属于系统的BASH的哟！
 41 我天，这个PID进程是属于系统的BASH的哟！
 42 我天，这个PID进程是属于系统的BASH的哟！
 43 我天，这个PID进程是属于系统的BASH的哟！
 44 我天，这个PID进程是属于系统的BASH的哟！
 45 我天，这个PID进程是属于系统的BASH的哟！
 46 我天，这个PID进程是属于系统的BASH的哟！
 47 我天，这个PID进程是属于系统的BASH的哟！
 48 我天，这个PID进程是属于系统的BASH的哟！
 49 我天，这个PID进程是属于系统的BASH的哟！
 50 我天，这个PID进程是属于系统的BASH的哟！
 51 我天，这个PID进程是属于系统的BASH的哟！
 52 我天，这个PID进程是属于系统的BASH的哟！
 53 我天，这个PID进程是属于系统的BASH的哟！
 54 我天，这个PID进程是属于系统的BASH的哟！
 55 我天，这个PID进程是属于系统的BASH的哟！
 56 我天，这个PID进程是属于系统的BASH的哟！
 57 我天，这个PID进程是属于系统的BASH的哟！
 58 我天，这个PID进程是属于系统的BASH的哟！
 59 我天，这个PID进程是属于系统的BASH的哟！
 60 我天，这个PID进程是属于系统的BASH的哟！
 61 我天，这个PID进程是属于系统的BASH的哟！
 62 我天，这个PID进程是属于系统的BASH的哟！
 63 我天，这个PID进程是属于系统的BASH的哟！
 64 我天，这个PID进程是属于系统的BASH的哟！
 65 进程的PID是：406        进程的名称是：/sbin/udevd-d
 66 我天，这个PID进程是属于系统的BASH的哟！
 67 我天，这个PID进程是属于系统的BASH的哟！
 68 我天，这个PID进程是属于系统的BASH的哟！
 69 我天，这个PID进程是属于系统的BASH的哟！
 70 进程的PID是：1317       进程的名称是：/usr/sbin/vmware-vmblock-fuse-osubtype=vmware-vmblock,default_permissions,allow_other/var/run/vmblock-fuse
 71 进程的PID是：1338       进程的名称是：/usr/sbin/vmtoolsd
 72 进程的PID是：1363       进程的名称是：/usr/lib/vmware-vgauth/VGAuthService-s
 73 进程的PID是：1423       进程的名称是：./ManagementAgentHost
 74 进程的PID是：1619       进程的名称是：auditd
 75 进程的PID是：1641       进程的名称是：/sbin/portreserve
 76 进程的PID是：1649       进程的名称是：/sbin/rsyslogd-i/var/run/syslogd.pid-c5
 77 进程的PID是：1679       进程的名称是：irqbalance--pid=/var/run/irqbalance.pid
 78 进程的PID是：1695       进程的名称是：rpcbind
 79 进程的PID是：1740       进程的名称是：dbus-daemon--system
 80 进程的PID是：1753       进程的名称是：NetworkManager--pid-file=/var/run/NetworkManager/NetworkManager.pid
 81 进程的PID是：1758       进程的名称是：/usr/sbin/modem-manager
 82 进程的PID是：1774       进程的名称是：rpc.statd
 83 进程的PID是：1810       进程的名称是：cupsd-C/etc/cups/cupsd.conf
 84 进程的PID是：1838       进程的名称是：/usr/sbin/wpa_supplicant-c/etc/wpa_supplicant/wpa_supplicant.conf-B-u-f/var/log/wpa_supplicant.log-P/var/run/wpa_supplicant.pid
 85 进程的PID是：1855       进程的名称是：/usr/sbin/acpid
 86 进程的PID是：1865       进程的名称是：hald
 87 进程的PID是：1866       进程的名称是：hald-runner
 88 进程的PID是：1911       进程的名称是：hald-addon-input: Listening on /dev/input/event0 /dev/input/event2
 89 进程的PID是：1917       进程的名称是：hald-addon-acpi: listening on acpid socket /var/run/acpid.socket
 90 进程的PID是：1943       进程的名称是：/usr/sbin/sshd
 91 进程的PID是：1953       进程的名称是：xinetd-stayalive-pidfile/var/run/xinetd.pid
 92 进程的PID是：2112       进程的名称是：/usr/libexec/postfix/master
 93 进程的PID是：2133       进程的名称是：qmgr-l-tfifo-u
 94 进程的PID是：2140       进程的名称是：/usr/sbin/abrtd
 95 进程的PID是：2151       进程的名称是：crond
 96 进程的PID是：2165       进程的名称是：/usr/sbin/atd
 97 进程的PID是：2178       进程的名称是：/usr/sbin/cimserver
 98 进程的PID是：2204       进程的名称是：/sbin/mingetty/dev/tty2
 99 进程的PID是：2206       进程的名称是：/sbin/mingetty/dev/tty3
100 进程的PID是：2208       进程的名称是：/sbin/mingetty/dev/tty4
101 进程的PID是：2210       进程的名称是：/sbin/mingetty/dev/tty5
102 进程的PID是：2212       进程的名称是：/sbin/mingetty/dev/tty6
103 进程的PID是：2251       进程的名称是：/usr/sbin/console-kit-daemon--no-daemon
104 进程的PID是：2327       进程的名称是：/usr/libexec/devkit-power-daemon
105 进程的PID是：2379       进程的名称是：/usr/libexec/polkit-1/polkitd
106 进程的PID是：2392       进程的名称是：/usr/libexec/rtkit-daemon
107 进程的PID是：2513       进程的名称是：/usr/libexec/udisks-daemon
108 进程的PID是：2515       进程的名称是：udisks-daemon: polling /dev/sr0
109 进程的PID是：2578       进程的名称是：/usr/sbin/restorecond-u
110 我天，这个PID进程是属于系统的BASH的哟！
111 我天，这个PID进程是属于系统的BASH的哟！
112 进程的PID是：3333       进程的名称是：/sbin/dmeventd
113 我天，这个PID进程是属于系统的BASH的哟！
114 我天，这个PID进程是属于系统的BASH的哟！
115 进程的PID是：3581       进程的名称是：/sbin/udevd-d
116 进程的PID是：3582       进程的名称是：/sbin/udevd-d
117 进程的PID是：6520       进程的名称是：/sbin/mingetty/dev/tty1
118 进程的PID是：6689       进程的名称是：/usr/sbin/gdm-binary-nodaemon
119 进程的PID是：6704       进程的名称是：/usr/libexec/gdm-simple-slave--display-id/org/gnome/DisplayManager/Display1
120 进程的PID是：6707       进程的名称是：/usr/bin/Xorg:0-br-verbose-audit4-auth/var/run/gdm/auth-for-gdm-IfKotc/database-nolistentcpvt1
121 进程的PID是：6728       进程的名称是：/usr/bin/dbus-launch--exit-with-session
122 进程的PID是：6729       进程的名称是：/bin/dbus-daemon--fork--print-pid5--print-address7--session
123 进程的PID是：6731       进程的名称是：/usr/bin/gnome-session--autostart=/usr/share/gdm/autostart/LoginWindow/
124 进程的PID是：6734       进程的名称是：/usr/libexec/gconfd-2
125 进程的PID是：6735       进程的名称是：/usr/libexec/at-spi-registryd
126 进程的PID是：6739       进程的名称是：/usr/libexec/gnome-settings-daemon--gconf-prefix=/apps/gdm/simple-greeter/settings-manager-plugins
127 进程的PID是：6741       进程的名称是：/usr/libexec/bonobo-activation-server--ac-activate--ior-output-fd=12
128 进程的PID是：6749       进程的名称是：/usr/libexec/gvfsd
129 进程的PID是：6750       进程的名称是：metacity
130 进程的PID是：6753       进程的名称是：/usr/libexec/gdm-simple-greeter
131 进程的PID是：6755       进程的名称是：gnome-power-manager
132 进程的PID是：6756       进程的名称是：/usr/libexec/polkit-gnome-authentication-agent-1
133 进程的PID是：6758       进程的名称是：plymouth-log-viewer--icon
134 进程的PID是：6775       进程的名称是：/usr/bin/pulseaudio--start--log-target=syslog
135 进程的PID是：6778       进程的名称是：pam: gdm-password
136 进程的PID是：7343       进程的名称是：sshd: root@pts/0
137 进程的PID是：7350       进程的名称是：-bash
138 进程的PID是：7797       进程的名称是：viuppercase.go
139 进程的PID是：8579       进程的名称是：pickup-l-tfifo-u
140 进程的PID是：8898       进程的名称是：/usr/sbin/anacron-s
141 进程的PID是：8904       进程的名称是：sshd: root@pts/2
142 进程的PID是：8911       进程的名称是：-bash
143 进程的PID是：9075       进程的名称是：vips.go
144 进程的PID是：9082       进程的名称是：sshd: root@pts/3
145 进程的PID是：9089       进程的名称是：-bash
146 进程的PID是：9300       进程的名称是：gorunps.go/proc/
147 进程的PID是：9318       进程的名称是：/tmp/go-build752959693/command-line-arguments/_obj/exe/ps/proc/
148 [root@yinzhengjie day3]#

程序用法展示

 　　对了，再给大家推荐一个Golang的官方文档链接：http://godoc.org/