一.整數
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 }