Skip to main content
Version: go

声明变量

var a, b *int

var a int
var b bool
var str string

var (
    a int
    b bool
    str string
)

赋值变量

a = 15

var identifier [type] = value
var a int = 15

var a = 15

a := 50

数据类型

别名

type TZ int

布尔类型 bool​

var b bool = true

整型 int​

整数：

  • int8（-128 -> 127）

  • int16（-32768 -> 32767）

  • int32（-2,147,483,648 -> 2,147,483,647）

  • int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

无符号整数：

  • uint8（0 -> 255）
  • uint16（0 -> 65,535）
  • uint32（0 -> 4,294,967,295）
  • uint64（0 -> 18,446,744,073,709,551,615）
package main

func main() {   
    var a int
    var b int32
    a = 15
    b = a + a    // 编译错误
    b = b + 5    // 因为 5 是常量，所以可以通过编译
}

浮点型 float​

浮点型（IEEE-754 标准）：

  • float32（+- 1e-45 -> +- 3.4 * 1e38）
  • float64（+- 5 1e-324 -> 107 1e308）
var f float32 = 16777216 // 1 << 24
fmt.Println(f == f+1)    // "true"!

const e = .71828 // 0.71828
const f = 1.     // 1

const Avogadro = 6.02214129e23  // 阿伏伽德罗常数
const Planck   = 6.62606957e-34 // 普朗克常数

复数​

复数使用 re+imI 来表示，其中 re 代表实数部分，im 代表虚数部分，I 代表根号负 1

complex64 (32 位实数和虚数)
complex128 (64 位实数和虚数)

var c1 complex64 = 5 + 10i
fmt.Printf("The value is: %v", c1)
// 输出： 5 + 10i

c = complex(re, im)

字符类型​

var ch byte = 65 
或 
var ch byte = '\x41'

字符串​

str := "Beginning of the string " +
    "second part of the string"

指针​

var i1 = 5
fmt.Printf("An integer: %d, it's location in memory: %p\n", i1, &i1)

复合数据类型

数组​

定义

var [3]int

q := [3]int{1,2,3}

操作

// 第一个元素
a[0]

// 最后一个元素
a[len(a)-1]

遍历

for i, v := range a {
    fmt.Printf("%d %d\n", i, v)
}

Slice​

切片: 对数组一个连续片段的引用

注意 绝对不要用指针指向 slice。切片本身已经是一个引用类型，所以它本身就是一个指针！！

声明

// 声明
var a []int

// 初始化
// arr[start] == arr[0]
var a []int = arr[start:end]

// arr[:] == arr[0:len(arr)]
var a []int = arr[:]

// 初始化元素
s := [3]int{1,2,3}[:]
// 或者
s := []int(1,2,3)

// make 创建切片 
// 格式: slice1 := make([]type, len, cap)
make([]int, 50, 100)
// 或者
make([100]int)[0:50]

操作

// 开始到最后
arr1[2:] == arr[2:len(arr)]

// 去除最后一个
slice1 = slice1[:len(slice1)-1]

// 复制
n := copy(s1_to, sl_from)

// 追加
n2 := append(n, 4, 5, 6)

Map​

引用类型

声明

// 格式
var map1 map[keytype]valuetype

// 声明
var map1 map[string]int
// 或者
map1 := map[string]int{}
// 或者 永远用 make 来构造 map
// 格式 make(map[keytype]valuetype, cap)
map2 := make(map[string]int)

// 赋值
map1 = map[string]int{"one":1, "two":2}

// 切片作为 map 值
mp1 := make(map[int][]int)
mp2 := make(map[int]*[]int)

操作

// 查找
map1[key1]

// 如果key1存在则ok == true，否则ok为false
_, ok := map1[key1] 
// 或者
if _, ok := map1[key1]; ok {
    // ...
}

// 查找赋值给变量
v := map1[key1]

// 赋值
map1[key1] = val1

其他

new()和make()的区别

  • new (T) 为每个新的类型 T 分配一片内存，初始化为 0 并且返回类型为 * T 的内存地址：这种方法 返回一个指向类型为 T，值为 0 的地址的指针，它适用于值类型如数组和结构体；它相当于 &T{}。
  • make(T) 返回一个类型为 T 的初始值，它只适用于 3 种内建的引用类型：切片、map 和 channel