[b]Basic types[/b]
基本类型
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32
// represents a Unicode code point
float32 float64
complex64 complex128
输出:
bool(false)
uint64(18446744073709551615)
complex128((2+3i))
%T 是类型Type(%v)是值Value
[b]Structs[/b]
结构体
A struct is a collection of fields.
结构体是很多字段的集合
输出:
{1 2}
[b]Struct Fields[/b]
结构体字段
Struct fields are accessed using a dot.
结构体字段用点.访问
输出:
4
[b]Pointers[/b]
Go has pointers, but no pointer arithmetic.
Go有指针,但是没有指针运算
Struct fields can be accessed through a struct pointer. The indirection through the pointer is transparent.
结构体字段能够通过结构体指针访问,很容易通过指针间接访问
输出:
{1000000000 2}
Struct Literals
结构体值
A struct literal denotes a newly allocated struct value by listing the values of its fields.
结构体值表示一个新分配结构体值通过列出它所有的字段值
You can list just a subset of fields by using the Name: syntax. (And the order of named fields is irrelevant.)
你也可以只通过名字语法勒出一部分字段值,顺序无所谓
The special prefix & constructs a pointer to a struct literal.
指定前缀&构造一个结构体字面值的指针
输出:
{1 2} &{1 2} {1 0} {0 0}
[b]The new function[/b]
new函数
The expression new(T) allocates a zeroed T value and returns a pointer to it.
表达式 new(T)返回一个分配了0默认值的T类型的指针
var t *T = new(T)
or
t := new(T)
输出:
&{0 0}
&{11 9}
[b]Maps[/b]
A map maps keys to values.
map匹配键和值
Maps must be created with make (not new) before use; the nil map is empty and cannot be assigned to.
Maps用之前必须用make创建,没有make的map是空的不能赋值
输出:
{40.68433 74.39967}
Map literals are like struct literals, but the keys are required.
Map的字面值和结构体字面值一样,但是必须有键值
输出:
map[Google:{37.42202 -122.08408} Bell Labs:{40.68433 -74.39967}]
If the top-level type is just a type name, you can omit it from the elements of the literal.
如果顶级类型只是类型名的话,可以省略
输出:
map[Google:{37.42202 -122.08408} Bell Labs:{40.68433 -74.39967}]
[b]Mutating Maps[/b]
Maps变型
Insert or update an element in map m:
插入或修改map m的一个元素
m[key] = elem
Retrieve an element:
提取一个元素
elem = m[key]
Delete an element:
删除一个元素
delete(m, key)
Test that a key is present with a two-value assignment:
测试键里是否有值
elem, ok = m[key]
If key is in m, ok is true. If not, ok is false and elem is the zero value for the map's element type.
如果键有对应值,ok 是true,如果没有,ok是false,并且对应map's元素类型elem是0值
Similarly, when reading from a map if the key is not present the result is the zero value for the map's element type.
相似的是当从map取值的时候如果键值不存在,返回结果也是map's元素类型默认值
输出:
The value: 42
The value: 48
The value: 0
The value: 0 Present? false
基本类型
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32
// represents a Unicode code point
float32 float64
complex64 complex128
package main
import (
"math/cmplx"
"fmt"
)
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
z complex128 = cmplx.Sqrt(-5+12i)
)
func main() {
const f = "%T(%v)\n"
fmt.Printf(f, ToBe, ToBe)
fmt.Printf(f, MaxInt, MaxInt)
fmt.Printf(f, z, z)
}
输出:
bool(false)
uint64(18446744073709551615)
complex128((2+3i))
%T 是类型Type(%v)是值Value
[b]Structs[/b]
结构体
A struct is a collection of fields.
结构体是很多字段的集合
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
fmt.Println(Vertex{1, 2})
}
输出:
{1 2}
[b]Struct Fields[/b]
结构体字段
Struct fields are accessed using a dot.
结构体字段用点.访问
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
v := Vertex{1, 2}
v.X = 4
fmt.Println(v.X)
}
输出:
4
[b]Pointers[/b]
Go has pointers, but no pointer arithmetic.
Go有指针,但是没有指针运算
Struct fields can be accessed through a struct pointer. The indirection through the pointer is transparent.
结构体字段能够通过结构体指针访问,很容易通过指针间接访问
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
p := Vertex{1, 2}
q := &p
q.X = 1e9
fmt.Println(p)
}
输出:
{1000000000 2}
Struct Literals
结构体值
A struct literal denotes a newly allocated struct value by listing the values of its fields.
结构体值表示一个新分配结构体值通过列出它所有的字段值
You can list just a subset of fields by using the Name: syntax. (And the order of named fields is irrelevant.)
你也可以只通过名字语法勒出一部分字段值,顺序无所谓
The special prefix & constructs a pointer to a struct literal.
指定前缀&构造一个结构体字面值的指针
package main
import "fmt"
type Vertex struct {
X, Y int
}
var (
p = Vertex{1, 2} // has type Vertex
q = &Vertex{1, 2} // has type *Vertex
r = Vertex{X: 1} // Y:0 is implicit
s = Vertex{} // X:0 and Y:0
)
func main() {
fmt.Println(p, q, r, s)
}
输出:
{1 2} &{1 2} {1 0} {0 0}
[b]The new function[/b]
new函数
The expression new(T) allocates a zeroed T value and returns a pointer to it.
表达式 new(T)返回一个分配了0默认值的T类型的指针
var t *T = new(T)
or
t := new(T)
package main
import "fmt"
type Vertex struct {
X, Y int
}
func main() {
v := new(Vertex)
fmt.Println(v)
v.X, v.Y = 11, 9
fmt.Println(v)
}
输出:
&{0 0}
&{11 9}
[b]Maps[/b]
A map maps keys to values.
map匹配键和值
Maps must be created with make (not new) before use; the nil map is empty and cannot be assigned to.
Maps用之前必须用make创建,没有make的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"])
}
输出:
{40.68433 74.39967}
Map literals are like struct literals, but the keys are required.
Map的字面值和结构体字面值一样,但是必须有键值
package main
import "fmt"
type Vertex struct {
Lat, Long float64
}
var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}
func main() {
fmt.Println(m)
}
输出:
map[Google:{37.42202 -122.08408} Bell Labs:{40.68433 -74.39967}]
If the top-level type is just a type name, you can omit it from the elements of the literal.
如果顶级类型只是类型名的话,可以省略
package main
import "fmt"
type Vertex struct {
Lat, Long float64
}
var m = map[string]Vertex{
"Bell Labs": {40.68433, -74.39967},
"Google": {37.42202, -122.08408},
}
func main() {
fmt.Println(m)
}
输出:
map[Google:{37.42202 -122.08408} Bell Labs:{40.68433 -74.39967}]
[b]Mutating Maps[/b]
Maps变型
Insert or update an element in map m:
插入或修改map m的一个元素
m[key] = elem
Retrieve an element:
提取一个元素
elem = m[key]
Delete an element:
删除一个元素
delete(m, key)
Test that a key is present with a two-value assignment:
测试键里是否有值
elem, ok = m[key]
If key is in m, ok is true. If not, ok is false and elem is the zero value for the map's element type.
如果键有对应值,ok 是true,如果没有,ok是false,并且对应map's元素类型elem是0值
Similarly, when reading from a map if the key is not present the result is the zero value for the map's element type.
相似的是当从map取值的时候如果键值不存在,返回结果也是map's元素类型默认值
package main
import "fmt"
func main() {
m := make(map[string]int)
m["Answer"] = 42
fmt.Println("The value:", m["Answer"])
m["Answer"] = 48
fmt.Println("The value:", m["Answer"])
delete(m, "Answer")
fmt.Println("The value:", m["Answer"])
v, ok := m["Answer"]
fmt.Println("The value:", v, "Present?", ok)
}
输出:
The value: 42
The value: 48
The value: 0
The value: 0 Present? false