⼀起来学Go---（go的枚举以及数据类型）
枚举
枚举指⼀系列的相关的常量，⽐如下⾯关于⼀个星期的中每天的定义，通过上篇博⽂，我们可以⽤在const后跟⼀对圆括号的⽅式定义⼀组常量，这种定义法在go语⾔中通常⽤于定义枚举值。go语⾔并不⽀持众多其他语⾔明确⽀持的enum关键字。
下⾯是⼀个常规的枚举表⽰法，其中定义了⼀系列整型常量。
const (
Sunday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
numberOfDays      // 这个常量没有导出
)
  同go语⾔中的其他符号(symbol)⼀样，以⼤写字母开头的常量在包外可见。
以上列⼦中 numberOfDays为包内私有，其他符号则可被其他包访问。
数据基本类型
布尔类型： bool
整数类型： int8、byte、int6、int、uint、uintptr等。
浮点类型： float32、float64。go语言字符串转数组
复数类型：complex64、complex128。
字符串：string。
字符类型：rune。
错误类型：error。
处上之外，go语⾔还⽀持⼀下的复合类型。
指针(pointer)
数组(array)
切⽚(slice)
字典(map)
通道(chan)
结构体(struct)
接⼝(interface)
  上述类型的特点在于使⽤⽅便，但使⽤者不能对这些类型的长度做任何假设。对于常规的开发来说，⽤int和uint就可以了，没必要⽤int8之类明确指定长度的类型，以免导致移植困难。
布尔类型
go语⾔中的布尔类型与其他语⾔基本⼀致，关键字也是 bool ，可赋值为预定义的true和false。
var test bool
test = true
test_two := (1 == 2)          // test_two也会被推导为bool类型
PS：布尔类型不能接受其他类型赋值，不⽀持⾃动或强制的类型转换。
下⾯⼀些错误的语法：
var  a bool
a = 1                        // 语法错误
a = bool(1)                  // 语法错误
以下的⽤法才是正确：
var one bool
one = (1 != 0)              // 正确语法
fmt.Println("result:", one)  // go的输出  Println
输出结果：
result : true
　整型：
整型是所有语⾔⾥最基础的类型了。
类型长度值范围
int8                            1                                -128 ~ 127
uint8(既byte)                  1                                  0 ~255
int16                          2                              -32 768 ~ 32 767
uint16                          2                                  0~65 535
int32                          4                          -2 147 483 648 ~ 2 147 483 647
uint32                          4                              0 ~ 4 294 967 295
int64                          8                -9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807
uint64                          8                          0 ~ 18 446 744 073 709 551 615
int                          因平台⽽定因平台⽽定
uint                        因平台⽽定因平台⽽定
uintptr                        同指针在32位平台下为4字节，64位平台下为8字节
  ①、类型表⽰
需要注意的是，int和int32在go语⾔⾥被认为是两种不同的类型，编译器也不会帮你⾃动做转换类型，⽐如以下的列⼦会有编译错误：
var value2 int32
value1 := 64                        // value1将会被⾃动推导为int类型
value2 = value1                    // 编译错误
编译错误类似于：
cannot use valu1 (type int) as type int32 in assignment。
使⽤强制类型转换可以解决这个编译错误：
value2 = int32 (value1)            //编译通过
  当然，开发者在做强制类型转换时，需要注意数据长度被截断⽽发⽣的数据精度损失(⽐如将浮点数强制转为整数)和值溢出(值超过转换的⽬标类型的值范围时)问题。
  ②、数值运算
go语⾔⽀持下⾯的常规整数运算： +、-、*、/、和%。加减乘除就不解释了，需要说下的是，%和C语⾔中⼀样是求余运算，⽐如：
5 % 3                              // 结果： 2
  ③、⽐较运算
go语⾔⽀持以下的⼏种⽐较运算符：  >  、 <  、 ==、>=、 <=和!=。这⼀点与其他⼤多数的语⾔相通，与C语⾔完全⼀致。
  ④、运算符
运算含义样列
x << y                左移                      124 << 2  // 结果为496
x >> y                右移                      124 >> 2  // 结果为31
x ^ y                  异或                      124 ^ 2    // 结果为126
x & y                  与                        124 & 2  // 结果为0
x | y                  或                        124 | 2  // 结果为126
^x                    取反                        ^2      // 结果为 3
  go语⾔的⼤多数位运算符与C语⾔都⽐较类似，除了取反在C语⾔中是~x，⽽在go语⾔中是^x。
浮点型
浮点型⽤于表⽰包含⼩数点的数据，⽐如1.234就是⼀个浮点型数据，在go语⾔中的浮点类型采⽤IEEE-754标准的表达⽅式。
①、浮点数表⽰
go语⾔定义了两个类型float32和float64，其中float32等价于C语⾔的float类型，float64等价于C语⾔的double类型。
在go语⾔中，定义⼀个浮点数变量的代码如下：
var fvalue1 float32
fvalue1 = 12
fvalue2 := 12.0    // 如果不加⼩数点，fvalue2会被推导为整型⽽不是浮点型
  对于以上列⼦类型被⾃动推导的fvalue2，需要注意的是其类型将被⾃动设为float64，⽽不管赋给它的
数字是否使⽤32位长度表⽰的，因此，对于以上列⼦，下⾯的赋值将导致编译错误：
fvalue1 = fvalue2
⽽必须使⽤这样的强制类型转换：
fvalue1 = float32(fvalue2)
　②、浮点数⽐较
因为浮点数不是⼀种精确的表达⽅式，所以像整型那样直接⽤==来判断两个浮点数是否相等是不可⾏的，这可能会导致不稳定的结果。
下⾯是⼀种推荐的替代⽅案。import "mat// p为⽤户⾃定义的⽐较精度，⽐如：0.00001
func IsEqual(f1, f2, p float64) bool {
return math.Fdim(f1, f2) < p
} 
  复数类型
复数实际上由两个实数(在计算机中⽤浮点数表⽰)构成，⼀个表⽰实部(real),⼀个表⽰虚部(imag)，如果了解了数学上的复数是怎么回事，那么go语⾔的复数就⾮常容易理解了。
①、复数表⽰
复数⽰例：
var value1 complex64            // 由2个float32构成复数类型
value1 = 3.2 + 12i
value2 := 3.2 + 12i              //value2是complex128类型
value3 := complex(3.2, 12)    //value3结果同value2
  ②、实部与虚部
对于⼀个复数z = complex(x, y)，就可以通过go语⾔内置函数real(z)获得该复数的实部，也就是x，通过imag(z)获得该复数的虚部，也就是y。
字符串
在go语⾔中，字符串也是⼀种基本类型，相⽐之下，C/C++语⾔中并不存在原⽣的字符串类型，通常使⽤字符数组来表⽰，并以字符指针来传递。
go语⾔中⼀下是字符串的声明和初始化。
var str string  // 声明⼀个字符串变量
str = "Hello world"    // 字符串赋值
ch := str[0]              // 取字符串的第⼀个字符
fmt.Printf("The length of \"%s\" is %d \n", str, len(str))
fmt.Printf("The first character of \" %s\"is %c.\n", str, ch)
输出结果：
The length of "Hello world" is 11
The first character of "Helllo world" is H.
  字符串的内容看可以⽤类似于数组下标的⽅式获取，但与数组不同，字符串的内容不能再初始化后被修改，⽐如⼀下列⼦：
str := "Hello world"    //  字符串也⽀持声明时进⾏初始化的做法
str[0] = "x"              //  编译错误
编译器会报类似如下错误：
cannot assign to str[0]
  字符串的操作
运算含义样列
x + y                  字符串连接                  "Hello" + "123"    //  hello123
len(str)              字符串长度                          len("hello")  // 5
s[*]                    取字符                            "hello" [1]      // e
更多⽅法请参考string标准库包
  ①字符串遍历
go语⾔中⽀持两种遍历⽅式，⼀种是以字节数组的⽅式遍历：
str := "Hello，世界"
n := len(str)
for i := 0; i < n; i++ {
ch := str[i]    // 依据下标取字符串中的字符，类型为byte
fmt.Println(i, ch)
}
结果：
0 72
1 101
2 108
3 108
4 111
5 44
6 32
7 228
8 184
9 150
10 231
11 149
12 140
  可以看出，这个字符串长度为13，尽管从直观上来说，这个字符串应该只有9个字符，这是因为每个中⽂字符在UTF-8中占三个字节，⽽不是壹个字节。
另⼀种是以Unicode字符遍历：
str := "Hello, 世界"
for i, ch := range str {
fmt.Println(i, ch)    // ch的类型为true
}
结果：
0 72
1 101
2 108
3 108
4 111
5 44
6 32
7 19990
10 30028
  以Unicode字符⽅式遍历时，每个字符的类型是rune(早期的go语⾔⽤int类型表⽰Unicode字符)，⽽不是byte。
字符类型
在go语⾔中⽀持两个字符类型，⼀个是byte(实际上是uint8的别名)，代表UTF-8字符串的单个字节的值，另⼀个是rune，代表单个Unicode 字符。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。