Golang字符串处理以及文件操作

一.整数

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxxx/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:xxxx@qq.com

 6 */

 7

 8 '''

 9 [root@xxxx 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@xxxxx day3]#

43 [root@xxxxx 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@xxxx day3]#

55

56 '''

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:yxxxx@qq.com

 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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:yxxxxx@qq.com

 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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 6 */

 7

 8 '''

 9 [root@xxxx day3]# more str_note.go

10 package main

11

12 import (

13         "fmt"

14 )

15

16 func main()  {

17         str1 := "xxxx\thave a apple!" //"\t"表示制表符，会根据操作系统自动空出几个空格。

18         doc :=`  //定义多行注释

19 111

20         222

21         3333

22         `

23         x := "hello\\world" //转移用"／"

24         y := "您好，good！\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@xxxx day3]#

41 [root@xxxx day3]# go run str_note.go  //如果你是在终端执行的话，或者windows用crt远程linux服务器，每次执行该脚本的时候都会出现系统提示音，前提是你的声卡要正常！

42 xxxx     have a apple!

43   //定义多行注释

44 111

45         222

46         3333

47

48 hello\world

49 您好，good！

50 ####2222

51 [root@xxxx day3]#

52

53 '''

2.字符串操作

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 6 */

 7

 8 '''

 9 [root@xxxx 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 := "golong" + "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@xxxx day3]#

58

59 '''

3.判断变量的数据类型

/*

#!/usr/bin/env gorun

@author :xxxx

Blog:http://www.cnblogs.com/xxxx/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/

EMAIL:xxxx@qq.com

*/

package main

import (

    "fmt"

    "reflect"

)

func main()  {

    str1 := "ygolang" + " 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

ygolang hello

121

uint8

*/

4.提升逼格的linux命令

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

xxd命令用法展示

5.小试牛刀

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 6 */

 7

 8 '''

 9 [root@xxxx day3]# more uppercase.go

10 package main

11

12 import "fmt"

13

14 func main() {

15         topper("xxxx") //我们在调用函数的时候输入的是小写字母

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@xxxx day3]#

33 [root@xxxx day3]#

34 [root@xxxx day3]# go run uppercase.go  //实现结果如下

35 xxxxE

36 [root@xxxx day3]#

37 '''

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 6 */

 7

 8 '''

 9 [root@xxxx day3]# more lower_upper.go

10 package main

11

12 import "fmt"

13

14 func main() {

15         topper("xxxx") //我们在调用函数的时候输入的是小写字母

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@xxxx day3]#

30 [root@xxxx day3]#

31 [root@xxxx day3]# go run lower_upper.go

32 xxxx

33 [root@xxxx day3]#

34 '''

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

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

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

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxxx/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:xxxx@qq.com

 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<j;i,j = i+1,j-1 { //这种思路就是把最后一个字符和第一个字符互换，循环到最中间的那个就不做任何操作

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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 1 2

28 2 0

29 3 1

30 4 7

四.条件判断

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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

五.运算符

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

 1 [root@xxxx day3]# gofmt myexpr.go

 2 /*

 3 #!/usr/bin/env gorun

 4 @author :xxxx

 5 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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@xxxx day3]#

40 [root@xxxx day3]# go run myexpr.go 11 + 22

41 运算结果是：33

42 [root@xxxx day3]# go run myexpr.go 11 - 3

43 运算结果是：8

44 [root@xxxx day3]# go run myexpr.go 11 \* 8

45 运算结果是：88

46 [root@xxxx day3]# go run myexpr.go 11 / 3

47 运算结果是：3

48 [root@xxxx day3]# go run myexpr.go 11 % 3

49 运算结果是：2

50 [root@xxxx day3]#

六.文件操作

1.文件的写入

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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("xxxx\n") //往文件写入相应的字符串。

23     f.Close()

24 }

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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("xxxx\n")

22     f.Close()

23 }

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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("xxxx\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 :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 xxxx

B>.随机读取文件内容

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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("xxxx.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/xxxx

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

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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乘法表；

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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@xxxx day3]# gofmt ls.go

 2 /*

 3 #!/usr/bin/env gorun

 4 @author :xxxx

 5 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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@xxxx day3]#

29 [root@xxxx 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@xxxx 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@xxxx day3]#

49 [root@xxxx 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@xxxx day3]#

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

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

 1 /*

 2 #!/usr/bin/env gorun

 3 @author :xxxx

 4 Blog:http://www.cnblogs.com/xxxx/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:xxxx@qq.com

 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 }

巴特西

Golang字符串处理以及文件操作

最新文章

热门文章