// int8 is the set of all signed 8-bit integers. // Range: -128 through 127. type int8 int8  // int16 is the set of all signed 16-bit integers. // Range: -32768 through 32767. type int16 int16  // int32 is the set of all signed 32-bit integers. // Range: -2147483648 through 2147483647. type int32 int32  // int64 is the set of all signed 64-bit integers. // Range: -9223372036854775808 through 9223372036854775807. type int64 int64  // uint8 is the set of all unsigned 8-bit integers. // Range: 0 through 255. type uint8 uint8  // uint16 is the set of all unsigned 16-bit integers. // Range: 0 through 65535. type uint16 uint16  // uint32 is the set of all unsigned 32-bit integers. // Range: 0 through 4294967295. type uint32 uint32  // uint64 is the set of all unsigned 64-bit integers. // Range: 0 through 18446744073709551615. type uint64 uint64  // byte is an alias for uint8 and is equivalent to uint8 in all ways. It is // used, by convention, to distinguish byte values from 8-bit unsigned // integer values. type byte = uint8  // rune is an alias for int32 and is equivalent to int32 in all ways. It is // used, by convention, to distinguish character values from integer values. type rune = int32  // int is a signed integer type that is at least 32 bits in size. It is a // distinct type, however, and not an alias for, say, int32. type int int  // uint is an unsigned integer type that is at least 32 bits in size. It is a // distinct type, however, and not an alias for, say, uint32. type uint uint

// float32 is the set of all IEEE-754 32-bit floating-point numbers. type float32 float32  // float64 is the set of all IEEE-754 64-bit floating-point numbers. type float64 float64

// complex64 is the set of all complex numbers with float32 real and // imaginary parts. type complex64 complex64  // complex128 is the set of all complex numbers with float64 real and // imaginary parts. type complex128 complex128  // The complex built-in function constructs a complex value from two // The complex built-in function constructs a complex value from two // floating-point values. The real and imaginary parts must be of the same // size, either float32 or float64 (or assignable to them), and the return // value will be the corresponding complex type (complex64 for float32, // complex128 for float64). func complex(r, i FloatType) ComplexType  // The real built-in function returns the real part of the complex number c. // The return value will be floating point type corresponding to the type of c. func real(c ComplexType) FloatType  // The imag built-in function returns the imaginary part of the complex // number c. The return value will be floating point type corresponding to // the type of c. func imag(c ComplexType) FloatType

// bool is the set of boolean values, true and false. type bool bool  // true and false are the two untyped boolean values. const ( 	true  = 0 == 0 // Untyped bool. 	false = 0 != 0 // Untyped bool. )

// string is the set of all strings of 8-bit bytes, conventionally but not // necessarily representing UTF-8-encoded text. A string may be empty, but // not nil. Values of string type are immutable. type string string

// iota is a predeclared identifier representing the untyped integer ordinal // number of the current const specification in a (usually parenthesized) // const declaration. It is zero-indexed. const iota = 0 // Untyped int.

a := [2]int{1, 2} b := [...]int{1, 2} c := [2]int{1, 3} fmt.Println(a == b, a == c, b == c) // "true false false" d := [3]int{1, 2} fmt.Println(a == d) // compile error: cannot compare [2]int == [3]int

1, 結構體值也可以用結構體面值表示，結構體面值可以指定每個成員的值。  type Point struct{ X, Y int } p := Point{1, 2}  2, 以成員名字和相應的值來初始化，可以包含部分或全部的成員，  anim := gif.GIF{LoopCount: nframes}  在這種形式的結構體面值寫法中，如果成員被忽略的話將默認用零值。  3, 因為結構體通常通過指針處理，可以用下面的寫法來創建并初始化一個結構體變量，并返回結構體的地址：  pp := &Point{1, 2}  它是下面的語句是等價的  pp := new(Point) *pp = Point{1, 2}  不過&Point{1, 2}寫法可以直接在表達式中使用，比如一個函數調用。

type Point struct{ X, Y int }  p := Point{1, 2} q := Point{2, 1} fmt.Println(p.X == q.X && p.Y == q.Y) // "false" fmt.Println(p == q)                   // "false"

var ip *int        /* 指向整型*/  ip是一個指向int類型對象的 指針 var fp *float32    /* 指向浮點型 */  fp是一個指向float32類型對象的 指針

   var a int= 20   /* 聲明實際變量 */    var ip *int        /* 聲明指針變量 */     ip = &a  /* 指針變量的存儲地址 */     fmt.Printf("a 變量的地址是: %xn", &a  )     /* 指針變量的存儲地址 */    fmt.Printf("ip 變量儲存的指針地址: %xn", ip )     /* 使用指針訪問值 */    fmt.Printf("*ip 變量的值: %dn", *ip )

type slice struct { 	array unsafe.Pointer 	len   int 	cap   int }

// The len built-in function returns the length of v, according to its type: //	Array: the number of elements in v. //	Pointer to array: the number of elements in *v (even if v is nil). //	Slice, or map: the number of elements in v; if v is nil, len(v) is zero. //	String: the number of bytes in v. //	Channel: the number of elements queued (unread) in the channel buffer; //	         if v is nil, len(v) is zero. // For some arguments, such as a string literal or a simple array expression, the // result can be a constant. See the Go language specification's "Length and // capacity" section for details. func len(v Type) int  // The cap built-in function returns the capacity of v, according to its type: //	Array: the number of elements in v (same as len(v)). //	Pointer to array: the number of elements in *v (same as len(v)). //	Slice: the maximum length the slice can reach when resliced; //	if v is nil, cap(v) is zero. //	Channel: the channel buffer capacity, in units of elements; //	if v is nil, cap(v) is zero. // For some arguments, such as a simple array expression, the result can be a // constant. See the Go language specification's "Length and capacity" section for // details. func cap(v Type) int  // The append built-in function appends elements to the end of a slice. If // it has sufficient capacity, the destination is resliced to accommodate the // new elements. If it does not, a new underlying array will be allocated. // Append returns the updated slice. It is therefore necessary to store the // result of append, often in the variable holding the slice itself: //	slice = append(slice, elem1, elem2) //	slice = append(slice, anotherSlice...) // As a special case, it is legal to append a string to a byte slice, like this: //	slice = append([]byte("hello "), "world"...) func append(slice []Type, elems ...Type) []Type  // The make built-in function allocates and initializes an object of type // slice, map, or chan (only). Like new, the first argument is a type, not a // value. Unlike new, make's return type is the same as the type of its // argument, not a pointer to it. The specification of the result depends on // the type: //	Slice: The size specifies the length. The capacity of the slice is //	equal to its length. A second integer argument may be provided to //	specify a different capacity; it must be no smaller than the //	length. For example, make([]int, 0, 10) allocates an underlying array //	of size 10 and returns a slice of length 0 and capacity 10 that is //	backed by this underlying array. //	Map: An empty map is allocated with enough space to hold the //	specified number of elements. The size may be omitted, in which case //	a small starting size is allocated. //	Channel: The channel's buffer is initialized with the specified //	buffer capacity. If zero, or the size is omitted, the channel is //	unbuffered. func make(t Type, size ...IntegerType) Type  // The new built-in function allocates memory. The first argument is a type, // not a value, and the value returned is a pointer to a newly // allocated zero value of that type. func new(Type) *Type  // The copy built-in function copies elements from a source slice into a // destination slice. (As a special case, it also will copy bytes from a // string to a slice of bytes.) The source and destination may overlap. Copy // returns the number of elements copied, which will be the minimum of // len(src) and len(dst). func copy(dst, src []Type) int  // The delete built-in function deletes the element with the specified key // (m[key]) from the map. If m is nil or there is no such element, delete // is a no-op. func delete(m map[Type]Type1, key Type)

創建map： 1， 內置的make函數可以創建一個map：  ages := make(map[string]int) // mapping from strings to ints  2， 我們也可以用map字面值的語法創建map，同時還可以指定一些最初的key/value：  ages := map[string]int{     "alice":   31,     "charlie": 34, } 這相當于  ages := make(map[string]int) ages["alice"] = 31 ages["charlie"] = 34 因此，另一種創建空的map的表達式是map[string]int{}。  Map中的元素通過key對應的下標語法訪問： ages["alice"] = 32  delete(ages, "alice") // remove element ages["alice"]  所有這些操作是安全的，即使這些元素不在map中也沒有關系； 如果一個查找失敗將返回value類型對應的零值，例如， 即使map中不存在“bob”下面的代碼也可以正常工作，因為ages["bob"]失敗時將返回0。 ages["bob"] = ages["bob"] + 1 // happy birthday!  遍歷map  for name, age := range ages {     fmt.Printf("%st%dn", name, age) }

func name(parameter-list) (result-list) {     body }

使用內置的make函數，我們可以創建一個channel：  使用內置的make函數，我們可以創建一個channel：  ch := make(chan int) // ch has type 'chan int'