go语言笔记0

 

函数只能判断是否为nil，不支持比较。

 

不管是指针，引用类型还是其他类型参数，都是值拷贝传递。在函数调用前，会为形参和返回值分配内存空间，并将实参拷贝到形参内存。

package main

import (
    "fmt"
)

func test(x *int){
    fmt.Printf("Pointer: %p, target: %v\n", &x, x)
}

func main() {
    a := 0x100
    p := &a
    fmt.Printf("Pointer: %p, target: %v\n", &p, p)
    test(p)
}

 

 

 尽管实参和形参指向同一目标，但传递指针时依然被复制。

 

二级指针可实现返回值，代码如下

package main

func test(p **int) {
    x := 100
    *p = &x
}

func main(){
    var p *int
    test(&p)
    println(*p)
}

 

 如果参数过多，建议将其重构成一个复合结构类型

package main

import (
    "time"
    "log"
)
type serverOption struct {
    address string
    port int
    path string
    timeout time.Duration
    log *log.Logger
}

func newOption() *serverOption {
    return &serverOption {//默认参数
        address: "0.0.0.0",
        port: 8080,
        path: "/var/test",
        timeout: time.Second * 5,
        log: nil,
    }
}

func server(option *serverOption){}

func main() {
    opt := newOption()
    opt.port = 8085
    server(opt)
}

变参相关

package main

import (
    "fmt"
)

func test(s string, a ...int) {
    fmt.Printf("%T, %v\n", a, a)
}

func main(){
    test("abc", 1,2,3,4)
}

 

 变参本质是一个切片，如果是数组时，要先转换为且切片

package main

import (
	"fmt"
)

func test(a ...int) {
	fmt.Println(a)
}

func main() {
	a := [3]int{10,20,30}
	test(a[:]...)
}

　　

 

 匿名函数

func(data int) {
    fmt.Println("hello", data)
}(100)

注意第3行}后的(100)，表示对匿名函数进行调用，传递参数为 100。

package main

import (
	"fmt"
)

func test(a ...int) {
	for i := range a {
		a[i] += 100
	}
}

func main(){
	a := []int{10,20,30}
	test(a...)

	fmt.Println(a)
}

　　

 

 Go 中的数组是值类型而不是引用类型。这意味着当数组赋值给一个新的变量时，该变量会得到一个原始数组的一个副本。如果对新变量进行更改，则不会影响原始数组。

 

package main

import "fmt"

func main() {
    a := [...]string{"USA", "China", "India", "Germany", "France"}
    b := a // a copy of a is assigned to b
    b[0] = "Singapore"
    fmt.Println("a is ", a)
    fmt.Println("b is ", b) 
}
/*
a is [USA China India Germany France]  
b is [Singapore China India Germany France]
*/

同样，当数组作为参数传递给函数时，它们是按值传递，而原始数组保持不变。

当切片传递给函数时，即使它通过值传递，指针变量也将引用相同的底层数组。因此，当切片作为参数传递给函数时，函数内所做的更改也会在函数外可见。

package main

import (
    "fmt"
)

func subtactOne(numbers []int) {
    for i := range numbers {
        numbers[i] -= 2
    }
}

func main() {
    nos := []int{8, 7, 6}
    fmt.Println("slice before function call", nos)
    subtactOne(nos)                               // function modifies the slice
    fmt.Println("slice after function call", nos) // modifications are visible outside
}

/*
array before function call [8 7 6]  
array after function call [6 5 4]
*/