GO语言的进阶之路-Golang字符串处理以及文件操作
GO语言的进阶之路-Golang字符串处理以及文件操作
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
我们都知道Golang是一门强类型的语言，相比Python在处理一些并发问题也是有过之而无不及，甚至可以说远远的甩python几条街。学过python基础或是shell的童鞋应该知道我们在定义一个变量的时候是不需要指定其所属数据类型的，直接让其等于一个变量即可，他们的解释器会自动识别你定义的是个整数，浮点数，字符串，还是数组或是函数。而Golang在定义每个变量的时候都被指定了数据类型，如果你给这个变量定义的是数字类型，你把它的指针指向字符串的话就会报错！接下来，让我们先看看，整数，常量，字符串，运算符等基础的数据类型吧，本文还会介绍Golang的循环控制以及文件处理等常用的操作。
当然我这里只是介绍了Golang的冰山一角，对Golang感兴趣的小伙伴，可以看一下Golang官网的文档说明。毕竟官方才是最权威的，给出国内地址：https://golang.org/pkg/
一.整数
1.int与uint的初值比较以及其大小。
/*
#!/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:y1053419035@qq.com
*/ '''
[root@yinzhengjie day3]# more myint.go
package main import (
"fmt"
"unsafe"
) func main() {
var (
a int //包括所有的整数
b int8 //取值个数2^8,取之范围（-128）-(127)
c int16
d int32 //取值个数：2^32，取值范围：(-2^16)-(2^16-1)
e int64
x uint //其中这个"u"，即：unsigned。表示无符号，即只能表示0和所有的正整数。
y uint8
z uint16
p uint32 //取之个数：2^32，取之范围0-2^32-1
q uint64
)
fmt.Println("A=",a,"size=",unsafe.Sizeof(a))
fmt.Println("B=",b,"size=",unsafe.Sizeof(b))
fmt.Println("C=",c,"size=",unsafe.Sizeof(c))
fmt.Println("D=",d,"size=",unsafe.Sizeof(d))
fmt.Println("E=",e,"size=",unsafe.Sizeof(e))
fmt.Println("X=",x,"size=",unsafe.Sizeof(x))
fmt.Println("Y=",y,"size=",unsafe.Sizeof(y))
fmt.Println("Z=",z,"size=",unsafe.Sizeof(z))
fmt.Println("P=",p,"size=",unsafe.Sizeof(p))
fmt.Println("Q=",q,"size=",unsafe.Sizeof(q))
} [root@yinzhengjie day3]#
[root@yinzhengjie day3]# go run myint.go
A= 0 size= 8
B= 0 size= 1
C= 0 size= 2
D= 0 size= 4
E= 0 size= 8
X= 0 size= 8
Y= 0 size= 1
Z= 0 size= 2
P= 0 size= 4
Q= 0 size= 8
[root@yinzhengjie day3]# '''
2.常量(关键字：const )的定义
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
) const ( //"const"关键字是定义一个常量。
PI = 3.1415926
E = 2.0
g = 9.8
) const (
RED = 10 * iota //"iota"关键字帮你自动从0，1,2......依次开始递增
GREEN
BLUE
) func main() {
fmt.Println(RED,GREEN,BLUE)
var (
n int
f float32
f_1 float32
)
n = 10
f = float32(n) / 3 //"n=10"属于“int”类型，int是整数类型，float32是浮点数类型，两者必须转换成一致的，不然会报错。因为Golang是强类型语言。这也是它的特点之一。
fmt.Println(f,n)
f_1 = float32(n / 3) //"n / 3"的结果是"",因为int的类型是个整数，所以被整数三除了之后应该还是整数。
fmt.Println(f_1)
fmt.Println(f_1 * 3)
n = int(f_1 * 3) //同左不同右，我们可以把右边的float32类型转换成int类型
fmt.Println(n)
var (
n1 int64
n2 int8
)
n1 = 2222222221024004
n2 = int8(n1) //要注意的是int8的取值范围是[-128到127]，总共255个数字。它会从这个数组的从右往左取数字，最多也就占3位，尽管你前面有再多的数字对其都是无用的。
fmt.Println(n1,n2) n1 = 1024129
n2 = int8(n1) //看完上面的例子你也，你也应该明白了，在其取值范围是会取得这个数字，如果不在的话渠道的数字也是有问题的！(数字128已经超出其正数的取值范围，它又从-128到0这个段开始取值。)因此在转换的时候要留心哟。
fmt.Println(n1,n2)
} #以上代码输出结果如下：
0 10 20
3.3333333 10
3
9
9
2222222221024004 4
1024129 -127
3.关于int的取值范围扩充。
4.将数字转换成字符串
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
"strconv"
"reflect"
) func main() { var (
s string
x = 100
)
s = strconv.Itoa(x) //将一个整数转换成字符串的方法
fmt.Println("转换前的类型",reflect.TypeOf(x))
fmt.Println("我是转换后的字符串：",s)
fmt.Println("转换后的类型",reflect.TypeOf(s)) } #以上代码输出结果如下：
转换前的类型 int
我是转换后的字符串： 100
转换后的类型 string
5.生成随机字符串案例
/*
#!/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:y1053419035@qq.com
*/ //世界上只有10种人，一种是懂二进制，一种是不懂二进制。
package main import (
"math/rand"
"time"
"strconv"
"fmt"
) var x int64
var s string func main() {
rand.Seed(time.Now().Unix())
x = rand.Int63()
s = strconv.FormatInt(x,36) //表示用36进制来计算x的值。
fmt.Println(s) //我们可以在这里对字符串做切片操作，这样就可以随机获取到我们想要到字符了。
} #以上代码直接结果如下：
p7d8bbl6rjy4
二.字符串
1.字符串花式定义玩法以及注释操作
/*
#!/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:y1053419035@qq.com
*/ '''
[root@yinzhengjie day3]# more str_note.go
package main import (
"fmt"
) func main() {
str1 := "yinzhengjie\thave a apple!" //"\t"表示制表符，会根据操作系统自动空出几个空格。
doc :=` //定义多行注释
111
222
3333
`
x := "hello\\world" //转移用"／"
y := "您好，尹正杰！\a" //在终端执行电脑会响.在IDE上执行可能不会有声音哟！
z := "####1\b2222" //"\b"表示退格键，会把"\b"前面的一个字符给删除掉，即打印的时候会删除数字"1"
fmt.Println(str1)
fmt.Println(doc)
fmt.Println(x)
fmt.Println(y)
fmt.Println(z)
} //本行是单行注释，下面到结尾是多行注释。
/*
I have a pen
I have an apple
I have a pen and i have an apple!
*/ [root@yinzhengjie day3]#
[root@yinzhengjie day3]# go run str_note.go //如果你是在终端执行的话，或者windows用crt远程linux服务器，每次执行该脚本的时候都会出现系统提示音，前提是你的声卡要正常！
yinzhengjie have a apple!
//定义多行注释
111
222
3333 hello\world
您好，尹正杰！
####2222
[root@yinzhengjie day3]# '''
2.字符串操作
/*
#!/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:y1053419035@qq.com
*/ '''
[root@yinzhengjie day3]# more str_manipulation.go
package main /*
字符串修改：
1.单引号是字符，双引号是字符串；
2.字符串本身不可以修改；
3.通过跟"[]byte"数组相互转换来修改；
*/ import (
"fmt"
) func main() {
str1 := "yinzhengjie" + "world" //拼接
fmt.Println(str1) var str2 byte //1个字节（byte）=8个比特位（bits），因此byte = uint8
str2 = str1[0] //取字符
fmt.Println(str2)
fmt.Printf("数字：%d 字符：%c\n",str2,str2) //表示字符"y"在ASCII表中对应的数字。printf不会换行但是prin
tln会自动换行。 str3 := str1[0:11] //切片,顾左不顾右，取0-10共11个字符，不会去知道第12个字符，即不会取到下标为11第字符
"w"
fmt.Println(str3) str4 := str1[11:len(str1)]
fmt.Println(str4) var b uint8 //我们这里也可以把unit8写成byte，其实是等效的。
for b = 0;b < 177 ;b++ {
fmt.Printf("%d %c\n",b,b)
}
array := []byte(str1) //将字符串转换成byte数组，可以理解成为python中的list.
fmt.Println(array)
array[0] = 72 //也可以写字符'H',在ASCII中他们是一一对应的
str1 = string(array)
fmt.Println(str1) fmt.Println('a' + ('H' - 'h')) //其实就是这些字符在ASCII中的数字相加减，得到的数字为65。
fmt.Println(0xa) //表示16进制数字a在ASCII所对应的数字 }
[root@yinzhengjie day3]# '''
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:y1053419035@qq.com
*/ 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编码中所对应的数字""(我说的说的是十进制的哟)
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”，如果用这个命令呢?展示方法如下：
/*
#!/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:y1053419035@qq.com
*/ '''
[root@yinzhengjie day3]# xxd str_manipulation.go
0000000: 7061 636b 6167 6520 6d61 696e 0a0a 0a0a package main....
0000010: 2f2a 0ae5 ad97 e7ac a6e4 b8b2 e4bf aee6 /*..............
0000020: 94b9 efbc 9a0a 312e e58d 95e5 bc95 e58f ......1.........
0000030: b7e6 98af e5ad 97e7 aca6 efbc 8ce5 8f8c ................
0000040: e5bc 95e5 8fb7 e698 afe5 ad97 e7ac a6e4 ................
0000050: b8b2 efbc 9b0a 322e e5ad 97e7 aca6 e4b8 ......2.........
0000060: b2e6 9cac e8ba abe4 b88d e58f afe4 bba5 ................
0000070: e4bf aee6 94b9 efbc 9b0a 332e e980 9ae8 ..........3.....
0000080: bf87 e8b7 9f22 5b5d 6279 7465 22e6 95b0 ....."[]byte"...
0000090: e7bb 84e7 9bb8 e4ba 92e8 bdac e68d a2e6 ................
00000a0: 9da5 e4bf aee6 94b9 efbc 9b0a 2a2f 0a0a ............*/..
00000b0: 696d 706f 7274 2028 0a09 2266 6d74 220a import (.."fmt".
00000c0: 290a 0a66 756e 6320 6d61 696e 2829 2020 )..func main()
00000d0: 7b0a 0973 7472 3120 3a3d 2022 7969 6e7a {..str1 := "yinz
00000e0: 6865 6e67 6a69 6522 202b 2022 776f 726c hengjie" + "worl
00000f0: 6422 202f 2fe6 8bbc e68e a50a 0966 6d74 d" //........fmt
0000100: 2e50 7269 6e74 6c6e 2873 7472 3129 0a0a .Println(str1)..
0000110: 0976 6172 2020 7374 7232 2062 7974 6520 .var str2 byte
0000120: 202f 2f31 e4b8 aae5 ad97 e88a 82ef bc88 //1............
0000130: 6279 7465 efbc 893d 38e4 b8aa e6af 94e7 byte...=8.......
0000140: 89b9 e4bd 8def bc88 6269 7473 efbc 89ef ........bits....
0000150: bc8c e59b a0e6 ada4 6279 7465 203d 2075 ........byte = u
0000160: 696e 7438 0a09 7374 7232 203d 2073 7472 int8..str2 = str
0000170: 315b 305d 202f 2fe5 8f96 e5ad 97e7 aca6 1[0] //.........
0000180: 0a09 666d 742e 5072 696e 746c 6e28 7374 ..fmt.Println(st
0000190: 7232 290a 0966 6d74 2e50 7269 6e74 6628 r2)..fmt.Printf(
00001a0: 22e6 95b0 e5ad 97ef bc9a 2564 20e5 ad97 ".........%d ...
00001b0: e7ac a6ef bc9a 2563 5c6e 222c 7374 7232 ......%c\n",str2
00001c0: 2c73 7472 3229 202f 2fe8 a1a8 e7a4 bae5 ,str2) //.......
00001d0: ad97 e7ac a622 7922 e59c a841 5343 4949 ....."y"...ASCII
00001e0: e8a1 a8e4 b8ad e5af b9e5 ba94 e79a 84e6 ................
00001f0: 95b0 e5ad 97e3 8082 7072 696e 7466 e4b8 ........printf..
0000200: 8de4 bc9a e68d a2e8 a18c e4bd 86e6 98af ................
0000210: 7072 696e 746c 6ee4 bc9a e887 aae5 8aa8 println.........
0000220: e68d a2e8 a18c e380 820a 0a09 7374 7233 ............str3
0000230: 203a 3d20 7374 7231 5b30 3a31 315d 202f := str1[0:11] /
0000240: 2fe5 8887 e789 872c e9a1 bee5 b7a6 e4b8 /......,........
0000250: 8de9 a1be e58f b3ef bc8c e58f 9630 2d31 .............0-1
0000260: 30e5 85b1 3131 e4b8 aae5 ad97 e7ac a6ef 0...11..........
0000270: bc8c e4b8 8de4 bc9a e58e bbe7 9fa5 e981 ................
0000280: 93e7 acac 3132 e4b8 aae5 ad97 e7ac a6ef ....12..........
0000290: bc8c e58d b3e4 b88d e4bc 9ae5 8f96 e588 ................
00002a0: b0e4 b88b e6a0 87e4 b8ba 3131 e7ac ace5 ..........11....
00002b0: ad97 e7ac a622 7722 0a09 666d 742e 5072 ....."w"..fmt.Pr
00002c0: 696e 746c 6e28 7374 7233 290a 0a09 7374 intln(str3)...st
00002d0: 7234 203a 3d20 7374 7231 5b31 313a 6c65 r4 := str1[11:le
00002e0: 6e28 7374 7231 295d 0a09 666d 742e 5072 n(str1)]..fmt.Pr
00002f0: 696e 746c 6e28 7374 7234 290a 0a09 7661 intln(str4)...va
0000300: 7220 6220 7569 6e74 3820 2f2f e688 91e4 r b uint8 //....
0000310: bbac e8bf 99e9 878c e4b9 9fe5 8faf e4bb ................
0000320: a5e6 8a8a 756e 6974 38e5 8699 e688 9062 ....unit8......b
0000330: 7974 65ef bc8c e585 b6e5 ae9e e698 afe7 yte.............
0000340: ad89 e695 88e7 9a84 e380 820a 0966 6f72 .............for
0000350: 2062 203d 2030 3b62 203c 2031 3737 203b b = 0;b < 177 ;
0000360: 622b 2b20 207b 0a09 0966 6d74 2e50 7269 b++ {...fmt.Pri
0000370: 6e74 6628 2225 6420 2563 5c6e 222c 622c ntf("%d %c\n",b,
0000380: 6229 0a09 7d0a 0961 7272 6179 203a 3d20 b)..}..array :=
0000390: 5b5d 6279 7465 2873 7472 3129 202f 2fe5 []byte(str1) //.
00003a0: b086 e5ad 97e7 aca6 e4b8 b2e8 bdac e68d ................
00003b0: a2e6 8890 6279 7465 e695 b0e7 bb84 efbc ....byte........
00003c0: 8ce5 8faf e4bb a5e7 9086 e8a7 a3e6 8890 ................
00003d0: e4b8 ba70 7974 686f 6ee4 b8ad e79a 846c ...python......l
00003e0: 6973 742e 0a09 666d 742e 5072 696e 746c ist...fmt.Printl
00003f0: 6e28 6172 7261 7929 0a09 6172 7261 795b n(array)..array[
0000400: 305d 203d 2037 3220 2f2f e4b9 9fe5 8faf 0] = 72 //......
0000410: e4bb a5e5 8699 e5ad 97e7 aca6 2748 272c ............'H',
0000420: e59c a841 5343 4949 e4b8 ade4 bb96 e4bb ...ASCII........
0000430: ace6 98af e4b8 80e4 b880 e5af b9e5 ba94 ................
0000440: e79a 840a 0973 7472 3120 3d20 7374 7269 .....str1 = stri
0000450: 6e67 2861 7272 6179 290a 0966 6d74 2e50 ng(array)..fmt.P
0000460: 7269 6e74 6c6e 2873 7472 3129 0a0a 0966 rintln(str1)...f
0000470: 6d74 2e50 7269 6e74 6c6e 2827 6127 202b mt.Println('a' +
0000480: 2028 2748 2720 2d20 2768 2729 2920 2f2f ('H' - 'h')) //
0000490: e585 b6e5 ae9e e5b0 b1e6 98af e8bf 99e4 ................
00004a0: ba9b e5ad 97e7 aca6 e59c a841 5343 4949 ...........ASCII
00004b0: e4b8 ade7 9a84 e695 b0e5 ad97 e79b b8e5 ................
00004c0: 8aa0 e587 8fef bc8c e5be 97e5 88b0 e79a ................
00004d0: 84e6 95b0 e5ad 97e4 b8ba 3635 e380 820a ..........65....
00004e0: 0966 6d74 2e50 7269 6e74 6c6e 2830 7861 .fmt.Println(0xa
00004f0: 2920 2f2f e8a1 a8e7 a4ba 3136 e8bf 9be5 ) //......16....
0000500: 88b6 e695 b0e5 ad97 61e5 9ca8 4153 4349 ........a...ASCI
0000510: 49e6 8980 e5af b9e5 ba94 e79a 84e6 95b0 I...............
0000520: e5ad 970a 0a0a 7d0a ......}.
[root@yinzhengjie day3]# '''
xxd命令用法展示
5.小试牛刀
A.用Golang语言实现将小写字母转换成大写字母。
/*
#!/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:y1053419035@qq.com
*/ '''
[root@yinzhengjie day3]# more uppercase.go
package main import "fmt" func main() {
topper("yinzhengjie") //我们在调用函数的时候输入的是小写字母
} func topper(s string) string { //后面的string表示返回值的类型。
array := []byte(s) //将字符串转换成字节
var (
i int
res string
)
for i = 0; i < len(s); i++ {
fmt.Printf(string(array[i] - 32)) //格式化输出，将每一次循环的变量i都保存下来。如果不敲击这一
行默认只会保留最后一次循环的值.
res = string(array[i] - 32) //将字节转换成字符串并赋值给res字符串.
}
fmt.Println(res)
return res
}
[root@yinzhengjie day3]#
[root@yinzhengjie day3]#
[root@yinzhengjie day3]# go run uppercase.go //实现结果如下
YINZHENGJIEE
[root@yinzhengjie day3]#
'''
以上代码你看起来可能特别简单，而且思路不严谨，没有判断字母大小写就同意转换成大写的操作！那么如何优化呢？请看下面的代码，稍微做了一下优化的代码风格就有所改变。
/*
#!/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:y1053419035@qq.com
*/ '''
[root@yinzhengjie day3]# more lower_upper.go
package main import "fmt" func main() {
topper("yinzhengjie") //我们在调用函数的时候输入的是小写字母 } func topper(s string) string {
num := []byte(s) //将传入的字符串转换成字节所对应的数字的数组。
for i,v := range num { //循环这个数组
if v >= 'a' && v <= 'z' { //判断这个数字的值是否为小写
num[i] = v - 32 //如果是小姐，就根据ASCII编码表的位置关系，将其转换成大写。
}
}
fmt.Println(string(num))
return string(num) //返回这个数组，通过ASCII编码表中的数字找到对应的字符串并返回。
}
[root@yinzhengjie day3]#
[root@yinzhengjie day3]#
[root@yinzhengjie day3]# go run lower_upper.go
YINZHENGJIE
[root@yinzhengjie day3]#
'''
B.用Golang语言试下将字母的顺序颠倒，专业术语叫反转。
在写这个小程序之前我们需要了解一下rune这个包，大家都知道byte,众所周知的字节，一个字节等于八个比特位，一个比特位存着响应的字母或是数字以及一些特殊符号等等，但是存取中国的汉字一个字节是远远不够的，可能用到三到四个字节进行存取的，所以我们之前将字母小写转换成大写就不好使了。因为你会发现自己是取不到下表的，一个汉字需要三个字节存取，你想读取汉字的时候必须也得取三个字节才能读到这个汉字，如果只取一个字节的话就会乱码。当然知道这个原理后我用byte也实现了反转的功能，但是真的太麻烦了（随着汉字的数量不同，我得判断字节循环的起点数量）。我找到了rune这个包，真的很好使，话不多说，我们直接上代码对比一下输出结果您就清楚了。代码请点击下面的小标题。
package main import (
"fmt"
"reflect"
) func main() {
yzj := "尹正杰ABCD"
yzj2 := []rune(yzj) //rune类型
yzj3 := []byte(yzj) //byte类型
for k, v := range yzj {
fmt.Println(k, "=字符串遍历=>", v)
}
for k, v := range yzj2 {
fmt.Println(k, "=rune遍历=>", v)
}
for k, v := range yzj3 {
fmt.Println(k, "=byte遍历=>", v)
}
fmt.Println("让我们来一起看看'byte'的数据类型吧：",reflect.TypeOf(yzj3))
fmt.Println("让我们来一起看看'rune'的数据类型吧：",reflect.TypeOf(yzj2))
} #以上代码执行结果如下：
0 =字符串遍历=> 23609
3 =字符串遍历=> 27491
6 =字符串遍历=> 26480
9 =字符串遍历=> 65
10 =字符串遍历=> 66
11 =字符串遍历=> 67
12 =字符串遍历=> 68
0 =rune遍历=> 23609
1 =rune遍历=> 27491
2 =rune遍历=> 26480
3 =rune遍历=> 65
4 =rune遍历=> 66
5 =rune遍历=> 67
6 =rune遍历=> 68
0 =byte遍历=> 229
1 =byte遍历=> 176
2 =byte遍历=> 185
3 =byte遍历=> 230
4 =byte遍历=> 173
5 =byte遍历=> 163
6 =byte遍历=> 230
7 =byte遍历=> 157
8 =byte遍历=> 176
9 =byte遍历=> 65
10 =byte遍历=> 66
11 =byte遍历=> 67
12 =byte遍历=> 68
让我们来一起看看'byte'的数据类型吧： []uint8
让我们来一起看看'rune'的数据类型吧： []int32
对比string，byte，rune存取汉字的方式
姿势一：用rune实现将字符倒着打印即可完成反转功能
/*
#!/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:y1053419035@qq.com
*/ package main import "fmt" func main() {
yzj := "尹正杰world欢迎你"
yzj2 := []rune(yzj) //rune类型
for i := len(yzj2) - 1; i >= 0; i-- { //从最后一个字符开始倒着打印
fmt.Printf(string(yzj2[i]))
}
} #以上代码执行结果如下：
你迎欢dlrow杰正尹
姿势二:思路和姿势一一样，知识角度不同（咳咳，我说的角度知识换了一个循环方式而已）
/*
#!/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:y1053419035@qq.com
*/ package main import "fmt" func main() {
yzj := "尹正杰Glang"
yzj2 := []rune(yzj) //rune类型
for k := range yzj2 { //利用数字循环倒着打印，思路跟姿势一一样
fmt.Printf(string(yzj2[len(yzj2)-k-1]))
}
} #以上代码执行结果如下：
gnalG杰正尹
姿势三：“69”互换，“咳咳，严格的来说应该是首末互换”，有两行代码被我注释掉了，大家可以把它注释取消掉，然后就能亲手体会这种感觉了。
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
) func main() {
strs := "北京欢迎你"
num := []rune(strs)
lang := len(num)
//fmt.Println(num)
for i,j := 0,lang-1;i<j;i,j = i+1,j-1 { //这种思路就是把最后一个字符和第一个字符互换，循环到最中间的那个就不做任何操作
//fmt.Println(i,j)
num[i],num[j] = num[j],num[i]
}
fmt.Println(string(num))
} #以上代码执行结果如下：
你迎欢京北
相比通过这个小程序，发现Golang的for循环很好玩吧。下面跟着我一起来学习一下Golang的for循环吧。
三.循环语句
说道循环，那Golang里面的姿势可多了，得给你涨涨经验了，光我所知道的就有4种，别问我最喜欢那种姿势，这个你得用手去感受，用心去体会，别想歪啊，我是说用手去敲代码感受，用心去研究那种循环的姿势最适合你。话不多收我们开干吧！
1.姿势一：这种循环玩shell的童鞋一看便知。
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
) func main() {
for i := 0;i <= 5 ;i++ {
fmt.Println(i)
}
} #以上代码输出结果如下：
0
1
2
3
4
5
2.姿势二:类似python中的while循环
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
) func main() {
i := 1
for i < 10 {
fmt.Println(i)
i = i + 2
}
} #以上代码执行结果如下：
1
3
5
7
9
3.姿势三：类似于python中的while循环
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
) func main() {
i := 8
for {
i = i + 1
fmt.Println(i)
if i > 10 {
break
} }
} #以上代码执行结果如下：
9
10
11
4.姿势四:遍历数组循环.
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt" ) func main() {
s := "尹正杰2017"
for i,arg := range s {
fmt.Printf("%d %c\n",i,arg)
}
} #以上代码执行结果如下：
0 尹
3 正
6 杰
9 2
10 0
11 1
12 7
四.条件判断
/*
#!/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:y1053419035@qq.com
*/ package main import (
"strconv"
"fmt"
)
//注意："strconv.Atoi"只能讲数字转换成字符串，如果不是纯数字的字符串是没法发转换的哟。
func main() {
s := "尹正杰2017"
n,err := strconv.Atoi(s) //用"n"和"err"两个参数来接受“strconv.Atoi”的值，如果正常就把值传给变量"n",如果异常就把值传给"err"。
if err != nil { //如果错误信息不为空，那么就执行大括号的代码。
fmt.Println("'strconv.Atoi'传入的参数有问题哟！看报错内容是>>>:",err) //将接受的错误信息打印出来。
return //出现这行代码就不会往下走啦，直接就终止这个函数了。
}
fmt.Println(n)
fmt.Println("")
} #以上代码执行结果如下：
'strconv.Atoi'传入的参数有问题哟！看报错内容是>>>: strconv.Atoi: parsing "尹正杰2017": invalid syntax
五.运算符
其实运算符，这些知识都是小学三年级的朋友都会的，简单点的无非就是加减乘除，我不打算详细介绍，刚兴趣的童鞋可以去Golang官网去看看关于运算符的，我这里简单的协议一个最low的小程序给大家看最基础的小程序，好了，天黑了，大神请闭眼，小白请睁眼。小白你要跟我一起撸吗？来吧，别克制！
[root@yinzhengjie day3]# gofmt myexpr.go
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
"os"
"strconv"
) func main() {
var (
x int
y int
//res int
)
x, _ = strconv.Atoi(os.Args[1]) //将字符串转换成数字
y, _ = strconv.Atoi(os.Args[3])
switch os.Args[2] {
case "+":
fmt.Printf("运算结果是：%d\n", x+y)
case "-":
fmt.Printf("运算结果是：%d\n", x-y)
case "*":
fmt.Printf("运算结果是：%d\n", x*y)
case "/":
fmt.Printf("运算结果是：%d\n", x/y)
case "%":
fmt.Printf("运算结果是：%d\n", x%y)
}
//fmt.Println(os.Args[1])
}
[root@yinzhengjie day3]#
[root@yinzhengjie day3]# go run myexpr.go 11 + 22
运算结果是：33
[root@yinzhengjie day3]# go run myexpr.go 11 - 3
运算结果是：8
[root@yinzhengjie day3]# go run myexpr.go 11 \* 8
运算结果是：88
[root@yinzhengjie day3]# go run myexpr.go 11 / 3
运算结果是：3
[root@yinzhengjie day3]# go run myexpr.go 11 % 3
运算结果是：2
[root@yinzhengjie day3]#
六.文件操作
1.文件的写入
a>.打开一个文件，如果没有就创建，如果有这个文件就清空文件内容（相当于python中的"w"）;
/*
#!/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:y1053419035@qq.com
*/ package main import (
"os"
"log"
) func main() {
f,err := os.Create("a.txt") //姿势一：打开一个文件，如果没有就创建，如果有这个文件就清空文件内容,需要用两个变量接受相应的参数
if err != nil {
log.Fatal(err)
}
f.WriteString("yinzhengjie\n") //往文件写入相应的字符串。
f.Close()
}
b>.以追加的方式打开一个文件（相当于python中的"a"）;
/*
#!/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:y1053419035@qq.com
*/ package main import (
"os"
"log"
) func main() {
f,err := os.OpenFile("a.txt",os.O_APPEND|os.O_CREATE|os.O_RDWR,0644) //表示最佳的方式打开文件，如果不存在就创建，打开的模式是可读可写，权限是644
if err != nil {
log.Fatal(err)
}
f.WriteString("yinzhengjie\n")
f.Close()
}
c>.修改文件内容-随机写入（自定义插入的位置，相当python重的seek方法）;
/*
#!/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:y1053419035@qq.com
*/ package main import (
"os"
"log"
) func main() {
f,err := os.OpenFile("a.txt",os.O_CREATE|os.O_RDWR,0644)
if err != nil {
log.Fatal(err)
}
f.WriteString("yinzhengjie\n")
f.Seek(1,os.SEEK_SET) //表示文件的其实位置，从第二个字符往后写入。
f.WriteString("$$$")
f.Close()
}
2.文件的读取
A>.顺序读取文件内容
/*
#!/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:y1053419035@qq.com
*/ package main import (
"os"
"bufio"
"io"
"fmt"
"log"
) //姿势一：读取文件内容
func main() {
//f,err := os.OpenFile("a.txt",os.O_CREATE|os.O_RDWR,0644) //打开该文件，但是不建议用这行命令，用下面的专门用来读取文件的。
f,err := os.Open("a.txt") //打开一个文件，如果这个文件不存在的话就会报错。
if err != nil {
log.Fatal(err)
}
r := bufio.NewReader(f) //取出文件的内容
for {
line,err := r.ReadString('\n') //表示以"\n"为分隔符，遇到"\n"就换行。
if err == io.EOF{ //读到文件结尾后就终止文件。
break
}
fmt.Print(line)
}
f.Close()
} #以上代码执行结果如下：
y$$$hengjie
yinzhengjie
B>.随机读取文件内容
/*
#!/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:y1053419035@qq.com
*/ package main import (
"os"
"bufio"
"io"
"fmt"
"log"
) func main() {
f,err := os.OpenFile("yinzhengjie.txt",os.O_CREATE|os.O_RDWR,0644)
if err != nil {
log.Fatal(err)
}
r := bufio.NewReader(f)
for {
line,err := r.ReadString('\n') //表示以"\n"为分隔符，遇到"\n"就换行。
if err == io.EOF{ //读到文件结尾后就终止文件。因此如果你这么干了的话，你始终只能读取到第一行的内容
break
}
fmt.Print(line)
}
f.Close()
} #以上代码执行结果如下：
欢迎来到我的博客：http://www.cnblogs.com/yinzhengjie
C.用ioutil模块读取文件内容；
要注意的是ioutil下有个读取文件的方法，但是读取出来的都是bytes,因此你需要将bytes转换成字符串，然后才打印给用户才好使。
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
"io/ioutil"
"log"
) func main() {
buf,err := ioutil.ReadFile("D:\\Golang环境\\Golang Program\\Golang lesson\\Day4\\单词.txt")
if err != nil {
log.Fatal(err)
}
fmt.Println(string(buf))
} #以上代码执行结果如下：
Scanner provides a convenient interface for reading data such as a file of newline-delimited lines of text Successive
calls to the Scan method will step through the tokens of a file skipping the bytes between the tokens The specification
of a token is defined by a split function of type SplitFunc the default split function breaks the input into lines with
line termination stripped Split functions are defined in this package for scanning a file into lines bytes UTF-8-encoded
runes and space-delimited words The client may instead provide a custom split function
3.小试牛刀
A.>.用Golang编写99乘法表；
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
"os"
"log" ) func main() {
var top int = 10
//f,err := os.Create("乘法表.txt")
f,err := os.OpenFile("乘法表.txt",os.O_CREATE|os.O_RDWR,0644)
if err != nil {
log.Fatal(err)
}
for i:=1; i<top; i++ {
for j := 1;j<=i;j++ {
fmt.Fprintf(f,"%d * %d = %2d\t", i , j, i*j)
}
fmt.Fprintln(f)
}
f.Close()
}
用Golang将九九乘法表写入到文件中
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
"os"
"log" "bufio"
"io"
) func main() {
f,err := os.Open("乘法表.txt") //打开一个文件，如果这个文件不存在的话就会报错。
if err != nil {
log.Fatal(err)
}
r := bufio.NewReader(f) //取出文件的内容
for {
line,err := r.ReadString('\n') //表示以"\n"为分隔符，遇到"\n"就换行。
if err == io.EOF{ //读到文件结尾后就终止文件。
break
}
fmt.Print(line)
}
f.Close()
} #以上代码执行结果如下：
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
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基础功能命令；
[root@yinzhengjie day3]# gofmt ls.go
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
"log"
"os"
) func main() {
f, err := os.Open(os.Args[1]) //表示把该程序的第一个字符串传进去，就好像模拟简单的ls命令
if err != nil {
log.Fatal(err)
}
infos, _ := f.Readdir(-1) //表示列出所有的文件或目录
for _, info := range infos {
fmt.Printf("是否为目录：%V ；文件或者目录大小：%d；目录名称是：%s\n", info.IsDir(), info.Size(), info.Name())
}
f.Close()
}
[root@yinzhengjie day3]#
[root@yinzhengjie day3]# go run ls.go .
是否为目录：%!V(bool=false) ；文件或者目录大小：601；目录名称是：reversal.go
是否为目录：%!V(bool=false) ；文件或者目录大小：708；目录名称是：myexpr.go
是否为目录：%!V(bool=false) ；文件或者目录大小：641；目录名称是：ls.go
[root@yinzhengjie day3]# go run ls.go ~/
是否为目录：%!V(bool=false) ；文件或者目录大小：1498；目录名称是：.viminfo
是否为目录：%!V(bool=false) ；文件或者目录大小：324；目录名称是：.bash_profile
是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：.pki
是否为目录：%!V(bool=false) ；文件或者目录大小：129；目录名称是：.tcshrc
是否为目录：%!V(bool=false) ；文件或者目录大小：12288；目录名称是：.bash_profile.swp
是否为目录：%!V(bool=false) ；文件或者目录大小：12790；目录名称是：.bash_history
是否为目录：%!V(bool=false) ；文件或者目录大小：18；目录名称是：.bash_logout
是否为目录：%!V(bool=false) ；文件或者目录大小：2856；目录名称是：anaconda-ks.cfg
是否为目录：%!V(bool=false) ；文件或者目录大小：56；目录名称是：.gitconfig
是否为目录：%!V(bool=false) ；文件或者目录大小：176；目录名称是：.bashrc
是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：.ssh
是否为目录：%!V(bool=false) ；文件或者目录大小：12480；目录名称是：install.log
是否为目录：%!V(bool=false) ；文件或者目录大小：4088；目录名称是：install.log.syslog
是否为目录：%!V(bool=false) ；文件或者目录大小：100；目录名称是：.cshrc
[root@yinzhengjie day3]#
[root@yinzhengjie day3]# go run ls.go /tmp/
是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：go-build655748897
是否为目录：%!V(bool=false) ；文件或者目录大小：1092；目录名称是：ks-script-ddWzzz
是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：cactiez
是否为目录：%!V(bool=false) ；文件或者目录大小：0；目录名称是：ks-script-ddWzzz.log
是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：go-build551514124
是否为目录：%!V(bool=true) ；文件或者目录大小：4096；目录名称是：.ICE-unix
是否为目录：%!V(bool=false) ；文件或者目录大小：52475；目录名称是：ins.log
是否为目录：%!V(bool=false) ；文件或者目录大小：0；目录名称是：yum.log
[root@yinzhengjie day3]#
C>.模拟操作系统中的ps基础功能命令；
[root@yinzhengjie day3]# more ps.go
/*
#!/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:y1053419035@qq.com
*/ package main import (
"os"
"log"
"fmt"
"strconv"
"io/ioutil"
)
/*
注意：linux操作系统中：/proc存放的进程的PID，基本上都是以数字目录形式记录，而在这些数字目录中的“cmdline”文件则记录着具体进程，当然还有exe记录的信息更加完整！
*/ func main() {
filepath := "/proc"
f,err := os.Open(filepath) //打开文件路径，如果打开当前路径就输入“.”
if err != nil {
log.Fatal(err)
}
infos,_ := f.Readdir(-) //表示最大读取的个数，这个“-1”表示读取该文件的全部内容。
for _,info := range infos{
//fmt.Printf("是否是目录：%v 文件大小是：%d 文件名称是：%s\n",info.IsDir(),info.Size(),info.Name())
if info.IsDir() {
n,err := strconv.Atoi(info.Name()) //将字符串转换成数字，但是并不是所有的字符串都能转换成数字哟！除非字符串本分并不包含非数字的元素。
if err != nil {
//fmt.Println("转换失败：",err)
continue
}
//fmt.Println(n)
filepath = filepath+"/"+ info.Name()
f1,err := os.Open(filepath)
if err != nil {
log.Fatal(err)
}
filepath = "/proc"
files,_ := f1.Readdir(-)
for _,arg := range files{
if arg.Name()=="cmdline" {
// fmt.Println(arg.Name())
buf,err := ioutil.ReadFile(filepath+"/"+ info.Name()+"/"+arg.Name())
if err != nil {
log.Fatal(err)
}
fmt.Println(n,string(buf))
}
}
}
}
f.Close()
}
[root@yinzhengjie day3]#
最初笔记戳这里，下面未折叠的是我优化后的代码
/*
#!/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:y1053419035@qq.com
*/ package main import (
"fmt"
"io/ioutil"
"log"
"os"
"strconv"
) func catFile(pid string, fileName string) {
var s string
buf, err := ioutil.ReadFile(fileName) //读取文件内容，即pid/cmdline文件内容
if err != nil {
log.Fatal(err) //如果文件不存在或是权限异常就打印出来，并且会附带时间戳效果哟！
return
}
s = string(buf) //将读取的内容变成字符串。
if len(s) > 0 { //如果读取的cmdline文件的内容不为空，就打印其的PID（数字目录）和进程名称。
fmt.Printf("进程的PID是：%v\t进程的名称是：%v\n", pid, s)
} else { fmt.Println("我天，这个PID进程是属于系统的BASH的哟！")
}
} func main() {
var fileName string
f, err := os.Open(os.Args[1]) //打开命令行位置参数下表为1的文件。
fmt.Println(f)
if err != nil {
log.Fatal(err)
}
infos, _ := f.Readdir(-1) //获取目录下的所有文件和目录。
for _, info := range infos {
_, err := strconv.Atoi(info.Name())
if info.IsDir() && err == nil { //判断是否为目录，并且转换成int类型时无报错
fileName = os.Args[1] + info.Name() + "/cmdline" //拼接其绝对路径。
catFile(info.Name(), fileName) //将数字的目录和其绝对路径传给函数catFile函数。
}
}
f.Close()
}
注意：以上代码仅适用于Linux操作系统，可能你换成MAC就不好使了，WINDOWS也不好使，建议用CentOs对代码进行测试，因为系统都有/proc目录。
[root@yinzhengjie day3]# gofmt -w ps.go
[root@yinzhengjie day3]# go run ps.go /proc/
&{0xc42006e080}
进程的PID是：1 进程的名称是：/sbin/init
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
进程的PID是：406 进程的名称是：/sbin/udevd-d
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
进程的PID是：1317 进程的名称是：/usr/sbin/vmware-vmblock-fuse-osubtype=vmware-vmblock,default_permissions,allow_other/var/run/vmblock-fuse
进程的PID是：1338 进程的名称是：/usr/sbin/vmtoolsd
进程的PID是：1363 进程的名称是：/usr/lib/vmware-vgauth/VGAuthService-s
进程的PID是：1423 进程的名称是：./ManagementAgentHost
进程的PID是：1619 进程的名称是：auditd
进程的PID是：1641 进程的名称是：/sbin/portreserve
进程的PID是：1649 进程的名称是：/sbin/rsyslogd-i/var/run/syslogd.pid-c5
进程的PID是：1679 进程的名称是：irqbalance--pid=/var/run/irqbalance.pid
进程的PID是：1695 进程的名称是：rpcbind
进程的PID是：1740 进程的名称是：dbus-daemon--system
进程的PID是：1753 进程的名称是：NetworkManager--pid-file=/var/run/NetworkManager/NetworkManager.pid
进程的PID是：1758 进程的名称是：/usr/sbin/modem-manager
进程的PID是：1774 进程的名称是：rpc.statd
进程的PID是：1810 进程的名称是：cupsd-C/etc/cups/cupsd.conf
进程的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
进程的PID是：1855 进程的名称是：/usr/sbin/acpid
进程的PID是：1865 进程的名称是：hald
进程的PID是：1866 进程的名称是：hald-runner
进程的PID是：1911 进程的名称是：hald-addon-input: Listening on /dev/input/event0 /dev/input/event2
进程的PID是：1917 进程的名称是：hald-addon-acpi: listening on acpid socket /var/run/acpid.socket
进程的PID是：1943 进程的名称是：/usr/sbin/sshd
进程的PID是：1953 进程的名称是：xinetd-stayalive-pidfile/var/run/xinetd.pid
进程的PID是：2112 进程的名称是：/usr/libexec/postfix/master
进程的PID是：2133 进程的名称是：qmgr-l-tfifo-u
进程的PID是：2140 进程的名称是：/usr/sbin/abrtd
进程的PID是：2151 进程的名称是：crond
进程的PID是：2165 进程的名称是：/usr/sbin/atd
进程的PID是：2178 进程的名称是：/usr/sbin/cimserver
进程的PID是：2204 进程的名称是：/sbin/mingetty/dev/tty2
进程的PID是：2206 进程的名称是：/sbin/mingetty/dev/tty3
进程的PID是：2208 进程的名称是：/sbin/mingetty/dev/tty4
进程的PID是：2210 进程的名称是：/sbin/mingetty/dev/tty5
进程的PID是：2212 进程的名称是：/sbin/mingetty/dev/tty6
进程的PID是：2251 进程的名称是：/usr/sbin/console-kit-daemon--no-daemon
进程的PID是：2327 进程的名称是：/usr/libexec/devkit-power-daemon
进程的PID是：2379 进程的名称是：/usr/libexec/polkit-1/polkitd
进程的PID是：2392 进程的名称是：/usr/libexec/rtkit-daemon
进程的PID是：2513 进程的名称是：/usr/libexec/udisks-daemon
进程的PID是：2515 进程的名称是：udisks-daemon: polling /dev/sr0
进程的PID是：2578 进程的名称是：/usr/sbin/restorecond-u
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
进程的PID是：3333 进程的名称是：/sbin/dmeventd
我天，这个PID进程是属于系统的BASH的哟！
我天，这个PID进程是属于系统的BASH的哟！
进程的PID是：3581 进程的名称是：/sbin/udevd-d
进程的PID是：3582 进程的名称是：/sbin/udevd-d
进程的PID是：6520 进程的名称是：/sbin/mingetty/dev/tty1
进程的PID是：6689 进程的名称是：/usr/sbin/gdm-binary-nodaemon
进程的PID是：6704 进程的名称是：/usr/libexec/gdm-simple-slave--display-id/org/gnome/DisplayManager/Display1
进程的PID是：6707 进程的名称是：/usr/bin/Xorg:0-br-verbose-audit4-auth/var/run/gdm/auth-for-gdm-IfKotc/database-nolistentcpvt1
进程的PID是：6728 进程的名称是：/usr/bin/dbus-launch--exit-with-session
进程的PID是：6729 进程的名称是：/bin/dbus-daemon--fork--print-pid5--print-address7--session
进程的PID是：6731 进程的名称是：/usr/bin/gnome-session--autostart=/usr/share/gdm/autostart/LoginWindow/
进程的PID是：6734 进程的名称是：/usr/libexec/gconfd-2
进程的PID是：6735 进程的名称是：/usr/libexec/at-spi-registryd
进程的PID是：6739 进程的名称是：/usr/libexec/gnome-settings-daemon--gconf-prefix=/apps/gdm/simple-greeter/settings-manager-plugins
进程的PID是：6741 进程的名称是：/usr/libexec/bonobo-activation-server--ac-activate--ior-output-fd=12
进程的PID是：6749 进程的名称是：/usr/libexec/gvfsd
进程的PID是：6750 进程的名称是：metacity
进程的PID是：6753 进程的名称是：/usr/libexec/gdm-simple-greeter
进程的PID是：6755 进程的名称是：gnome-power-manager
进程的PID是：6756 进程的名称是：/usr/libexec/polkit-gnome-authentication-agent-1
进程的PID是：6758 进程的名称是：plymouth-log-viewer--icon
进程的PID是：6775 进程的名称是：/usr/bin/pulseaudio--start--log-target=syslog
进程的PID是：6778 进程的名称是：pam: gdm-password
进程的PID是：7343 进程的名称是：sshd: root@pts/0
进程的PID是：7350 进程的名称是：-bash
进程的PID是：7797 进程的名称是：viuppercase.go
进程的PID是：8579 进程的名称是：pickup-l-tfifo-u
进程的PID是：8898 进程的名称是：/usr/sbin/anacron-s
进程的PID是：8904 进程的名称是：sshd: root@pts/2
进程的PID是：8911 进程的名称是：-bash
进程的PID是：9075 进程的名称是：vips.go
进程的PID是：9082 进程的名称是：sshd: root@pts/3
进程的PID是：9089 进程的名称是：-bash
进程的PID是：9300 进程的名称是：gorunps.go/proc/
进程的PID是：9318 进程的名称是：/tmp/go-build752959693/command-line-arguments/_obj/exe/ps/proc/
[root@yinzhengjie day3]#
程序用法展示
对了，再给大家推荐一个Golang的官方文档链接：http://godoc.org/
GO语言的进阶之路-Golang字符串处理以及文件操作的更多相关文章
- GO语言的进阶之路-Golang高级数据结构定义
GO语言的进阶之路-Golang高级数据结构定义 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 我们之前学习过Golang的基本数据类型,字符串和byte,以及rune也有所了解, ...
- Golang字符串处理以及文件操作
一.整数 1.int与uint的初值比较以及其大小. 1 /* 2 #!/usr/bin/env gorun 3 @author :xxxx 4 Blog:http://www.cnblogs.com ...
- GO语言的进阶之路-流程控制
GO语言的进阶之路-流程控制 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 流程控制在编程语言中是最伟大的发明了,因为有了它,你可以通过很简单的流程描述来表达很复杂的逻辑.流程控制 ...
- GO语言的进阶之路-网络安全之proxy
GO语言的进阶之路-网络安全之proxy 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 在党的带领下,我们大陆的孩子身心健康还是杠杠的,尤其是像我这种农村孩纸,从来不会像<人 ...
- GO语言的进阶之路-网络编程之socket
GO语言的进阶之路-网络编程之socket 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.什么是socket; 在说socket之前,我们要对两个概念要有所了解,就是IP和端口 ...
- GO语言的进阶之路-协程和Channel
GO语言的进阶之路-协程和Channel 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 看过我之前几篇博客小伙伴可能对Golang语言的语法上了解的差不多了,但是,如果想要你的代码 ...
- GO语言的进阶之路-面向对象编程
GO语言的进阶之路-面向对象编程 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 当你看完这篇文章之时,我可以说你的Golang算是入门了,何为入门?就是你去看Docker 源码能看 ...
- GO语言的进阶之路-面向过程式编程
GO语言的进阶之路-面向过程式编程 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 我们在用Golang写一个小程序的时候,未免会在多个地方调用同一块代码,这个时候如何优化你的代码呢 ...
- GO语言的进阶之路-go的程序结构以及包简介
GO语言的进阶之路-go的程序结构以及包简介 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.编辑,编译和运行 A,编辑 Go程序使用UTF-8编码的纯Unicode文本编写.大 ...
随机推荐
- oracle加注释
COMMENT ON table GC_G_DOC84 IS '行政处罚撤销决定书'; COMMENT ON column GC_G_DOC84.CASEID IS '案件记录ID';
- 小学生四则运算APP核心代码公布
Mainactivity类: package com.example.XXSCYS; import java.io.ByteArrayOutputStream; import java.io.File ...
- Android 學習之旅!(2)
早幾天因爲學車,弄了幾天時間和精力過去,今天終於考過了(科目二,還是補考的...)嗯..不管這麼多了..今天又開始我的android 學習之旅!! 筆記: platform-tools目錄下的文件: ...
- Sprint 冲刺第二阶段之1---5天（上）
11月24号——12月8号,这一个时间段学校的电压不是很稳定,时不时会断电,为了冲刺的完整性,我们商量决定把这一时间段做的事情写成一个连贯的小日记.然后统一在整个时间段一起发出来. 经过一个阶段的努力 ...
- SVN入门教程
1. 什么是SVN SVN全名Subversion,即版本控制系统.SVN与CVS一样,是一个跨平台的软件,支持大多数常见的操作系统. 作为一个开源的版本控制系统,Subversion管理者随时间改变 ...
- Jenkins and Python
https://jenkins.io/solutions/python/ In the Python ecosystem there are tools which can be integrated ...
- python下对appium服务端的操作
appium -p 4703 -bp 5500 -U 127.0.0.1:5005 -p 指的是·appium的服务器端口 -bp 指的是 连接安卓设备端口 -U 指的是 安卓设备 大体思路: 1. ...
- BZOJ2796[Poi2012]Fibonacci Representation——贪心+二分查找
题目描述 给出一个正整数x,问x最少能由多少个Fibonacci数加减算出. 例如1070=987+89-5-1,因此x=1070时答案是4. 输入 第一行一个正整数q (q<=10),表示有q ...
- ZOJ2836-Number Puzzle-容斥原理
依次考虑一个数的倍数,两个数的倍数(lcm),三个数的倍数(lcm)... 会发现有这么一个规律,奇数个数时要加上情况数,偶数个数时要减去情况数. 一种只有10个数,用二进制枚举所有情况即可. #in ...
- Codeforces Round #412 C. Success Rate
C. Success Rate time limit per test 2 seconds memory limit per test 256 megabytes input standard inp ...