Go 学习笔记（1）变量及函数

1. 变量

声明变量

声明变量的基本格式为：

var <name1>, <name2>, <name3> <type>

如：

// 声明单个变量
var a string
var x int
// 同时声明多个相同类型变量
var c, d string

var
var (
    a, b string
    c int
)

声明变量并初始化

若声明变量时同时初始化，则仍可用以上两种方式，但不用指定数据类型，Go 可以根据初始值自动推断类型。

// 以下两种方式等价
var a string = "a string"
var a = "a string"
// int
var x = 1
var x int = 1
// 或
var (
    a = "a string" // string
    x = 1          // int
)

此外可以同时初始化多个变量：

var (
    a, b, c = "string", 3, "string"
)

:=var:=
a := 1
b := "string"

注意：变量声明后必须使用，否则会报错。

定义常量

constvar
const (
    a = 1
    b = 2
    c = 3
)
const x = "str"

:=const ()
const (
    a = 1
    b
    c = "str"
)

b1

2. 基本数据类型

Go 是一种强类型的语言，因此每个变量或常量都对应一种特定的数据类型。Go 中的数据类型有四种：

  1. 基本类型：数字、布尔值、字符串
  2. 聚合类型：数组和结构
  3. 引用类型：指针、切片、映射、函数、通道
  4. 接口类型：接口

本节只包括基本类型。

整数类型

int, int8, int16, int32, int64intuint, uint8, uint16, uint32, uint64
intint32int64intintint64
var a = 10
var b int64 = 20
// fmt.Println(a + b) // error
fmt.Println(a + int(b))

int
runeint32
var rune1 rune = 'a'

浮点数类型

float32, float64
// 声明浮点类型
var a float64 = 100
var b = 1.0

float64

布尔类型

booltrue, false
var a bool = true
var b = false

字符串

string\
var a string = "aaa"
var b = "bbb"
var c = "ccc\n"

默认值

int, float0boolfalsestring""

类型转换

type()
a := 10
b := float32(a)
c := int(b)

stringstrconv
package main

import "strconv"

func main() {
    s := "10"
    i, _ := strconv.Atoi(s) // string to int
    s2 := strconv.Itoa(i) // int to string
}

3. 函数

main 函数

main
func main () {}

osos.Args
package main

import (
    "os"
    "strconv"
)

func main () {
    a := strconv.Atoi(os.Args[1])
    b := strconv.Atoi(os.Args[2])
    fmt.Println("a + b = " + strconv.Itoa(a + b))
}

使用下列命令运行：

go run main.go 1 2

自定义函数

函数的基本格式为：

func name(parameters) (results) {
    body-content
}

sumint
func sum(a, b int) int {
    return a + b
}

sumreturnint
func sum(a, b int) (result int) {
    result = a + b
    return
}

也可以为函数指定多个返回值：

// 方式1
func calc(a, b int) (sum, mul int) {
    sum = a + b
    mul = a * b
    return
}

// 方式2
func calc(a, b int) (int, int) {
    sum := a + b
    mul := a * b
    return sum, mul
}

上面两种方式的效果相同，但推荐使用第二种方式，这样更有助于代码的阅读，可以直观地看出返回的变量。

函数的调用

func main() {
    a, b := sum(1, 2)
    c, _ := sum(2, 3)
}

_

Go 是“按值传递”的语言，因此调用函数时，传递的参数为原参数的副本，在函数中对该参数的修改不会影响到原变量。

func swap(a, b int) {
    a, b = b, a
}

func main() {
    a, b := 1, 2
    swap(a, b)
    fmt.Println(a) // 1
    fmt.Println(b) // 2
}

*&swap
func swap(a, b *int) {
    *a, *b = *b, *a
}

func main() {
    a, b := 1, 2
    swap(&a, &b)
    fmt.Println(a) // 2
    fmt.Println(b) // 1
}

swapa, b*a, *b

参考