1. 定义结构体:

    1
    2
    3
    4
    5
    6
    
        type struct_variable_type struct {
       member definition;
       member definition;
       ...
       member definition;
    }
    
  2. 结构体example:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    
    // struct_test2.go
    
    package main
    	
    import (
        "fmt"
    )
    	
    type Book struct {
        author  string
        title   string
        book_id int
        subject string
    }
    	
    func main() {
        var book1 Book
        book1.author = "lryong1"
        book1.title = "test1"
        book1.subject = "wulala"
        book1.book_id = 1
    	
        var book2 Book
        book2.author = "lryong2"
        book2.title = "test2"
        book2.subject = "wakaka"
        book2.book_id = 2
    	
        gen_inform(&book1) //传递book1结构体的地址
        gen_inform(&book2)
    	
    }
    	
    func gen_inform(*a Book) { //结构体指针
        fmt.Printf("Book's title is %s\n", a.title)
        fmt.Printf("Book's author is %s\n", a.author)
        fmt.Printf("Book's book_id is %d\n", a.book_id)
        fmt.Printf("Book's subject is %s\n", a.subject)
        fmt.Printf("Book's information is %d\n", a.try_method())
        fmt.Println("============================")
    }
    	
    func (a Book) try_method() int {
        return a.book_id << 4
    }
    
  3. Golang的双引号和反引号,单引号:

    • 双引号和反引号都用于表示一个常量字符串。
    • 双引号用来创建可解析的字符串字面量(支持转义,但不能用来引用多行)。
    • 反引号用来创建原生的字符串字面量,这些字符串可能由多行组成(不支持任何转义序列),原生的字符串字面量多用于书写多行消息、HTML以及正则表达式。
    • 而单引号则用于表示Golang的一个特殊类型:rune,类似其他语言的byte但又不完全一样,是指:码点字面量(Unicode code point),不做任何转义的原始内容。
  4. Go 数组的长度不可改变,在特定场景中这样的集合就不太适用,Go中提供了一种灵活,功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的,可以追加元素,在追加时可能使切片的容量增大。

  5. Go 语言中 range 关键字用于for循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引值,在集合中返回 key-value 对的 key 值。example:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    
    // range_test1.go
    package main
    	
    import (
        "fmt"
    )
    	
    func main() {
        //使用range求一个slice的和,跟使用数组相似
        var test = []int{2, 4, 6}
        sum := 0
    	
        for _, num := range test { //"_"只是可写变量,省略索引
            sum += num
        }
    	
        fmt.Println("sum result is ", sum)
    	
        for i, v := range test {
            if v == 6 {
                fmt.Println("index:", i)
            }
        }
        //range也可以用在map的键值对上。
        kvs := map[string]string{"a": "apple", "b": `banana`}
        for k, v := range kvs {
            fmt.Printf("%s -> %s\n", k, v)
        }
        //range也可以用来枚举Unicode字符串。第一个参数是字符的索引,第二个是字符(Unicode的值)本身
        for i, c := range "go" {
            fmt.Printf("%d -> %d\n", i, c)
        }
    	
    }
    
  6. Go语言Map(集合):Map 是一种集合,所以我们可以像迭代数组和切片那样迭代它。不过,Map 是无序的,我们无法决定它的返回顺序,这是因为 Map 是使用 hash 表来实现的。定义方式:

    1
    2
    3
    4
    5
    
        /* 声明变量,默认 map 是 nil */
    var map_variable map[key_data_type]value_data_type
    	
    /* 使用 make 函数 */
    map_variable = make(map[key_data_type]value_data_type)
    
    • example:
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    
        // map_test1.go
    package main
    	
    import (
        "fmt"
    )
    	
    func main() {
        // var countryCapitalMap map[string]string //gen map,无序
        countryCapitalMap := make(map[string]string)
    	
        countryCapitalMap["France"] = "Paris"
        countryCapitalMap["Italy"] = "Rome"
        countryCapitalMap["Japan"] = "Tokyo"
        countryCapitalMap["India"] = "New Delhi"
        countryCapitalMap["United States"] = "New York"
    	
        for country := range countryCapitalMap {
            fmt.Printf("The capital of %s is %s\n", country, countryCapitalMap[country])
        }
    	
        capital, ok := countryCapitalMap["United States"] //查看元素在集合中是否存在
        if ok {
            fmt.Println("Capital of United States is ", capital, "!!!")
        } else {
            fmt.Println("Capital of United States is not present.")
        }
    	
        delete(countryCapitalMap, "United States")
        fmt.Println("United States has been deleted.")
    }
    
  7. 接口:Go 语言提供了另外一种数据类型即接口,它把所有的具有共性的方法定义在一起,任何其他类型只要实现了这些方法就是实现了这个接口。

    • example:
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    
    // interface_example1.go
    package main
    	
    import (
        "fmt"
    )
    	
    type Phone interface {
        call()
    }
    	
    type NokiaPhone struct{}
    	
    func (phone NokiaPhone) call() {
        fmt.Println("I'm Nokia,I can call you!")
    }
    	
    type IPhone struct{}
    	
    func (phone IPhone) call() {
        fmt.Println("I'm iphone,I can call you!")
    }
    	
    func main() {
        var test_phone Phone
        test_phone = new(NokiaPhone)
        test_phone.call()
    	
        test_phone = new(IPhone)
        test_phone.call()
    }
    
  8. Go 语言通过内置的错误接口提供了非常简单的错误处理机制。error类型是一个接口类型.