8.基本資料型別

Go的基本資料型別有數字,字串,布林型。

a.布林型別
var b bool//var b bool = true/var b = false
操作符==和！=,取反！b,&&和||操作符,格式化%t
例：

  1: func main() {
  2: 	var a bool
  3: 	fmt.Println(a)
  4: 	a = true
  5: 	fmt.Println(a)
  6: 	a = !a
  7: 	fmt.Println(a)
  8: 	var b bool = true
  9: 	if a == true && b == true {
 
 10: 		fmt.Println("right")
 11: 	}else{
 12: 		fmt.Println("not right")
 13: 	}
 14: 	if a == true || b == true {
 15: 		fmt.Println("||right")
 16: 	}else{
 17: 		fmt.Println("not right")
 18: 	}
 19: 	fmt.Printf("%t-%t\n", a, b)
 20: }

b.整數和浮點數型別
有符號整數int和無符號整數uint:
int8,int16,int32,int64和uint8,uint16,uint32,uint64
與作業系統相關:
int和uint
浮點數:
float32和float64
注意：所有的整數初始化為0，所有浮點數初始化為0.0.布林型別初始化為false，例：

  1: func main(){
  2: 	var a int8
  3: 	a = 18
  4: 	fmt.Println("a=", a)
  5: 	a = -12
  6: 	fmt.Println("a=", a)
  7: 	var b int
  8: 	b = 232112332
  9: 	fmt.Println("b=", b)
 10: 	var c float32 = 1.13242
 11: 	fmt.Println("c=", c)
 12: }

Go是強型別語言，不同型別相加以及賦值一般是不允許的，下面是實現不同型別相加：

  1: b = int(a)

格式化輸出：

  1: fmt.Printf("a=%d a=%x c=%f\n", a, a, c)

輸出結果：

  1: //a=-12 a=-c c=1.132420

c.字串型別

var str string
var str string = "hello world!"
字串輸出佔位符%s
萬能輸出佔位符%v
兩種表示方式：
雙引號""和反引號``(字元原樣輸出)

  1: func main() {
  2: 	var a string = "hello world!"
  3: 	var b = "hello world_2!"
  4: 	fmt.Printf("a=%s\nb=%s\n", a, b)
  5: 	c := a
  6: 	fmt.Printf("c=%s\n",c)
  7: 	d := "d:hello world_3!"
  8: 	fmt.Println(d)
  9: 	fmt.Printf("a=%v b=%v c=%v d=%v\n", a, b, c, d)
 10: 	e := `c:\n
 11: 	hello\nhello\nhello
 12: 	hello\nhello\n`
 13: 	fmt.Println("e=",e)
 14: }

字串常用操作:

長度：len(str)
拼接：+，fmt.Sprintf
分割:strings.Split
包含:strings.Contains
字首或字尾判斷：strings.HasPrefix,strings.HasSuffix
子串出現的位置: strings.Index(),strings.LastIndex()
join操作: strings.Join(a[]string, sep string)

例：

  1: func main(){
  2: 	c := "hello world!"
  3: 	clen := len(c)
  4: 	fmt.Printf("len of c = %d\n", clen)
  5: 	c1 := c + c
  6: 	c2 := fmt.Sprintf("%s%s", c, c)
  7: 	fmt.Printf("c1=%s\nc2=%s\n", c1, c2)
  8: 	ips := "10.108.34.30;10.108.34.34"
  9: 	ipsArray := strings.Split(ips, ";")
 10: 	fmt.Println("ips[0]=",ipsArray[0])
 11: 	result := strings.Contains(ips, "10.108.34.31")
 12: 	fmt.Println(result)
 13: 	baidu_index := "http://baidu.com"
 14: 	if strings.HasPrefix(baidu_index, "http"){
 15: 		fmt.Printf("str is http url")
 16: 	}else{
 17: 		fmt.Printf("str is not http url")
 18: 	}
 19: 	index := strings.Index(baidu_index, "baidu")
 20: 	fmt.Printf("baidu is index:%d\n", index)
 21: 	index = strings.LastIndex(baidu_index, "baidu")
 22: 	fmt.Printf("baidu last index:%d\n", index)
 23: 	var str []string = []string{"10.237.8.2","10.237.8.2","10.237.8.2"}
 24: 	result_2 := strings.Join(str, "|")
 25: 	fmt.Printf("result_2=%s\n", result_2)
 26: }

操作符：（這個太簡單就不寫例子了）
邏輯操作符： ==,!=,<,<=,>=
算數操作符： +,-,*,/,%

9.go語言的基本結構

  1: package main 
  2: import (
  3: 	"fmt"
  4: 	"os"
  5: ) 
  6: func main() { 
  7:     fmt.Println(“hello, world”) 
  8: }

1. 任何一個程式碼檔案隸屬於⼀個包
2. import 關鍵字,引用其他包：
3. 開發可執行程式，package main,並且有且只有一個main入口函式
4. 包中函式呼叫：
    a. 同一個包中函式,直接用函式名調⽤
    b. 不同包中函式,通過包名+點+ 函式名進行呼叫
5. 包訪問控制規則：
    a. ⼤寫意味著這個函式/變量是可匯出的
    b. ⼩寫意味著這個函式/變數是私有的,包外部不不能訪問