Go最常用函数

墨蓝 2024-03-30 09:18 75阅读 0赞

**hello.go**

package main

import "fmt"

func main() \{

fmt.Println("Hello, world!")

直接运行

$ go run hello.go

Hello, world!

或者在 Go repl 中尝试一下

**变量**

var s1 string

s1 = "Learn Go!"

// 一次声明多个变量

var b, c int = 1, 2

var d = true

简短声明

s1 := "Learn Go!" // string

b, c := 1, 2 // int

d := true // bool

参见：基本类型

**函数**

package main

import "fmt"

// 程序的入口点

func main() \{

fmt.Println("Hello world!")

say("Hello Go!")

func say(message string) \{

fmt.Println("You said: ", message)

参见：函数(Functions)

**注释**

// 单行注释

/\* 这是

多行注释 \*/

**如果语句**

if true \{

fmt.Println("Yes!")

参见：条件控制

**Golang** **基本类型**

**字符串 Strings**

s1 := "Hello" \+ "World"

s2 := \`A "raw" string literal

can include line breaks.\`

// 输出：10

fmt.Println(len(s1))

// 输出：Hello

fmt.Println(string(s1\[0:5\]))

字符串的类型为 字符串

**数字 Numbers**

num := 3 // int

num := 3. // float64

num := 3 \+ 4i // complex128

num := byte('a') // byte (alias: uint8)

var u uint = 7 // uint (unsigned)

var p float32 = 22.7 // 32-bit float

**操作符 Operators**

x := 5

x++

fmt.Println("x \+ 4 =", x \+ 4)

fmt.Println("x \* 4 =", x \* 4)

参见：更多操作符

**布尔值 Booleans**

isTrue := true

isFalse := false

**操作符**

fmt.Println(true && true) // true

fmt.Println(true && false) // false

fmt.Println(true || true) // true

fmt.Println(true || false) // true

fmt.Println(!true) // false

参见：更多操作符

**数组 Arrays**

┌────┬────┬────┬────┬─────┬─────┐

| 2 | 3 | 5 | 7 | 11 | 13 |

└────┴────┴────┴────┴─────┴─────┘

0 1 2 3 4 5

--------------------

primes := \[...\]int\{2, 3, 5, 7, 11, 13\}

fmt.Println(len(primes)) // => 6

// 输出：\[2 3 5 7 11 13\]

fmt.Println(primes)

// 与 \[:3\] 相同，输出：\[2 3 5\]

fmt.Println(primes\[0:3\])

--------------------

var a \[2\]string

a\[0\] = "Hello"

a\[1\] = "World"

fmt.Println(a\[0\], a\[1\]) //=> Hello World

fmt.Println(a) // => \[Hello World\]

**2d array**

var twoDimension \[2\]\[3\]int

for i := 0; i < 2; i++ \{

for j := 0; j < 3; j++ \{

twoDimension\[i\]\[j\] = i \+ j

// => 2d: \[\[0 1 2\] \[1 2 3\]\]

fmt.Println("2d: ", twoDimension)

**指针(Pointers)**

func main () \{

b := \*getPointer()

fmt.Println("Value is", b)

func getPointer () (myPointer \*int) \{

a := 234

return &a

a := new(int)

\*a = 234

参见：指针(Pointers)

**切片(Slices)**

s := make(\[\]string, 3)

s\[0\] = "a"

s\[1\] = "b"

s = append(s, "d")

s = append(s, "e", "f")

fmt.Println(s)

fmt.Println(s\[1\])

fmt.Println(len(s))

fmt.Println(s\[1:3\])

slice := \[\]int\{ 2, 3, 4\}

另见：切片示例

**常量(Constants)**

const s string = "constant"

const Phi = 1.618

const n = 500000000

const d = 3e20 / n

fmt.Println(d)

**类型转换**

i := 90

f := float64(i)

u := uint(i)

// 将等于字符Z

s := string(i)

**如何获取int字符串？**

i := 90

// 需要导入“strconv”

s := strconv.Itoa(i)

fmt.Println(s) // Outputs: 90

**Golang** **字符串**

**字符串函数**

package main

import (

"fmt"

s "strings"

)

func main() \{

/\* 需要将字符串导入为 s \*/

fmt.Println(s.Contains("test", "e"))

/\* 内置 \*/

fmt.Println(len("hello")) // => 5

// 输出: 101

fmt.Println("hello"\[1\])

// 输出: e

fmt.Println(string("hello"\[1\]))

**fmt.Printf**

package main

import (

"fmt"

"os"

)

type point struct \{

x, y int

func main() \{

p := point\{ 1, 2\}

fmt.Printf("%v\\n", p) // => \{1 2\}

fmt.Printf("%+v\\n", p) // => \{x:1 y:2\}

fmt.Printf("%\#v\\n", p) // => main.point\{x:1, y:2\}

fmt.Printf("%T\\n", p) // => main.point

fmt.Printf("%t\\n", true) // => TRUE

fmt.Printf("%d\\n", 123) // => 123

fmt.Printf("%b\\n", 14) // => 1110

fmt.Printf("%c\\n", 33) // => !

fmt.Printf("%x\\n", 456) // => 1c8

fmt.Printf("%f\\n", 78.9) // => 78.9

fmt.Printf("%e\\n", 123400000.0) // => 1.23E+08

fmt.Printf("%E\\n", 123400000.0) // => 1.23E+08

fmt.Printf("%s\\n", "\\"string\\"") // => "string"

fmt.Printf("%q\\n", "\\"string\\"") // => "\\"string\\""

fmt.Printf("%x\\n", "hex this") // => 6.86578E+15

fmt.Printf("%p\\n", &p) // => 0xc00002c040

fmt.Printf("|%6d|%6d|\\n", 12, 345) // => | 12| 345|

fmt.Printf("|%6.2f|%6.2f|\\n", 1.2, 3.45) // => | 1.20| 3.45|

fmt.Printf("|%-6.2f|%-6.2f|\\n", 1.2, 3.45) // => |1.20 |3.45 |

fmt.Printf("|%6s|%6s|\\n", "foo", "b") // => | foo| b|

fmt.Printf("|%-6s|%-6s|\\n", "foo", "b") // => |foo |b |

s := fmt.Sprintf("a %s", "string")

fmt.Println(s)

fmt.Fprintf(os.Stderr, "an %s\\n", "error")

另见：fmt

**函数实例**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> Contains("test", "es") </td> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> Count("test", "t") </td> 
 <td style="vertical-align:top;"> 2 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> HasPrefix("test", "te") </td> 
 <td style="vertical-align:top;"> true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> HasSuffix("test", "st") </td> 
 <td style="vertical-align:top;"> true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> Index("test", "e") </td> 
 <td style="vertical-align:top;"> 1 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> Join([]string{"a", "b"}, "-") </td> 
 <td style="vertical-align:top;"> a-b </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> Repeat("a", 5) </td> 
 <td style="vertical-align:top;"> aaaaa </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> Replace("foo", "o", "0", -1) </td> 
 <td style="vertical-align:top;"> f00 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> Replace("foo", "o", "0", 1) </td> 
 <td style="vertical-align:top;"> f0o </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> Split("a-b-c-d-e", "-") </td> 
 <td style="vertical-align:top;"> [a b c d e] </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> ToLower("TEST") </td> 
 <td style="vertical-align:top;"> test </td> 
 </tr> 
 <tr> 
 <td style="border-color:#e8e8e8;vertical-align:top;"> ToUpper("test") </td> 
 <td style="vertical-align:top;"> TEST </td> 
 </tr> 
 </tbody> 
</table>

**Golang** **条件控制**

**有条件的**

a := 10

if a > 20 \{

fmt.Println(">")

\} else if a < 20 \{

fmt.Println("<")

\} else \{

fmt.Println("=")

**if** **中的语句**

x := "hello go!"

if count := len(x); count > 0 \{

fmt.Println("Yes")

--------------------

if \_, err := doThing(); err != nil \{

fmt.Println("Uh oh")

**Switch**

x := 42.0

switch x \{

case 0:

case 1, 2:

fmt.Println("Multiple matches")

case 42: // Don't "fall through".

fmt.Println("reached")

case 43:

fmt.Println("Unreached")

default:

fmt.Println("Optional")

参见：Switch

**For loop**

for i := 0; i <= 10; i++ \{

fmt.Println("i: ", i)

**对于 Range 循环**

nums := \[\]int\{ 2, 3, 4\}

sum := 0

for \_, num := range nums \{

sum += num

fmt.Println("sum:", sum)

**While** **循环**

i := 1

for i <= 3 \{

fmt.Println(i)

i++

**Continue** **关键字**

for i := 0; i <= 5; i++ \{

if i % 2 == 0 \{

continue

fmt.Println(i)

**Break** **关键字**

for \{

fmt.Println("loop")

break

**Golang** **结构和映射**

**定义**

package main

import (

"fmt"

)

type Vertex struct \{

X int

Y int

func main() \{

v := Vertex\{ 1, 2\}

v.X = 4

fmt.Println(v.X, v.Y) // => 4 2

参见：结构(Structs)

**字面量**

v := Vertex\{X: 1, Y: 2\}

// Field names can be omitted

v := Vertex\{ 1, 2\}

// Y is implicit

v := Vertex\{X: 1\}

您还可以输入字段名

**映射**

m := make(map\[string\]int)

m\["k1"\] = 7

m\["k2"\] = 13

fmt.Println(m) // => map\[k1:7 k2:13\]

v1 := m\["k1"\]

fmt.Println(v1) // => 7

fmt.Println(len(m)) // => 2

delete(m, "k2")

fmt.Println(m) // => map\[k1:7\]

\_, prs := m\["k2"\]

fmt.Println(prs) // => false

n := map\[string\]int\{ "foo": 1, "bar": 2\}

fmt.Println(n) // => map\[bar:2 foo:1\]

**指向结构的指针**

v := &Vertex\{1, 2\}

v.X = 2

Doing v.X is the same as doing (\*v).X, when v is a pointer.

**Golang** **函数**

**多个参数**

func plus(a int, b int) int \{

return a + b

func plusPlus(a, b, c int) int \{

return a + b + c

fmt.Println(plus(1, 2))

fmt.Println(plusPlus(1, 2, 3))

**多次返回**

func vals() (int, int) \{

return 3, 7

a, b := vals()

fmt.Println(a) // => 3

fmt.Println(b) // => 7

**匿名函数**

r1, r2 := func() (string, string) \{

x := \[\]string\{ "hello", "world"\}

return x\[0\], x\[1\]

\}()

// => hello world

fmt.Println(r1, r2)

**命名返回**

func split(sum int) (x, y int) \{

x = sum \* 4 / 9

y = sum - x

return

x, y := split(17)

fmt.Println(x) // => 7

fmt.Println(y) // => 10

**变量函数**

func sum(nums ...int) \{

fmt.Print(nums, " ")

total := 0

for \_, num := range nums \{

total \+= num

fmt.Println(total)

sum(1, 2) //=> \[1 2\] 3

sum(1, 2, 3) // => \[1 2 3\] 6

nums := \[\]int\{1, 2, 3, 4\}

sum(nums...) // => \[1 2 3 4\] 10

**初始化函数**

import \--> const \--> var \--> init()

--------------------

var num = setNumber()

func setNumber() int \{

return 42

func init() \{

num = 0

func main() \{

fmt.Println(num) // => 0

**作为值的函数**

func main() \{

// 将函数赋给名称

add := func(a, b int) int \{

return a + b

// 使用名称调用函数

fmt.Println(add(3, 4)) // => 7

**关闭 1**

func scope() func() int\{

outer\_var := 2

foo := func() int \{ return outer\_var\}

return foo

// Outpus: 2

fmt.Println(scope()())

**关闭 2**

func outer() (func() int, int) \{

outer\_var := 2

inner := func() int \{

outer\_var += 99

return outer\_var

inner()

return inner, outer\_var

inner, val := outer()

fmt.Println(inner()) // => 200

fmt.Println(val) // => 101

**Golang** **包(Packages)**

**导入**

import "fmt"

import "math/rand"

**等同于**

import (

"fmt" // 给 fmt.Println

"math/rand" // 给 rand.Intn

)

另见：导入

**别名**

import r "math/rand"

--------------------

import (

"fmt"

r "math/rand"

)

--------------------

r.Intn()

**Packages**

package main

// 一个内部包只能被另一个包导入

// 那是在以内部目录的父级为根的树内

package internal

另见：内部包

**导出名称**

// 以大写字母开头

func Hello () \{

···

另见：导出的名称

**Golang** **并发**

**协程**

package main

import (

"fmt"

"time"

)

func f(from string) \{

for i := 0; i < 3; i++ \{

fmt.Println(from, ":", i)

func main() \{

f("direct")

go f("goroutine")

go func(msg string) \{

fmt.Println(msg)

\}("going")

time.Sleep(time.Second)

fmt.Println("done")

参见：Goroutines, Channels

**WaitGroup**

package main

import (

"fmt"

"sync"

"time"

)

func w(id int, wg \*sync.WaitGroup) \{

defer wg.Done()

fmt.Printf("%d starting\\n", id)

time.Sleep(time.Second)

fmt.Printf("%d done\\n", id)

func main() \{

var wg sync.WaitGroup

for i := 1; i <= 5; i++ \{

wg.Add(1)

go w(i, &wg)

wg.Wait()

参见：WaitGroup

**Closing channels**

ch <- 1

ch <- 2

ch <- 3

close(ch) // 关闭频道

--------------------

// 迭代通道直到关闭

for i := range ch \{

···

--------------------

// Closed if \`ok == false\`

v, ok := <- ch

参见：范围和关闭

**缓冲通道**

ch := make(chan int, 2)

ch <- 1

ch <- 2

ch <- 3

// 致命错误：

// 所有 goroutine 都处于休眠状态 \- 死锁

参见：缓冲通道

**Golang** **错误控制**

**延迟函数**

func main() \{

defer func() \{

fmt.Println("Done")

\}()

fmt.Println("Working...")

**Lambda defer**

func main() \{

var d = int64(0)

defer func(d \*int64) \{

fmt.Printf("& %v Unix Sec\\n", \*d)

\}(&d)

fmt.Print("Done ")

d = time.Now().Unix()

defer 函数使用当前值d，除非我们使用指针在 main 末尾获取最终值

**Defer**

func main() \{

defer fmt.Println("Done")

fmt.Println("Working...")

参见：Defer, panic and recover

**Golang** **方法(Methods)**

**接收器**

type Vertex struct \{

X, Y float64

func (v Vertex) Abs() float64 \{

return math.Sqrt(v.X \* v.X + v.Y \* v.Y)

v := Vertex\{ 1, 2\}

v.Abs()

参见：Methods

**Mutation**

func (v \*Vertex) Scale(f float64) \{

v.X = v.X \* f

v.Y = v.Y \* f

v := Vertex\{ 6, 12\}

v.Scale(0.5)

// \`v\` 已更新

参见：指针接收器

**Golang** **接口(Interfaces)**

**基本接口(Interfaces)**

type Shape interface \{

Area() float64

Perimeter() float64

**结构(Struct)**

type Rectangle struct \{

Length, Width float64

结构 Rectangle 通过实现其所有方法隐式实现接口 Shape

**方法(Methods)**

func (r Rectangle) Area() float64 \{

return r.Length \* r.Width

func (r Rectangle) Perimeter() float64 \{

return 2 \* (r.Length + r.Width)

在 Shape 中定义的方法在Rectangle中实现

**接口实例**

func main() \{

var r Shape = Rectangle\{Length: 3, Width: 4\}

fmt.Printf("Type of r: %T, Area: %v, Perimeter: %v.", r, r.Area(), r.Perimeter())

**杂项**

**关键字(Keywords)**

*  break
 *  default
 *  func
 *  interface
 *  select
 *  case
 *  defer
 *  go
 *  map
 *  struct
 *  chan
 *  else
 *  goto
 *  package
 *  switch
 *  const
 *  fallthrough
 *  if
 *  range
 *  type
 *  continue
 *  for
 *  import
 *  return
 *  var

**运算符和标点符号**