Go基础小计(一)

数组和切片

package main

import (
    "fmt"
)

func main() {
    /*
    * 数组
    */

    // 定义
    myArray := [5]int{1, 2, 3, 4, 5} // 变量名 := [数组长度] 变量类型 {}
    // 通过初始化值确定数组长度: myArray := [...]int{1,2,3}
    // 使用索引号初始化元素: myArray := [5]int{2: 100, 4: 200}
    // 二维: a := [2][3]int{{1, 2, 3}, {4, 5, 6}}

    // 遍历 for
    for i := 0; i < len(myArray); i++ {
        fmt.Println(myArray[i])
    }

    for i, v := range myArray {
        fmt.Println(i, v)
    }

    /*
    * 切片
    切片代表变长的序列, 抽象于数组,类似vector
    是一个数组的引用
    cap可以求出slice最大扩张容量,不能超出数组限制。0 <= len(slice) <= len(array),其中array是slice引用的数组。
    超出原 slice.cap 限制,就会重新分配底层数组,即便原数组并未填满。通常以 2 倍容量重新分配底层数组
    */

    // 方式1:从数组切片
    slice := myArray[0:3]                 // slice: [1 2 3]
    fullSlice := myArray[:]               // fullSlice: [1 2 3 4 5]
    fmt.Println(slice[2] == fullSlice[2]) // true,切片共享底层

    // 方式2:声明切片
    var s1 []int
    // s1 := []int{}
    if s1 == nil { // // nil 是 map、slice、pointer、channel、func、interface 的零值
        fmt.Println("是空")
    } else {
        fmt.Println("不是空")
    }

    // 方式3:make,避免了数组必须用常量做长度的麻烦。还可用指针直接访问底层数组,退化成普通数组操作。
    s2 := make([]int, 6, 8)           // 使用 make 创建,指定 len 和 cap 值。
    fmt.Println(s2, len(s2), cap(s2)) // [0 0 0 0 0 0] 6 8

    // 方式4:new, 返回地址
    s3 := new([]int)
    fmt.Println(s3) //  &[]

    // 内置的append函数用于向slice追加元素
    s4 := append(*s3, 2)
    fmt.Println(s4)  // [2]
}

Map

package main

import (
    "fmt"
)

func main() {
    /*
    * Map
    */

    // 方式1
    ages := make(map[string]int)
    ages["alice"] = 31
    ages["charlie"] = 34
    fmt.Println(ages) // map[alice:31 charlie:34]

    // 方式2  map[string]int{}

    // 访问:使用key
    ages["alice"] = 32

    value, exists := ages["alice"]
    fmt.Println(value, exists)  // 32 true

    // 删除:使用delete
    delete(ages, "alice")

}

结构体

package main

import (
    "fmt"
)

func main() {
    /*
        * 结构体
        Go语言中没有“类”的概念,也不支持“类”的继承等面向对象的概念。
        Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。
    */

    //类型定义
    type NewInt int

    //类型别名 别称,还是他自己
    type MyInt = int

    var a NewInt
    var b MyInt

    fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
    fmt.Printf("type of b:%T\n", b) //type of b:int

    // 结构体
    type Person struct {
        name string
        city string
        age  int8
    }

    // 1.初始化

    var p1 Person
    fmt.Printf(p1.name)

    // 2.new p2.name="Euler3"底层是(*p2).name="Euler3",Go语言帮我们实现的语法糖
    p2 := new(Person)
    p2.name = "Euler3"
    p2.age = 18
    p2.city = "Beijing"

    // 3.使用值的列表初始化&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作
    p3_0 := Person{"Euler", "Shanghai", 24}
    p3_1 := &Person{"Euler", "Shanghai", 24}
    fmt.Println(p3_0, p3_1)

    // 4.对结构体使用键值
    p4 := Person{
        name: "Euler4",
        city: "Shanghai",
        age:  18,
    }
    fmt.Printf("p4=%#v\n", p4) //p4=main.Person{name:"Euler4", city:"Shanghai", age:18}

    // 5.对结构体指针使用键值
    p5 := &Person{
        name: "Euler5",
        city: "Shanghai",
        age:  18,
    }
    fmt.Printf("p5=%#v\n", p5) //p5=&main.Person{name:"Euler5", city:"Shanghai", age:18}

}

指针

区别于C/C++中的指针,Go语言中的指针不能进行偏移和运算,是安全指针。

new与make的区别

  1. 二者都是用来做内存分配的。
  2. make只用于slice、map以及channel的初始化,返回的还是这三个引用类型本身;
  3. 而new用于类型的内存分配,并且内存对应的值为类型零值,返回的是指向类型的指针。

其他

Slice底层实现

Map实现原理

暂无评论

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇