Go にはデータ型がいくつありますか?

Go には 4 つのデータ型があります: 1. 基本型 (整数、浮動小数点数、複素数、ブール値、文字列、定数など); 2. 集計型 (配列および構造体を含む) (集計データ A 型)任意の型の 0 個以上の値から集約されたエンティティです。各値は構造体のメンバーと呼ばれます); 3. ポインタ、スラ​​イス、マップ、関数、チャネルを含む参照型; 4. インターフェイス型、それは他のタイプの動作の抽象化および一般化であり、抽象タイプです。

このチュートリアルの動作環境: Windows 7 システム、GO バージョン 1.18、Dell G3 コンピューター。

Go のデータ型は、基本型、集約型、参照型、インターフェイス型の 4 つの主要なカテゴリに分類されます。

#基本型は、整数、浮動小数点数、複素数、ブール値、文字列、定数に分類されます
• #集計タイプには、配列、構造体が含まれます
• 参照タイプには、ポインタ、スラ​​イス、マップ、関数、チャネルが含まれます。
• インターフェイス タイプ

##基本タイプ

#整数: #

// 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 値は次のように構成されています多くの要素またはメンバーフィールドの値の。

配列は同型要素で構成されます。各配列要素はまったく同じ型です。一方、構造体は異種要素で構成されます。

配列と構造体は、固定メモリ サイズを持つデータ構造体です。 対照的に、スライスとマップは、必要に応じて動的に拡張される動的データ構造です。

• #Array

• 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

• 配列の要素の型が互いに同等である場合, 次に、配列型を相互に比較することもできます。このとき、== 比較演算子を使用して 2 つの配列を直接比較できます。
• 配列が等しいのは、2 つの配列のすべての要素が等しい場合のみです。
不等号比較演算子 != も同じルールに従います。

関数が呼び出されるとき、関数の各呼び出しパラメーターは関数内のパラメーター変数に割り当てられるため、関数パラメーター変数は元の呼び出し変数ではなく、コピーされたコピーを受け取ります。関数パラメータの受け渡しメカニズムのため、大きな配列型 を渡すのは非効率的であり、配列パラメータへの変更はコピーされた配列で行われ、 を呼び出したときに元の配列変数を直接変更することはできません。値渡しによる呼び出し配列ポインタを明示的に渡すことができます。その場合、ポインタを介した関数による配列の変更は呼び出し元に直接フィードバックできます

構造
• 構造は、0 個以上のエンティティで構成される集約データ型です。あらゆるタイプの値を集約して形成されます。それぞれの値は構造体のメンバーと呼ばれます。 構造体のメンバー名が大文字で始まる場合、メンバーはエクスポートされます;

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}写法可以直接在表达式中使用，比如一个函数调用。

構造体のすべてのメンバーが比較可能な場合、構造体も比較可能ですこの場合、2 つの構造は または != 演算子を使用して比較されます。等価比較演算子 は 2 つの構造体の各メンバーを比較するため、次の 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 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )

slice

• Slice (スライス) は、可変長のシーケンスを表します。シーケンス すべての要素は同じ型を持ちます。
• 
  スライス タイプは通常 []T と書かれ、T はスライス内の要素のタイプを表します。

スライスの構文は配列の構文とよく似ていますが、次の点が異なります。固定長ではありません

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)

• #マップ

##
• 在Go语言中，一个map就是一个哈希表的引用，map类型可以写为map[K]V，其中K和V分别对应key和value。map中所有的key都有相同的类型，所有的value也有着相同的类型。
• 其中K对应的key必须是支持==比较运算符的数据类型，所以map可以通过测试key是否相等来判断是否已经存在。虽然浮点数类型也是支持相等运算符比较的，但是将浮点数用做key类型则是一个坏的想法。
• 对于V对应的value数据类型则没有任何的限制。

创建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("%s\t%d\n", name, age)
}

函数

函数声明包括函数名、形式参数列表、返回值列表（可省略）以及函数体。

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

channel 通道

• 如果说goroutine是Go语音程序的并发体的话，那么channels它们之间的通信机制。
• 一个channels是一个通信机制，它可以让一个goroutine通过它给另一个goroutine发送值信息。
• 每个channel都有一个特殊的类型，也就是channels可发送数据的类型。一个可以发送int类型数据的channel一般写为chan int。

使用内置的make函数，我们可以创建一个channel：

使用内置的make函数，我们可以创建一个channel：

ch := make(chan int) // ch has type 'chan int'

• 和map类似，channel也一个对应make创建的底层数据结构的引用。

• 当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者何被调用者将引用同一个channel对象。和其它的引用类型一样，channel的零值也是nil。

• 两个相同类型的channel可以使用==运算符比较。如果两个channel引用的是相通的对象，那么比较的结果为真。一个channel也可以和nil进行比较。

接口类型

接口

• 接口类型是对其它类型行为的抽象和概括；因为接口类型不会和特定的实现细节绑定在一起，通过这种抽象的方式我们可以让我们的函数更加灵活和更具有适应能力。

• 很多面向对象的语言都有相似的接口概念，但Go语言中接口类型的独特之处在于它是满足隐式实现的。

• 也就是说，我们没有必要对于给定的具体类型定义所有满足的接口类型；简单地拥有一些必需的方法就足够了。

• 这种设计可以让你创建一个新的接口类型满足已经存在的具体类型却不会去改变这些类型的定义；当我们使用的类型来自于不受我们控制的包时这种设计尤其有用。

• 接口类型是一种抽象的类型。它不会暴露出它所代表的对象的内部值的结构和这个对象支持的基础操作的集合；它们只会展示出它们自己的方法。也就是说当你有看到一个接口类型的值时，你不知道它是什么，唯一知道的就是可以通过它的方法来做什么。

【相关推荐：Go视频教程、编程教学】

以上がGo にはデータ型がいくつありますか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。