Golang基础面试题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package example

// 结构体定义，字段 age 是私有的
type Person struct {
    name string
    age  int
}

// 包内函数，能够访问私有字段
func NewPerson(name string, age int) Person {
    return Person{name: name, age: age}
}

func GetPersonAge(p Person) int {
    return p.age
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import (
    "fmt"
    "example" // 假设 example 是定义 Person 的包
)

func main() {
    p := example.NewPerson("John", 30)

    // 不能直接访问 p.age，因为 age 是私有的
    // fmt.Println(p.age) // 编译错误

    // 可以通过包内公开的函数访问私有成员
    age := example.GetPersonAge(p)
    fmt.Println("Age:", age) // 输出: Age: 30
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    name string
    age  int
}

func main() {
    p := Person{name: "John", age: 30}

    // 获取指向 p 的指针的反射值，Elem 方法用于获取指针指向的值。
    v := reflect.ValueOf(&p).Elem()

    // 获取私有字段 name
    nameField := v.FieldByName("name")

    fmt.Println("name (private):", nameField.String())
}

 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

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

type Person struct {
    name string
    age  int
}

func main() {
    p := Person{name: "John", age: 30}

    // 获取指向 p 的指针的反射值，Elem 方法用于获取指针指向的值。
    value := reflect.ValueOf(&p).Elem()

    // 通过 FieldByName 方法获取私有字段的值
    field := value.FieldByName("name")

    // 使用 unsafe.Pointer 和反射来操作私有字段
    realField := reflect.NewAt(field.Type(), unsafe.Pointer(field.UnsafeAddr())).Elem()

    // 输出私有字段的值
    fmt.Println("name (private):", realField.String())
}

1

<目标类型的值>, <布尔值> := <表达式>.(<目标类型>)

1
2

var x interface{} = 10
y := x.(int) // 将 x 断言为 int 类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import (
    "fmt"
)

func main() {
    var x interface{}
    x = 100
    value, ok := x.(int) // 输出100
    if ok {
        fmt.Println(value) // 输出100
    }

    value2, ok := x.(string)
    if ok { // ok=false，所以不进入这个分支
        fmt.Println(value2)
    }
}

1
2
3
4

var i interface{} = 12 // 接口存储有一个 int 类型的值
v := i.(int)          // 断言后 v 是 i 中 int 的拷贝
v = 100               // 修改 v 不会影响接口 i 中的值
fmt.Println(i)        // 输出 12

1
2
3
4
5
6
7
8

type MyStruct struct {
    Field int
}

var i interface{} = &MyStruct{Field: 12} // 接口存储有一个 *MyStruct 指针
v := i.(*MyStruct)                       // 断言后 v 是同一个 *MyStruct 指针
v.Field = 100                            // 修改 v 会影响接口 i 中的数据
fmt.Println(i.(*MyStruct).Field)          // 输出 100

 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

package main

import (
    "fmt"
)

type MyStruct struct {
    Field int
}

func main() {
    var i interface{} = MyStruct{Field: 12}

    if ms, ok := i.(MyStruct); ok {
        // 使用 &p 显示内存地址
        fmt.Printf("Address of ms: %p\n", &ms)
        fmt.Printf("Address of i: %p\n", &i)
        fmt.Println(ms.Field) // 输出：12
    }

    // 尝试修改 ms 的 Field 值
    ms.Field = 123

    // 无法修改，依然输出12
    if ms2, ok := i.(MyStruct); ok {
        fmt.Println(ms2.Field) // 输出：12
    }

    // 如果我们想要通过接口修改原始值，需要确保接口持有的是引用类型（如指针）
    var ip interface{} = &MyStruct{Field: 12}
    if msp, ok := ip.(*MyStruct); ok {
        msp.Field = 1234567
    }

    // 现在通过断言再次获取，验证修改
    if ms3, ok := ip.(*MyStruct); ok {
        fmt.Println(ms3.Field) // 输出：1234567
    }
}

1
2
3
4
5

Address of ms: 0xc0000ec098
Address of i: 0xc0000ec299
12
12
1234567

1
2

var a int = 10
var b int32 = int32(a) // 类型转换

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//定义接口
type Speaker interface {
    Speak()
}

// 实现接口的类型
type Duck struct {}

// 定义接口要求的方法
func (d Duck) Speak() {
    fmt.Println("mianshiya!")
}

func main() {
    var s Speaker = Duck{} // 接口赋值
    s.Speak()             // 接口方法调用
}

1
2
3
4
5

// 非空接口
type iface struct {
    tab *itab         // 指向类型信息和方法表
    data unsafe.Pointer // 指向实际的数据
}

1
2
3
4
5

// 空接口
type eface struct {
    _type *_type         // 数据类型信息
    data  unsafe.Pointer  // 指向实际的数据
}

1
2
3
4
5
6
7

type itab struct {
    inter *interfacetype // 接口类型信息
    _type *_type         // 实现接口的具体类型信息
    hash  uint32         // 类型 hash 值
    _     [4]byte
    fun   [1]uintptr     // 实现接口方法的函数地址
}

1
2
3
4
5

type interfacetype struct {
	typ     _type
	pkgpath name
	mhdr    []imethod // 具体方法列表
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func convT2I(inter *interfacetype, tab *itab, t *_type, v unsafe.Pointer) (iface, bool) {
    var i iface
    if tab == nil {
        tab = getitab(inter, t, false)
    }
    if tab == nil {
        return i, false
    }
    i.tab = tab
    i.data = v
    return i, true
}

1
2
3
4
5
6

func assertE2I(inter *interfacetype, e eface) (i iface) {
    tab := getitab(inter, e._type, true)
    i.tab = tab
    i.data = e.data
    return
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//定义接口
type Speaker interface {
    Speak()
}

// 实现接口的类型
type Duck struct {}

// 定义接口要求的方法
func (d Duck) Speak() {
    fmt.Println("mianshiya!")
}

func main() {
    var s Speaker = Duck{} // 接口赋值
    s.Speak()             // 接口方法调用
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 实现闭包的函数
func adder() func(int) int {
    sum := 0                   // 定义外部作用域的变量
    return func(x int) int {   // 返回一个匿名函数
        sum += x               // 操作外部作用域的变量
        return sum             // 返回结果
    }
}
func main() {
    pos, neg := adder(), adder()   // 创建两个闭包
    for i := 0; i < 10; i++ {
        fmt.Println(pos(i), neg(-2*i))  // 调用闭包
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func incrementer() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
func main() {
    inc := incrementer()
    fmt.Println(inc()) // 1
    fmt.Println(inc()) // 2
    fmt.Println(inc()) // 3
}

 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

func CalcFactory(operation string) func(int, int) int {
	switch operation {
	case "add":
		return func(a, b int) int {
			return a + b
		}
	case "subtract":
		return func(a, b int) int {
			return a - b
		}
	case "multiply":
		return func(a, b int) int {
			return a * b
		}
	case "divide": // 这里是向下取整了，因为函数签名返回是int
		return func(a, b int) int {
			if b != 0 {
				return a / b
			}
			return 0
		}
	default:
		return nil
	}
}
func main() {
	addFunc := CalcFactory("add")
	subtractFunc := CalcFactory("subtract")
	multiplyFunc := CalcFactory("multiply")
	divideFunc := CalcFactory("divide")

	fmt.Println(addFunc(4, 5)) //9
	fmt.Println(subtractFunc(4, 5)) // -1
	fmt.Println(multiplyFunc(4, 5))// 20
	fmt.Println(divideFunc(5, 4))// 1
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func doubleAndPrint(fn func(int) int) func(int) int {
    return func(x int) int {
        result := fn(x)
        fmt.Println("Result:", result*2)
        return result
    }
}
func square(x int) int {
    return x * x
}
func main() {
    doubleSquare := doubleAndPrint(square)
    doubleSquare(3) // 18 (3*3*2)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func TaskAsync(input int, callback func(int)) {
    go func() {
       time.S leep(1 * time.Second)// 模拟运算操作
       result := input * 3
       callback(result)
    }()
}
func main() {
    callback := func(result int) {
       fmt.Println("操作结果：", result) // 输出30
    }
    TaskAsync(10, callback) 
    time.S leep(5 * time.Second) // 让主协程hang主，避免程序结束。
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func main() {
	var wg sync.WaitGroup
	var urls = []string{
		"http://www.google.com/",
		"http://golang.org/",
		"http://m.baidu.com/",
	}
	for _, url := range urls {
		wg.Add(1)
		go func(url string) {
			defer wg.Done()
			// http.Get(url)
			fmt.Println(url)
		}(url)
	}
	wg.Wait()
}

1
2

arr := []int{1, 2, 3}
fmt.Println(arr[5]) // 触发 panic: runtime error: index out of range

1
2
3
4
5

var ptr *int
fmt.Println(*ptr) // 触发 panic: runtime error: invalid memory address or nil pointer dereference

var m map[string]string
m["a"] = "3123" // 触发 panic: assignment to entry in nil map

1

panic("something went wrong") // 触发 panic

1
2

var i interface{} = "string"
num := i.(int) // 触发 panic: interface conversion: interface {} is string, not int

1

result := 1 / 0 // 触发 panic: runtime error: integer divide by zero

1
2
3
4

import "unsafe"

var p unsafe.Pointer
*(*int)(p) = 42 // 触发 panic: runtime error: invalid memory address or nil pointer dereference

1
2
3
4
5
6
7
8
9

func safeDivide(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()
    result = a / b
    return
}

1
2
3
4
5
6
7
8
9

type Book struct {
    title string
}
func main() {
    b := Book{title: "Go Programming"}
    p := &b
    // 显式解引用
    fmt.Println((*p).title)
}

1
2
3
4
5
6
7
8
9

type Book struct {
    title string
}
func main() {
    b := Book{title: "Go Programming"}
    p := &b
    // 简写方式
    fmt.Println(p.title)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type Book struct {
    title string
}
func (b *Book) printTitle() {
    fmt.Println(b.title)
}
func main() {
    b := Book{title: "Go Programming"}
    p := &b
    // 调用方法时，Go 会自动解引用
    p.printTitle()  // 等价于 (*p).printTitle()
}

1
2
3
4
5
6
7
8

type Person struct {
	Name string
	Age  int
}
func main() {
	people := []*Person{{"Alice", 30}, {"Bob", 31}}
	fmt.Println(people[0].Name) // 输出：Alice
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

type Address struct {
	City string
}
type Person struct {
	Name    string
	Age     int
	Address *Address
}
func main() {
	p := &Person{
		Name: "Alice",
		Age:  30,
		Address: &Address{
			City: "Beijing",
		},
	}
	fmt.Println(p.Address.City) // 输出：Beijing
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    // 处理文件的逻辑
}

1
2
3
4
5
6

func main() {
    x := 0
    defer func() { fmt.Println("deferred x:", x) }() // 这里捕获的是x的引用
    x = 1
    fmt.Println("Normal x:", x)
}

1
2

Normal x: 1
deferred x: 1

1
2
3
4
5
6

func main() {
    x := []int64{0}
    defer fmt.Println("deferred x:", x) // 这里捕获的是x的引用
    x[0] = 1
    fmt.Println("Normal x:", x)
}

1
2

Normal x: [1]
deferred x: [1]

1
2
3
4
5
6
7

func main() {
    for i := 0; i < 3; i++ {
        defer func(item int) {  // 函数调用
                fmt.Println(item)
        }(i)
    }
}

1
2
3

2
1
0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func main() {
    var p *int // 声明指针变量，但不分配内存，此时 p 是 nil

    if p == nil {
        fmt.Println("p 是 nil 指针")
    }

    // 这行代码会引发运行时错误
    // fmt.Println(*p)
}

 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

package main

import (
	"fmt"
)

type Address struct {
	City string
}

type Person struct {
	Name    string
	Age     int
	Address *Address  // Person 结构体中含有一个 Address指针 成员
}

func main() {
	var p *Person  // p 是一个指向Person的指针

        //访问 City 成员前，必须确认 p 和 p.Address 都不为nil
	if p != nil && p.Address != nil {
		fmt.Println(p.Address.City)  
	} else {
		fmt.Println("Nil pointer detected.")
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import "fmt"

func main() {
    // 使用 new 分配内存
    p := new(int)
    *p = 42
    fmt.Println(*p) // 输出：42

    // 使用 & 操作符分配内存
    var x int = 10
    px := &x
    fmt.Println(*px) // 输出：10
}

1
2
3
4
5
6
7
8
9

package main

func main() {
    var p *int
    if p != nil {
        // 这种情况不会发生，因为 p 是 nil
        println(*p)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import "fmt"

type Rect struct {
    Width, Height int
}

// 指针接收者方法
func (r *Rect) Area() int {
    return r.Width * r.Height
}

// 值接收者方法
func (r Rect) Perimeter() int {
    return 2 * (r.Width + r.Height)
}

func main() {
    r := Rect{Width: 10, Height: 5}
    fmt.Println("Area:", r.Area())
    fmt.Println("Perimeter:", r.Perimeter())
}

1
2
3
4

func createPointer() *int {
    x := 10
    return &x // x 逃逸到堆上
}

1
2
3
4
5
6

func closure() func() int {
    x := 10
    return func() int { // x 逃逸到堆上
        return x
    }
}

1
2
3
4
5
6

func goroutine() {
    x := 10
    go func() {
        fmt.Println(x) // x 逃逸到堆上
    }()
}

1

go build -gcflags="-m" main.go

1

main.go:5:6: moved to heap: x

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func stackAllocation() {
    x := 42 // x 分配在栈上
    fmt.Println(x)
}
func heapAllocation() *int {
    x := 42 // x 分配在堆上，因为返回了指针
    return &x
}
func main() {
    stackAllocation()

    p := heapAllocation()
    fmt.Println(*p)
}

1
2
3
4
5
6
7
8

func grow(slice []T, newCap int) []T {
    if newCap <= cap(slice) {
        return slice
    }
    newSlice := make([]T, len(slice), newCap)
    copy(newSlice, slice)
    return newSlice
}

1
2

var arr [5]int // 定义一个长度为5的数组
arr[0] = 10    // 可以直接访问和修改元素

1
2
3

func modifyArray(arr [5]int) {
  arr[0] = 100 // 修改数组不会影响原数组
}

1
2

slice := []int{1, 2, 3}
slice = append(slice, 4, 5) // 切片会自动扩容

1
2

slice := []int{1, 2, 3, 4, 5}
subSlice := slice[1:4] // 获取一个子切片，指向原数组的一部分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func append(slice []int, value int) []int {
    if len(slice) == cap(slice) {
        // 如果切片满了，则扩容
        newSlice := make([]int, len(slice), 2*cap(slice)) // 容量翻倍
        copy(newSlice, slice)
        slice = newSlice
    }
    slice = append(slice, value)
    return slice
}

 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

// 1.18 及之后版本
// nextslicecap 计算下一个合适的切片容量。
// 参数 newLen 是目标切片的长度，oldCap 是当前切片的容量。
// 返回值是根据新的长度和当前容量计算出的最适合的容量。
func nextslicecap(newLen, oldCap int) int {
	newcap := oldCap                   // 初始化新的容量为当前容量
	doublecap := newcap + newcap       // 计算当前容量的两倍
	if newLen > doublecap {            // 如果目标长度大于两倍当前容量，则返回目标长度
		return newLen
	}

	const threshold = 256              // 定义一个阈值，当容量小于阈值时，采用2倍增长
	if oldCap < threshold {            // 如果当前容量小于阈值，则返回当前容量的2倍
		return doublecap
	}

	for {
		// 对于较小的切片，容量增长为2倍；对于较大的切片，容量增长为1.25倍。
		// 这个公式实现了在两者之间的平滑过渡。
		newcap += (newcap + 3*threshold) >> 2 // 增长1.25倍

		// 需要检查 newcap 是否大于等于 newLen，并且检查 newcap 是否溢出。
		// 因为 newLen 保证大于零，因此当 newcap 溢出时，uint(newcap) 会大于 uint(newLen)。
		// 这样我们可以通过相同的比较来检查这两个条件。
		if uint(newcap) >= uint(newLen) {
			break // 如果新容量大于等于目标长度，跳出循环
		}
	}

	// 如果 newcap 计算溢出，设置 newcap 为目标长度。
	// 因为容量溢出时，newcap 可能变为负数或 0，因此返回目标长度。
	if newcap <= 0 {
		return newLen
	}

	return newcap // 返回计算出的合适容量
}

1

slice := make([]int, 0, 1000) // 预分配1000个容量，减少扩容

1
2
3
4
5
6
7

func init() {
  db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/dbname")
  if err != nil {
      log.Fatal(err)
  }
  fmt.Println("数据库连接成功")
}

1
2
3

func init() {
  log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main

import "fmt"

type MyStruct struct {
	field int
}

func (ms MyStruct) ValueReceiverMethod() {
	fmt.Println("ValueReceiverMethod")
}

func (ms *MyStruct) PointReceiverMethod() {
	fmt.Println("PointReceiverMethod")
}

func main() {
	var s MyStruct
	s.ValueReceiverMethod() // 输出 ValueReceiverMethod
	s.PointReceiverMethod() // 输出 PointReceiverMethod
	tmpS := &s
	tmpS.ValueReceiverMethod() // 输出 ValueReceiverMethod
	tmpS.PointReceiverMethod() // 输出 PointReceiverMethod
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package main

import "fmt"

func createPointer() *int {
    var localVar int = 42
    return &localVar
}

func main() {
    ptr := createPointer()
    fmt.Println(*ptr)  // 输出 42
}

 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

func growslice(et *_type, old slice, cap int) slice {
    // ...
    newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {
        newcap = cap
    } else {
        if old.cap < 1024 {
            newcap = doublecap
        } else {
            // Check 0 < newcap to detect overflow
            // and prevent an infinite loop.
            for 0 < newcap && newcap < cap {
                newcap += newcap / 4
            }
            // Set newcap to the requested cap when
            // the newcap calculation overflowed.
            if newcap <= 0 {
                newcap = cap
            }
        }
    }
    // ...
    return slice{p, old.len, newcap}
}

 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

func growslice(et *_type, old slice, cap int) slice {
    // ...
    newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {
        newcap = cap
    } else {
        const threshold = 256
        if old.cap < threshold {
            newcap = doublecap
        } else {
            // Check 0 < newcap to detect overflow
            // and prevent an infinite loop.
            for 0 < newcap && newcap < cap {
                // Transition from growing 2x for small slices
                // to growing 1.25x for large slices. This formula
                // gives a smooth-ish transition between the two.
                newcap += (newcap + 3*threshold) / 4
            }
            // Set newcap to the requested cap when
            // the newcap calculation overflowed.
            if newcap <= 0 {
                newcap = cap
            }
        }
    }
    // ...
    return slice{p, old.len, newcap}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func main() {
  var s []int

  // 初始值为5
  s = append(s, 1, 2, 3, 4, 5)
  fmt.Printf("Length: %d, Capacity: %d\n", len(s), cap(s)) // Length: 5, Capacity: 8

  // 添加更多元素，会使容量增长
  s = append(s, 6, 7, 8, 9, 10)
  fmt.Printf("Length: %d, Capacity: %d\n", len(s), cap(s)) // Length: 10, Capacity: 16
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

func main() {
	s := []int{0, 0}
	f(s)
	fmt.Println(s) // [10,10,10]
}
func f(s []int) {
	// 这样不能改变s中元素的值
	//for _, v := range s {
	//	v=10
	//}
	
        // 这样可以
	for i := range s {
		s[i] = 10
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

func f(s []int) []int {
	// 这里 s 是改变了，但是不会影响外层函数的 s。因为s本身就是一个值拷贝。
	s = append(s, 100)
	return s
}
func fPtr(s *[]int) {
	// 会改变外层 s 本身
	*s = append(*s, 10)
	return
}
func main() {
	s := []int{0,0}
	newS := f(s)

	fmt.Println(s) //[0,0]
	fmt.Println(newS)//[0,0]

	s = newS

	fPtr(&s)
	fmt.Println(s) //[0,0,10]
}

1
2
3
4
5
6
7
8

func modify(slice []int) {
	slice[0] = 100
}
func main() {
	s := []int{1, 2, 3}
	modify(s)
	fmt.Println(s) // 输出 [100, 2, 3]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func appendAndPrint(slice []int) {
	fmt.Printf("slice start: %p\n", slice)
	slice = append(slice, 4)
	fmt.Printf("slice end: %p\n", slice)
}
func main() {
	s := make([]int, 3, 3)
	appendAndPrint(s)
	fmt.Printf("main slice: %p\n", s) // 地址不同了
}

1
2
3
4
5
6
7
8
9

func addElement(slice []int, element int) []int {
	slice = append(slice, element)
	return slice
}
func main() {
	s := []int{1, 2, 3}
	s = addElement(s, 4)
	fmt.Println(s) // 输出 [1, 2, 3, 4]
}

1
2
3
4
5

var y int = 20 // 函数内声明+赋值变量
fmt.Println("y:", y) // 输出：y: 20

y = 50 // 重新赋值
fmt.Println("y:", y) // 输出：y: 50

1
2
3
4

y := 20 // 声明+赋值新变量
fmt.Println("y:", y) // 输出：20

// y := 30 // 不允许对已有变量赋值