1 函数格式

定义格式：

func functionName(para1 para1Type, para2 para2Type) (ret1 ret1Type, ret2 ret2Type) {
    ...
}

函数名用骆驼命名法。
main函数无参数无返回。
其他函数可以有多个返回值，跟Python一样。

每个包在被引入或者main包开始运行的时候，可以有一个首先运行的函数，类似于构造函数：

func init () {
    ...
}

2 类型

Go语言的静态性，体现在类型上，需要显示定义，显示转换。
变量、常量，具有类型。
声明形式：

var varName varType
var varName varType = xxx
varName := xxx

var s string
var v int = 5
a := 5.0

类型转换：

valueOfTypeB = typeB(valueOfTypeA)

a := 5.0
b := int(a)

2.1 基本类型

基本类型
int
float
bool
byte

2.1.1 int

int	范围
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

从上面看不到int/uint类型，Go语言的int/uint类型，是不可移植的类型，其长度根据宿主机的机器字长决定，比如32位的架构，int/uint就是int32/uint32；64位架构，int/uint就是int64/uint64。

uintptr是宿主系统内足够存放一个指针的类型。

八进制：0777
十六进制：0xFF
格式化输出：%d %x %X

2.1.2 float

float	精度
float32（+- 1e-45 -> +- 3.4 * 1e38）	精确位数小数点后7位
float64（+- 5 * 1e-324 -> 107 * 1e308）	精确位数小数点后15位

格式化输出：%g %f %e

2.1.3 bool

true或者false。
比较运算表达式（==, !=），可以返回bool类型的结果。
bool类型可以参与到逻辑运算中（!, &&, ||），采用短路运算。
格式化输出用 %t 表示bool类型。

2.1.4 byte

byte其实是整型的特殊用例。byte是uint8的别名。

var ch byte = 'A'
var ch byte = 65
var ch byte = '\0x41' //0x后面必须跟2位的16进制数

如果是UTF-8，就不能用byte了，要用int：

var ch int = '\u0041'
var ch2 int = '\u03B2'
fmt.Printf("%d, %d", ch, ch2) //int
fmt.Printf("%c, %c", ch, ch2) //字符
fmt.Printf("%X, %X", ch, ch2) //UTF-8字节
fmt.Printf("%U, %U", ch, ch2) //UTF-8 code point

65, 946
A, β
41, 3B2
U+0041, U+03B2

字符类型的一些判定函数，在系统包unicode里边：

unicode.IsLetter(ch)
unicode.IsDigit(ch)
unicode.IsSpace(ch)

2.2 字符串

其实是个字节类型的定常数组，但是一旦初始化后，内容不可变。
转义字符还是老样子：

转义字符
\n
\r
\t
\u \U Unicode字符
\\

新的东西是非解释字符串，里边的内容不解释，没有转义，用反括号（键盘1左边的那个键）括起来：

`This is a raw string \n`
This is a raw string \n

字符串的对比，可以通过：

字符串对比运算符
==
!=
<
<=
>
>=

比较的方式是按照字节来对比。

2.2.1 长度

len(str)

2.2.2 字符

str[0]
str[1]
str[len(str) - 1]

2.2.3 拼接

s = s1 + s2
strings.Join()
bytes.Buffer

2.2.4 strings 包

前后缀

strings.HasPrefix(s, prefix string) bool //s是否以prefix开头
strings.HasSuffix(s, suffix string) bool //s是否以suffix结尾

包含

strings.Contains(s, substr string) bool //s是否包含substr

index位置

strings.Index(s, str string) int //str在s中的位置，-1表示不包含
strings.LastIndex(s, str string) int //s中最后一个str的位置，-1表示不包含
strings.IndexRune(s string, r rune) int //非ASCII字符的定位

替换

strings.Replace(str, old, new, n) string 
//str中前n个old换成new，n=-1表示全部替换
//并不会改变str，返回一个新的string

统计个数

strings.Count(s, str string) int //str在s中出现的个数

重复字符串

strings.Repeat(s, count int) string //s重复count次，生成一个新的string

大小写

strings.ToLower(s) string //s里边全部Unicode字符变成小写
strings.ToUpper(s) string //s里边全部Unicode字符变成大写

字符串修剪

strings.TrimSpace(s) string //删除头尾两端的空白字符
strings.Trim(s, cutset) string //删除头尾两端的cutset字符串
strings.TrimLeft(s, cutset) string
strings.TrimRight(s, cutset) string

字符串分割

strings.Fields(s) []string //按照空白字符分割s，返回一个slice
strings.Split(s, sep) []string //按照指定字符分割s，返回slice

拼接slice

strings.Join(sl []string, sep string) string //用分割符把slice拼接到一起

从字符串中读取内容

strings.NewReader(str) *Reader //实例化一个Reader，可以用Reader的若干方法
.Len()
.Read(b []byte) (n int, err error) //把str的内容读入到一个[]byte中

关于Reader的Read，有个例子，反复Read到一个[]byte中：

    func main() {  
        s := "Hello World!"  
        // 创建 Reader  
        r := strings.NewReader(s)  
        // 创建长度为 5 个字节的缓冲区  
        b := make([]byte, 5)  
        // 循环读取 r 中的字符串  
        for n, _ := r.Read(b); n > 0; n, _ = r.Read(b) {  
            fmt.Printf("%q, ", b[:n]) // "Hello", " Worl", "d!"  
        }  
    }

2.2.5 strconv 包

字符串和其他类型的转换

strconv.IntSize //当前平台int的字长
strconv.Itoa(i int) string //整数转字符串
strconv.FormatFloat(f float64, fmt byte, prec int, bitSize int) string //float64 转字符串， fmt可以是'b', 'e', 'f', 'g'；prec表示精度；bitSize 32表示float32，64表示float64
strconv.Atoi(s string) (i int, err error) //字符串转整数
strconv.ParseFloat(s string, bitSize int) (f float64, err error) //字符串转float64

2.3 常量

const identifier [type] = value

const b string = "abc"
const b = "abc"
const Pi = 3.14159

注意上面的常量定义，类型是可以省略的，但是不等于没有类型了，省略关键字的时候，类型是编译器自己判断出来并加上的。

常量的值必须在编译时可知，运行时才知道的值不能作为常量定义的右值。

const c1 = 2/3 // OK
const c2 = getNumber() // 引发构建错误: getNumber() used as value

2.4 枚举

枚举用的是常量，没有专门的枚举类型，奉行能少就少，能用别的代替就用别的代替的原则：

const (
    Unknown = 0
    Female = 1
    Male = 2
)
const (
    a = iota
    b
    c
) 
// 每一个新行，iota都加1，所以a, b, c = 0, 1, 2
// 每遇到const，iota就归零

2.5 变量

名字在前，类型在后。

var a, b *int //a和b都是*int类型
var (
    a int
    b bool
    str string
)

变量声明后就有零值了，所以都是经过初始化的：

int 0
float 0.0
bool false
string “”
* nil

作用域：
1. 函数外，全局，包内甚至包外（首字母大写）可用
2. 函数内，代码块外，函数可用
3. 函数内，代码块内（if, for等含有{}的部分），代码块内可用

Go语言-基本类型（int，float，bool，byte，string）