【Golang源码阅读】builtin/builtin.go

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
	builtin包为Go的预先声明的标识符提供了文档
*/
package builtin

// bool 是布尔值的集合，true 和 false
type bool bool

// true 和 false 是两个无类型的布尔值
const (
	true  = 0 == 0 // Untyped bool.
	false = 0 != 0 // Untyped bool.
)

// uint8 是全部 8 位无符号整型的集合
// 范围: 0 ~ 255.
type uint8 uint8

// uint16 是全部 16 位无符号整型的集合
// 范围: 0 ~ 65535.
type uint16 uint16

// uint32 是全部 32 位无符号整型的集合
// 范围: 0 ~ 4294967295.
type uint32 uint32

// uint64 是全部 64 位无符号整型的集合
// 范围: 0 ~ 18446744073709551615.
type uint64 uint64

// int8 是全部 8 位有符号整型的集合
// Range: -128 through 127.
type int8 int8

// int16 是全部 16 位有符号整型的集合
// 范围: -32768 ~ 32767.
type int16 int16

// int32 是全部 32 位有符号整型的集合
// 范围: -2147483648 ~ 2147483647.
type int32 int32

// int64 是全部 64 位有有符号整型的集合
// 范围: -9223372036854775808 ~ 9223372036854775807.
type int64 int64

// float32 是全部 32 位浮点数的集合
type float32 float32

// float64 是全部 64 位浮点数的集合
type float64 float64

// complex64 是具备 float32 实部和虚部的全部复数的集合
type complex64 complex64

// complex128 是具备 float64 实部和虚部的全部复数的集合
type complex128 complex128

// string 是全部 8 位字节字符串的集合，一般但不必定表明 UTF-8 编码的文本。 字符串类型的值是不可变的。
type string string

// int 是大小至少为 32 位的有符号整数类型
type int int

// uint 是大小至少为 32 位的无符号整数类型。 可是，它是一种独特的类型，而不是 uint32 等的别名
type uint uint

// uintptr 是一个整数类型，它大到足以容纳任何指针的位模式
type uintptr uintptr

// byte 是 uint8 的别名，在全部方面都等同于 uint8。 按照惯例，它用于区分字节值和 8 位无符号整数值
type byte = uint8

// rune 是 int32 的别名，在全部方面都等同于 int32。 按照惯例，它用于区分字符值和整数值
type rune = int32

// iota 是一个预先声明的标识符，表示（一般带括号的）const 声明中当前 const 规范的无类型整数序数。 它是零索引的。
const iota = 0 // Untyped int.

// nil 是一个预先声明的标识符，表示指针、通道、函数、接口、映射或切片类型的零值
var nil Type // 类型必须是一个pointer, channel, func, interface, map, or slice type

// 此处的类型仅用于文档目的。 它是任何 Go 类型的替代品，但表明任何给定函数调用的相同类型
type Type int

// Type1 仅用于文档目的。 它是任何 Go 类型的替代品，但表明任何给定函数调用的相同类型。
type Type1 int

// IntegerType 仅用于文档目的。 它是任何整数类型的替代：int、uint、int8 等。
type IntegerType int

// FloatType 在这里仅用于文档目的。 它是浮点类型的替代：float32 或 float64。
type FloatType float32

// ComplexType 仅用于文档目的。 它是复杂类型的替代：complex64 或 complex128。
type ComplexType complex64

// append 内置函数将元素附加到切片的末尾。 若是它有足够的容量，目标将被从新切片以容纳新元素。
// 若是没有，将分配一个新的底层数组。Append 返回更新后的切片。 所以有必要将 append 的结果存储在保存切片自己的变量中：
//	slice = append(slice, elem1, elem2)
//	slice = append(slice, anotherSlice...)
// 做为一种特殊状况，将字符串附加到字节切片是合法的，以下所示：
//	slice = append([]byte("hello "), "world"...)
func append(slice []Type, elems ...Type) []Type

// copy 内置函数将元素从源切片复制到目标切片。 （做为一种特殊状况，它还会将字节从字符串复制到字节切片。）源和目标可能重叠。
// Copy 返回复制的元素数，这将是 len(src) 和 len(dst) 中的最小值。
func copy(dst, src []Type) int

// delete 内置函数从映射中删除具备指定键 (m[key]) 的元素。 若是 m 为 nil 或没有这样的元素，则 delete 是空操做
func delete(m map[Type]Type1, key Type)

// len 内置函数根据 v 的类型返回 v 的长度：
// 数组：v 中元素的数量。
// 指向数组的指针：*v 中的元素数（即便 v 为零）。
// 切片或映射：v 中元素的数量； 若是 v 为零，则 len(v) 为零。
// 字符串：v 中的字节数。
// 通道：通道缓冲区中排队（未读）的元素数量； 若是 v 为零，则 len(v) 为零。
// 对于某些参数，例如字符串文字或简单的数组表达式，结果能够是常量。
func len(v Type) int

// cap 内置函数根据其类型返回 v 的容量：
//	数组：v 中元素的数量（与 len(v) 相同）。
//	指向数组的指针：*v 中的元素数（与 len(v) 相同）。
//	Slice：从新切片时切片所能达到的最大长度； 若是 v 为nil，则 cap(v) 为零。
//	Channel：通道缓冲容量，以元素为单位；若是 v 为nil，则 cap(v) 为零。
// 对于某些参数，例如简单的数组表达式，结果能够是常量
func cap(v Type) int

// make 内置函数分配和初始化 slice、map 或 chan（仅限）类型的对象。
// 和 new 同样，第一个参数是一个类型，而不是一个值。 与 new 不一样，make 的返回类型与其参数的类型相同，而不是指向它的指针。
// 结果的规范取决于类型：
//	切片：大小指定长度。 切片的容量等于其长度。 能够提供第二个整数参数来指定不一样的容量； 它必须不小于长度。
//	例如，make([]int, 0, 10) 分配一个大小为 10 的底层数组，并返回一个由该底层数组支持的长度为 0 和容量为 10 的切片。
//
// Map：为空映射分配足够的空间来容纳指定数量的元素。 能够省略大小，在这种状况下分配一个小的起始大小。
//	通道：通道的缓冲区被初始化为指定的缓冲区容量。 若是为零，或者省略了大小，则通道是无缓冲的。
func make(t Type, size ...IntegerType) Type

// new内置函数分配内存。 第一个参数是一个类型，而不是一个值，返回的值是一个指向该类型新分配的零值的指针
func new(Type) *Type

// complex 内置函数从两个浮点值构造一个复数值。
// 实部和虚部的大小必须相同，float32 或 float64（或可分配给它们），返回值将是相应的复数类型（float32 为 complex64，float64 为 complex128）。
func complex(r, i FloatType) ComplexType

// real 内置函数返回复数 c 的实部。返回值将是与 c 类型对应的浮点类型
func real(c ComplexType) FloatType

// imag 内置函数返回复数 c 的虚部。 返回值将是对应于 c 类型的浮点类型
func imag(c ComplexType) FloatType

// close 内置函数关闭通道，该通道必须是双向的或仅发送的。 它应该只由发送方执行，而不是由接收方执行，而且具备在接收到最后发送的值后关闭通道的效果。
// 从关闭的通道 c 接收到最后一个值后，来自 c 的任何接收都将成功而不会阻塞，返回通道元素的零值。 x, ok := <-c 也会将 ok 设置为关闭通道的 false。
func close(c chan<- Type)

// panic 内置函数会中止 currentgoroutine 的正常执行。
// 当函数 F 调用 panic 时，F 的正常执行会当即中止。
// 任何被 F 推迟执行的函数都以正常的方式运行，而后 F 返回给它的调用者。
// 对于调用者 G 来讲，F 的调用就像是调用 panic，终止 G 的执行并运行任何延迟函数。
// 这一直持续到全部正在执行的 goroutine 中的函数以相反的顺序中止。
// 在此时，程序以非零退出代码终止。 这终止序列称为恐慌，能够由内置功能恢复。
func panic(v interface{})

// revocer内置函数容许程序管理恐慌 goroutine 的行为。
// 在延迟函数（但不是它调用的任何函数）内执行恢复调用经过恢复正常执行来中止恐慌序列，并检索传递给恐慌调用的错误值。
// 若是在延迟函数以外调用恢复，它不会中止恐慌序列。
// 在这种状况下，或者当 goroutine 没有发生恐慌时，或者若是提供给恐慌的参数为零，则recover 返回零。
// 所以，recover 的返回值会报告 goroutine 是否处于恐慌状态。
func recover() interface{}

// print 内置函数以特定于实现的方式格式化其参数并将结果写入标准错误。Print 对于引导和调试颇有用
func print(args ...Type)

// println 内置函数以特定于实现的方式格式化其参数并将结果写入标准错误
// 参数之间老是添加空格并附加换行符。Println 对于引导和调试颇有用
func println(args ...Type)

// error 内置接口类型是表示错误条件的常规接口，nil 值表示没有错误
type error interface {
	Error() string
}