golang的變量聲明

基本格式
var identifier [type] [= value]

例子

var a int
var b string
var c bool
var d int = 8
var e string = "hello"
var f = "hello"

例子2

var (
  a int
  b string
  c bool
  d int = 8
  e string = "hello"
)

這個就跟golang的package引入類似，可以用括號將多個項目括起來，這樣就只用寫一個var或者import。

例子3

a := 20

golang的常量聲明

基本格式
const identifier [type] = value

例子

const a int = 10
const b = 10
const c string = "233"
const d = "233"

例子2

const (
  a int = 100
  b = 10
  c string = "233"
  d = "233"
)

例子3

const (
  a = 100
  b 
  c = "233"
  d
)

和變量不同，常量的聲明可以在后面什么都不跟，例子中的b和d等于他們之前第一個有賦值的常量。即：b = 100 d = "233"

例子4

const (
  a = iota  //0
  b         //1
  c = 234   //234
  d = iota  //3
  e         //4
)

iota是一個很神奇的玩意。在一個const的括號內，第一個iota是0，之后的每一行，iota會自增1，無論你是否使用iota。

golang的基本類型

string

1. string的聲明
   string可以用雙引號"也可以用`來聲明。

var a = "123"
var b = `\n123`      //等同于C#中 var b = @"\n123"

2. string的常用操作

取字符串長度

var a = "123"
len(a)

格式化輸入到字符串

var a = 123
var c = fmt.Sprintf("%d",a)

字符串分割

var a = "123;234;345"
var aSlice = strings.Split(a,";")

字符串存在

var a = "123"
var aBool = strings.Contains(a,"2")

前后綴判斷

var a = "pre123suf"
var aPreBool = strings.HasPrefix(a,"pre")
var aSufBool = strings.HasSuffix(a,"suf")

字符串查找

var a = "1234561"
var index = strings.Index(a,"1")
index = strings.LastIndex(a,"1")

字符串拼接

var strArr []string = {"123","234","345"}
var result = strings.Join(strArr, ";")

3. string底層知識

底層是數(shù)組，可以和byte數(shù)組進行轉換

var str = "123456789"
var c = str[0]  //使用下標訪問元素
for index,val := range str {
  fmt.Printf("index = %d, value = %c", index, val)
}

字符串不能對單個元素直接進行更改(str[0] = '0'是非法的)。需要轉成切片再進行更改。

var str = "123"
strSlice = []byte(str)
strSlice[0] = '0'
str =  string(strSlice)

字符串是由byte字節(jié)存儲，所以字符串的長度是byte數(shù)組的長度。如果字符串中有中文，字符串長度會和字的個數(shù)不一致。

var str = "Hello, 中文"
fmt.Printf("length of str = %d", len(str))   //length of str = 13
runeSlice = []rune(str)
fmt.Printf("length of str = %d", len(runeSlice))   //length of str = 9

時間和日期類型

獲取當前時間

now := time.Now()

獲取時間戳

timeStamp := time.Now().Unix()

時間和時間戳轉換

now := time.Now()
timeStamp := now.Unix()
now = time.Unix(timeStamp,0)

定時器

ticker := time.Tick(time.Second)
for i:= range ticker{
  fmt.Printf("%v\n", i)
}

時間常量

const (
  Nanosecond Duration
  Microsecond = 1000 * Nacosecond
  Millisecond = 1000 * Microsecond
  Second = 1000 * Millisecond
)

格式化

now := time.Now()
now.Format("2006/01/02 15:04:05" )  //這時間是golang的誕生時間，只能寫這個

流程控制

if-else

和c系列的if-else非常類似，只是可以再一開始聲明一個變量，而且不用括號

a := 10
if a > 5 {
  fmt.Printfln("great than 5")
}
else {
  fmt.Printfln("less than 5")
}
fmt.Printf("value = %d", a)

if a := 10; a > 5 {
  fmt.Printfln("great than 5")
}
else {
  fmt.Printfln("less than 5")
}
fmt.Printf("value = %d", a)  //非法。a只能在if的范圍內使用

for

循環(huán)只有for，沒有while。
基本用法

for i := 0; i < 10; i++ {
  
}

while用法

for i < 10 {
}

無限循環(huán)

for {
}

range遍歷

for _, val := range b {
  sum += val
}

switch

基本用法，不需要跟break，默認就是有break的情況。

a := 10
switch a{
  case 1:
    //do something
  case 2:
    //do something
   default:
    //do something
}

和if一樣，可以在使用時聲明變量

switch a := 10; a{
  case 1:
    //do something
  case 2:
    //do something
   default:
    //do something
}

可以多個case放在一起

switch a := 10; a{
  case 1, 3, 5, 7, 9:
    //do something
  case 2, 4, 6, 8, 10:
    //do something
   default:
    //do something
}

可以不寫固定值，而是用條件控制

a := 10
switch {
  case a < 5:
    //do something
  case a > 5:
    //do something
   default:
    //do something
}

可以執(zhí)行多個case

a := 10
switch {
  case a < 5:
    //do something
    fallthrough
  case a <10:
    //do something
   default:
    //do something
}

函數(shù)

基本格式

func functionName([parameterName type]) [returnType]{
}

連續(xù)的相同類型的參數(shù)，可以只寫一次類型

func add(a, b int) int {
  return a + b
}

多返回值, 返回值可以直接命名。不需要的返回值用_忽略

func calc(a, b int) (int, int){
  sum := a + b
  sub := a - b
  return sum, sub
}

func calc1(a, b int) (sum, sub int) {
    sum = a + b
    sub = a - b
    return
}

aa, _ := calc(a, b)

可變參數(shù)

func calc(b ...int) int {
    sum := 0
    for _, val := range b {
        sum += val
    }
    return sum
}

defer延遲執(zhí)行。在函數(shù)返回之前執(zhí)行。執(zhí)行到defer時會進行壓棧操作，函數(shù)執(zhí)行完成后出棧執(zhí)行defer。壓棧時會把數(shù)據的當前值進行存儲，即使后面改變也不會生效。

func testDefer() {
    defer fmt.Println("first defer")
    defer fmt.Println("second defer")
    defer fmt.Println("third defer")
    sam = "sam"
    defer fmt.Println("hello %s", sam)
    sam = "peter"
    fmt.Println("hello %s", sam)
}
//輸出結果：
//hello peter
//hello sam
//third defer
//second defer
//first defer

函數(shù)可以存儲在變量中。類似于函數(shù)指針或者delegate?？梢月暶髂涿瘮?shù)。

func func1(name string) {
  fmt.Printf("Hello %s\n", name)
}

func test() {
  f1 := func1
  f1("peter")
  f1 = func(name string){
    fmt.Printf("Welcome %s\n", name)
  }
  f1("peter")
}
//輸出:
//Hello peter
//Welcome peter