go - 内置基础类型

Go 语言中包括以下内置基础类型：
布尔型：bool

整型：int int64 int32 int16 int8 uint8(byte) uint16 uint32 uint64 uint

浮点型：float32 float64

复数型：complex64 complex128

字符串：string

字符型：rune

错误型：error

1. bool类型

关键字: bool

可定义为: true 或者 false 或者 逻辑表达式

var bool1 bool = true
var bool2 bool = (2 == 2)

注：不能接受其他类型的赋值，包括(0, 1)，也不支持自动或强制类型转换

2. 整型

分为有符号与无符号两种

值范围，如: int8 2^8 -128~127, uint8 0~255, 其他以此类推

int/uint 其值范围与平台有关，所以 int32 != int

支持强制类型转换，注意精度问题

变量2 = 类型(变量1)

3. 浮点型

即含小数点的数据

有两种: float32 float64(默认)

可相互转换,

注：比较大小时最好先确定比较精度, 再比较大小

4. 字符串

声明方式: var str string

值用 "" 或者 `` 包括, `` 可包含多行字符串

字符串的操作与数组相同

与如php等其他语言不同的是，字符串的内容在初始化后，不能被修改，但可重新完全赋值

s := "123"
s[1] = "3" //compile error

$s = "123"; $s[1] = "3"; echo $s; //133

5. 字符型

两种字符类型: 

byte 对应 utf-8

rune 对应 unicode

6. 错误型

在 go 语言中，负责错误信息处理的是 error 接口，也可以使用 errors 包

var e error = errors.New("...")

在 go 语言中，函数支持多个返回值

可用下面的方式来处理错误

res, err := funName(param)
if err != nil {
    //处理错误
} else {
    //无错误
}

func funName(param) (res type, err error) {
    if ... {
        err = errors.New(...)
        return
    }
    ...
    return res, nil
}

7. 复数

在此省略，有需要可再了解

note_type_1.go code list

package main

import "fmt"
import "errors" //引入 errors 包

//声明 bool 型全局变量
var (
	enable = true
	disable = false
)

func main() {
	//预定义常量 iota
	const (
		c0 = iota //0
		c1 = iota //0+1
		c2        //会自动赋上一个定义常量的值或者表达式
	)
	const (
		c3 = iota //0
		c4
	)
	fmt.Println("c0, c1, c2 = ", c0, c1, c2)
	fmt.Println("c3, c4 = ", c3, c4)

	/*
	//这种写法编译时会报错，需要 if condition { 在同一行代码中
	//missing condition in if statement
 	//enable == true not used
	if enable == true
	{
		fmt.Println("error")
	}
	*/
	if enable == true {
		fmt.Println("enabled = ", enable)
	} else {
		fmt.Println("enabled = ", disable)
	}
	/*
	//编译时会出现以下错误：
	// cannot use 1 (type int) as type bool in assignment
	enable = 1;
	// cannot convert 1 to type bool
 	// cannot convert 1 (type int) to type bool
 	// cannot use 1 (type int) as type bool in assignment
	enable = bool(1)
	*/

	var (
		a int8 = 1
		b int  = 2
	)
	//invalid operation: a + b (mismatched types int8 and int)
	//c := a + b
	//需要做类型转换
	c := int(a) + b
	fmt.Println("c = a + b = ", c)

	//int32 与 int 是两种不同的类型，但是可用强制类型转换
	var d int32
	//d = b    // cannot use b (type int) as type int32 in assignment
	d = int32(b)
	fmt.Println("d = ", d)

	var f1 float32 = 1.23456
	fmt.Printf("f1 = %.3f \n", f1) //1.235
	f2 := 1.111
	//compile error: invalid operation: f1 + f2 (mismatched types float32 and float64
	//f3 := f1 + f2
	b1 := (float64(f1) == f2)//该比较方式不严谨
	if b1 {
		fmt.Println("float64(f1) == f2")
	} else {
		fmt.Println("float64(f1) != f2")
	}

	//用 "" 括起来表示字符串
	//字符串的操作与数组一样
	var str string = "hello"
	fmt.Println("str = ", str)
	fmt.Println("str[1] = ", str[1])
	fmt.Printf("%c \n", str[1]) // s[i]取第i+1个字符
	//str = "hi"   //compile ok
	//str[0] = 'c' //compile error: cannot assign to str[0]

	//多行字符串，用 `` 包含
	str2 := `
			SELECT username, pwd
			FROM tb_user
			WHERE id = 123456
	`
	fmt.Println(str2)

	str3 := " world!"
	fmt.Println("str + str3 = ", str + str3)  // s1 + s2, 连接字符串

	//len(s)返回字符串的长度
	fmt.Printf("length of str2 = %d \n", len(str2))

	//s[m:n] 返回从m位开始到n结束之间的字符串，m, n可以省略, 此时m为0, n为len(s)
	s := "hello"
	s = "c" + s[1:]
	fmt.Println(s)      //cello
	fmt.Println(s[:3])  //cel
	fmt.Println(s[1:3])	//el
	fmt.Println(s[:])	//cello

	//byte 用 '' 包括字符
	//var ch byte = "1" //compile error: cannot use "1" (type string) as type byte in assignment
	var ch1 byte = 'a'
	fmt.Printf("ch1 = %c \n", ch1)  //ch1 = a
	fmt.Println(ch1)                //97
	//rune
	var ch2 rune = 'b'
	fmt.Printf("ch2 = %c \n", ch2)  //ch2 = b
	fmt.Println(ch2)                //98

	//error
	err := errors.New("error1")
	if err != nil {
		//错误处理...
		fmt.Println(err)
	}

	var e1 error
	if e1 == nil {
		fmt.Println("no problem")
	}

	res, e := div(5, 0)
	//res, e := div(5, 1)
	if e != nil {
		//错误处理
		fmt.Println(e) //如果div(5, 0), 会输出: error: division by zero
	} else {
		//正确
		fmt.Println("res = ", res) //如果div(5, 1)，会输出: res = 5
	}
}
//定义函数
func div(a, b int) (res int, e error) {
	if b == 0 {
		e = errors.New("error: division by zero")
		return
	}
	return a /b , nil
}

运行结果：