Golang_2_类型

x := 10

var x = 100

func main(){
    fmt.Println(&x, x) // 全局变量

	x := "abc"
	fmt.Println(&x, x) // 重新定义和初始化同名的局部变量
}

func main(){
    x := 123
	fmt.Println(&x, x)

	x, y := 200, "abc" // 同域 + 新变量被定义
    // x := 200 会报错，因为没有新变量被定义
	fmt.Println(&x, y)
    
    // 重新定义，括号内是另外一个域
    //{
    //    x := 200
    //}
}

func main() {
	x, y := 1, 2
	x, y = y+3, x+2
	fmt.Println(x, y)
}

	var c int // count 用 c 代替
	for i := 0; i < 10; i++ { // index 用 i 代替
		c++
	}
	fmt.Println(c)

x, _ := strconv.Atoi("12")
fmt.Println(x)

const x, y int = 123, 0x32
const s = "hello world"
const c = '我'

const (
	i, f = 1, 0.123
	b = false
)

x int = -999

n 	= uint8(x) // -999超过uint8范围

const (
    x uint16 = 120
    y
    s = "abc"
    z
)
fmt.Printf("%T %v\n", y, y)
// 输出 uint16 和 120
fmt.Printf("%T %v\n", z, z)
// 输出 string 和 abc

const (
		x = iota 	// 0
		y		 	// 1
		z			// 2
)

const (
    _ = iota // 0
    KB = 1 << (10 *iota)	// 1 << (10 * 1)
    MB						// 1 << (10 * 2)
    GB						// 1 << (1 * 3)
)

const (
    _, _ = iota, iota*10	// 0, 0*10
    a, b					// 1, 1*10
    c, d					// 2, 2*10
)

const (
    a = iota	// 0
    b			// 1
    c = 100		// 100
    d			// 100 默认和上值相同
    e = iota	// 4 根据行自增，而不是从2开始
    f			// 5
)

const (
    a = iota			// int
    b = iota			// int
    c float32 = iota	// float 32
    d = iota			// int 不显式指定，则还是默认int
)
fmt.Printf("%v %v %v %v\n", a, b, c, d)
fmt.Printf("%T %T %T %T", a, b, c, d)
// 0 1 2 3
// int int float32 int

type color byte

const (
	black color = iota
	red
	blue
)

func test(c color)  {
	println(c)
}

func main() {
	test(red)
	test(100)
	
	x := 2
	test(x) // 错误：不能使用int类型作为test的函数类型
}

var x = 0x100
const y = 0x200

func main() {
	fmt.Println(&x, x)	
	fmt.Println(&y, y)	 // 报错，can't take the adress of y
}

func main() {
	 a, b, c := 100, 0144, 0x64
	 fmt.Println(a, b, c) // 默认按照十进制输出， 100 100 100
	 fmt.Printf("0b%b, %#o, %#x\n", a, a, a) // 二进制、八进制、十六进制  
    // 0b1100100, 0144, 0x64
	 fmt.Println(math.MinInt8, math.MaxInt8) // -128 和 127
}

func main() {
    a, _ := strconv.ParseInt("1100100", 2, 32)
    b, _ := strconv.ParseInt("0114", 8, 32)
    c, _ := strconv.ParseInt("64", 16, 32)
    fmt.Println(a, b, c) // 输出100 76 100

    fmt.Println("0b"+strconv.FormatInt(a, 2)) // 0b1100100
    fmt.Println("0"+strconv.FormatInt(a, 8)) // 0144
    fmt.Println("0x"+strconv.FormatInt(a, 16)) // 0x64
}

byte	alias for unit8
rune	alias for int32

func test(x byte){
	fmt.Println(x)
}

func main() {
	var a byte = 0x11
	var b uint8 = a
	var c uint8 = a + b
	
	test(c)
}

func add(x, y int) int {
	return x + y;
}

func main() {
	var x int = 100
	var y int64 = x // 错误 cannot use x (type int) as type int64 in assignment
    add(x, y) // 错误 use y (type int64) as type int in argument to add
}

package main

import "fmt"

func mkslice() []int {
	s := make([]int, 0, 10)
	s = append(s, 100)
	return s
}

func mkmap() map[string]int {
	m := make(map[string]int)
	m["a"] = 1
	return m
}

func main(){
	m := mkmap()
	fmt.Println(m["a"])

	s := mkslice()
	fmt.Println(s[0])
}

func main(){
    p := new(map[string]int)
    m := *p
    m["a"] = 1
    fmt.Println(m) // 运行期错误
}

a := 10
b := byte(a)
c := a + int(b) // 混合类型表达式要求类型一致

(*int)(p) // *(int(p))

type flags byte

const (
	read flags = 1 << iota
	write
	exec
)

func main(){
	f := read | exec
	fmt.Printf("%b\n", f) // 输出 101
}

package main

import "fmt"

func main(){
	type (
		user struct {
			name string
			age uint8
		}
		event func(string) bool
	) 
	
	// 使用结构体类型
	u := user{"Tom", 20}
	fmt.Println(u)
	
	// 使用结构体内方法
	var f event = func(s string) bool {
		fmt.Println(s)
		return s != ""
	}
	
	f("abc")
}

type data int
var d data = 10

var x int = d // 出错，两种类型

fmt.Println(d == x) // 出错，两种类型不能进行比较