go语言学习——1

基本类型和运算符

布尔类型

var b bool=true
var a bool=false
var aVar=10
aVar==5//false
aVar==10//true

• !非、&&和、||或
• ==、!=
• 格式化输出：%t

数字类型

整数：

• int8（-128 -> 127）
• int16（-32768 -> 32767）
• int32（-2,147,483,648 -> 2,147,483,647）
• int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

---

无符号整数：

• uint8（0 -> 255）
• uint16（0 -> 65,535）
• uint32（0 -> 4,294,967,295）
• uint64（0 -> 18,446,744,073,709,551,615）

---

没有float类型，只有float32和float63，没有double类型
浮点型：

• float32（± 1e-45 -> ± 3.4 * 1e38）
• float64（± 5 1e-324 -> 107 1e308）

---

• int 型是计算最快的一种类型。
• 整型的零值为 0，浮点型的零值为 0.0。

---

• 8进制数，前缀0，077
• 16进制，前缀0x，0xFF
• 10连乘，e，1e3=1000
• 可以使用 a := uint64(0) 来同时完成类型转换和赋值操作

//Go中不允许不同类型之间的混合使用，但对常量类型的限制非常少，允许常量之间的混合使用
package main

func main() {
    var a int
    var b int32
    a = 15
    b = a + a    // 编译错误
    b = b + 5    // 因为 5 是常量，所以可以通过编译
}

//int16 也不能够被隐式转换为 int32。
package main

import "fmt"

func main() {
    var n int16 = 34
    var m int32
    // compiler error: cannot use n (type int16) as type int32 in assignment
    //m = n
    m = int32(n)

    fmt.Printf("32 bit int is: %d\n", m)
    fmt.Printf("16 bit int is: %d\n", n)
}

格式化：

• %d 用于格式化整数（%x 和 %X 用于格式化16 进制表示的数字），%g 用于格式化浮点型（%f 输出浮点数，%e 输出科学计数表示法），%0d 用于规定输出定长的整数，其中开头的数字 0 是必须的。
• %n.mg 用于表示数字 n 并精确到小数点后 m 位，除了使用 g 之外，还可以使用 e 或者 f，例如：使用格式化字符串 %5.2e 来输出 3.4 的结果为 3.40e+00。

复数

complex64 (32 位实数和虚数)
complex128 (64 位实数和虚数)

复数使用 re+imI 来表示，其中 re 代表实数部分，im 代表虚数部分，I 代表根号负 1。

var c1 complex64 = 5 + 10i
fmt.Printf("The value is: %v", c1)
// 输出： 5 + 10i

位运算

位运算只能用于整数类型的变量，且需当它们拥有登场模式时。

二元运算符：

• 位与&
• 位或|
• 位异或^
• 位清除&^：将指定位置上的值设置为0

---

一元运算符：

• 位补足^

该运算符与异或运算符一同使用，即 m^x，对于无符号 x 使用 “全部位设置为 1”，对于有符号 x 时使用 m=-1。

• 位左移<<

用法：bitP << n。
bitP 的位向左移动 n 位，右侧空白部分使用 0 填充；如果 n 等于 2，则结果是 2 的相应倍数，即 2 的 n 次方。

位右移>>

用法：bitP >> n。
bitP 的位向右移动 n 位，左侧空白部分使用 0 填充；如果 n 等于 2，则结果是当前值除以 2 的 n 次方。

逻辑运算符

==, !=, <, <=, >, >=

算术运算符

+, -, *, /

随机数

rand包

package main
import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    for i := 0; i < 10; i++ {
        a := rand.Int()
        fmt.Printf("%d / ", a)
    }
    for i := 0; i < 5; i++ {
        r := rand.Intn(8)
        fmt.Printf("%d / ", r)
    }
    fmt.Println()
    timens := int64(time.Now().Nanosecond())
    rand.Seed(timens)
    for i := 0; i < 10; i++ {
        fmt.Printf("%2.2f / ", 100*rand.Float32())
    }
}

• 函数 rand.Float32 和 rand.Float64 返回介于 [0.0, 1.0) 之间的伪随机数，其中包括 0.0 但不包括 1.0。函数 rand.Intn 返回介于 [0, n) 之间的伪随机数。

• 可以使用 Seed(value) 函数来提供伪随机数的生成种子，一般情况下都会使用当前时间的纳秒级数字。

运算符的优先级

优先级     运算符
 7      ^ !
 6      * / % << >> & &^
 5      + - | ^
 4      == != < <= >= >
 3      <-
 2      &&
 1      ||

字符类型

• 字符只是整数的特殊用例。byte类型是unit8的别名，对于只占用一个字节的传统ASCII编码的字符完全没问题。字符用单引号括起来。

var ch byte='A'
var ch byte=65	//A的值是65
var ch byte='\x41'	//十六进制表示

• 同样支持Unicode，字符称为Unicode代码点或者runes，在内存中使用int来表示，一般使用格式U+hhhh来表示，h表示一个16进制数。rune也是Go中的一个类型，是int32的别名
• \U紧跟着长度为8的16进制数
• \u紧跟着长度为4的16进制数

var ch int = '\u0041'
var ch2 int = '\u03B2'
var ch3 int = '\U00101234'
fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer
fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character
fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes
fmt.Printf("%U - %U - %U", ch, ch2, ch3) // UTF-8 code point

//输出
65 - 946 - 1053236
A - β - r
41 - 3B2 - 101234
U+0041 - U+03B2 - U+101234

格式化说明符%c用于表示字符；当和字符配合使用时，%v 或 %d 会输出用于表示该字符的整数；%U 输出格式为 U+hhhh 的字符串

包 unicode 包含了一些针对测试字符的非常有用的函数（其中 ch 代表字符）：

• 判断是否为字母：unicode.IsLetter(ch)
• 判断是否为数字：unicode.IsDigit(ch)
• 判断是否为空白符号：unicode.IsSpace(ch)