侧边栏壁纸
  • 累计撰写 781 篇文章
  • 累计创建 1 个标签
  • 累计收到 1 条评论
标签搜索

Go

Dettan
2022-02-27 / 0 评论 / 0 点赞 / 45 阅读 / 4,718 字
温馨提示:
本文最后更新于 2022-04-30,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。
/ More / Go


if
不用() ,{ } 必填
if x < 0 {
		return sqrt(-x) + "i"
}
// 同 for 一样, if 语句可以在条件表达式前执行一个简单的语句。 该语句声明的变量作用域仅在 if 之内。
if v := math.Pow(x, n); v < lim {
		return v
} else {
		fmt.Printf("%g >= %g\n", v, lim)
}

switch
没有穿透问题
package main

import (
"fmt"
"runtime"
)

func main() {
fmt.Print("Go runs on ")

switch os := runtime.GOOS; os {
	case &quot;darwin&quot;:
		fmt.Println(&quot;OS X.&quot;)
		fallthrough
	case &quot;linux&quot;:
		fmt.Println(&quot;Linux.&quot;)		
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf(&quot;%s.\n&quot;, os)
}

}




没有条件的switch

package main

import (
"fmt"
"time"
)

func main() {
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("Good morning!")
case t.Hour() < 17:
fmt.Println("Good afternoon.")
default:
fmt.Println("Good evening.")
}
}





defer
defer 语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值,但直到外层函数返回前该函数都不会被调用。
栈结构, 先进后出
package main

import "fmt"

func main() {
defer fmt.Println("world")

fmt.Println(&quot;hello&quot;)

}




指针
Go 拥有指针。指针保存了值的内存地址。
类型 *T 是指向 T 类型值的指针。其零值为 nil
var p *int
& 操作符会生成一个指向其操作数的指针。
i := 42
p = &i
 操作符表示指针指向的底层值。
fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i
这也就是通常所说的“间接引用”或“重定向”。
与 C 不同,Go 没有指针运算。

结构体
package main

import "fmt"

type Vertex struct

func main() {
v := Vertex{1, 2}

v1 = Vertex{1, 2}  // 创建一个 Vertex 类型的结构体
v2 = Vertex{X: 1}  // Y:0 被隐式地赋予
v3 = Vertex{}      // X:0 Y:0
p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体(指针)

v.X = 4
fmt.Println(v.X)

}




package main

import "fmt"

type Vertex struct

func main() {
v := Vertex{1, 2}
p := &v
//如果我们有一个指向结构体的指针 p,那么可以通过 (*p).X 来访问其字段 X。不过这么写太啰嗦了,所以语言也允许我们使用隐式间接引用,直接写 p.X 就可以。
p.X = 1e9
fmt.Println(v)
}





array
package main

import "fmt"

func main() {
var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0], a[1])
fmt.Println(a)

primes := [6]int{2, 3, 5, 7, 11, 13}
fmt.Println(primes)

}




slice
[]int 切片就像数组的引用
切片的零值是 nil。if s == nil
package main

import "fmt"

func main() {
primes := [6]int{2, 3, 5, 7, 11, 13}

var s []int = primes[1:4]
fmt.Println(s)

}



下面这样则会创建一个和上面相同的数组,然后构建一个引用了它的切片:
package main

import "fmt"

func main() {
q := []int{2, 3, 5, 7, 11, 13}
fmt.Println(q)

r := []bool{true, false, true, true, false, true}
fmt.Println(r)

s := []struct {
	i int
	b bool
}{
	{2, true},
	{3, false},
	{5, true},
	{7, true},
	{11, false},
	{13, true},
}
fmt.Println(s)

}




忽略上下界

对于数组
var a [10]int
来说,以下切片是等价的:
a[0:10]
a[:10]
a[0:]
a[:]
切片可以重新分配长度
package main

import "fmt"

func main() {
s := []int{2, 3, 5, 7, 11, 13}
printSlice(s)

// 截取切片使其长度为 0
s = s[:0]
printSlice(s)

// 拓展其长度
s = s[:4]
printSlice(s)

// 舍弃前两个值
s = s[2:]
printSlice(s)

}

func printSlice(s []int) {
fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}



s = append(s, 1) printSlice(s)
// 可以一次性添加多个元素
s = append(s, 2, 3, 4)

图像
package main

import "golang.org/x/tour/pic"

func Pic(dx, dy int) [][]uint8 {
var r [][]uint8
for x := 0; x < dx; x++ {
var temp []uint8
r = append(r, temp)
for y := 0; y < dy; y++ {
//r[x] = append(r[x], uint8((float64(x)math.Log(float64(y)))))
//r[x] = append(r[x], uint8(x%(y+1)))
//r[x] = append(r[x], uint8(x^y))
//r[x] = append(r[x], uint8(x
y))
r[x] = append(r[x], uint8((x+y)/2))
}
}
return r
}

func main() {
pic.Show(Pic)
}




for range

for i, v := range pow { fmt.Printf("2**%d = %d\n", i, v) }
for _, value := range pow { fmt.Printf("%d\n", value) }

map
package main

import "fmt"

type Vertex struct {
Lat, Long float64
}

var m map[string]Vertex

func main() {
m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{
40.68433, -74.39967,
}
fmt.Println(m["Bell Labs"])
}

var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}

var m = map[string]Vertex{
"Bell Labs": {40.68433, -74.39967},
"Google": {37.42202, -122.08408},
}



删除元素:
delete(m, key)
通过双赋值检测某个键是否存在:
elem, ok = m[key]
若 key 在 m 中,ok 为 true ;否则,ok 为 false


function
package main

import (
"fmt"
"math"
)

func compute(fn func(float64, float64) float64) float64 {
return fn(3, 4)
}

func main() {
hypot := func(x, y float64) float64 {
return math.Sqrt(xx + yy)
}
fmt.Println(hypot(5, 12))

fmt.Println(compute(hypot))
fmt.Println(compute(math.Pow))

}




函数的闭包
Go 函数可以是一个闭包。闭包是一个函数值,它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值,换句话说,该函数被这些变量“绑定”在一起。
例如,函数 adder 返回一个闭包。每个闭包都被绑定在其各自的 sum 变量上。
package main

import "fmt"

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),
)
}
}

0 0
1 -2
3 -6
6 -12
10 -20
15 -30
21 -42
28 -56
36 -72
45 -90
            <div style="color: inherit; fill: inherit;">
                <div style="display: flex;">

method
no class, only have struct
记住:方法只是个带接收者参数的函数。
package main

import (
"fmt"
"math"
)

type Vertex struct {
X, Y float64
}

func (v Vertex) Abs() float64 {
return math.Sqrt(v.Xv.X + v.Yv.Y)
}

func main() {
v := Vertex{3, 4}
fmt.Println(v.Abs())
}




package main

import (
"fmt"
"math"
)

type MyFloat float64

func (f MyFloat) Abs() float64 {
if f < 0 {
return float64(-f)
}
return float64(f)
}

func main() {
f := MyFloat(-math.Sqrt2)
fmt.Println(f.Abs())
}





0

评论区