go语言基本数据类型和变量

var x int
var f float32 = 1.6
var s = "abc"

func main() {
	x := 123
	n, s := 0x1234, "Hello, World!"
	b := 123
	b := 1234 //会出现错误no new variables on left side of := 。因为在上一行已经定义过变量
	println(x, n, s, b)
}

data, i := [3]int{0, 1, 2}, 0 
i, data[i] = 2, 100 // (i = 0) -> (i = 2), (data[0] = 100) 

func test() (int, string) {
 return 1, "abc"
}
func main() {
 _, s := test()
 println(s)
}

i,j = j,i

var s string // 全局变量没问题。
func GetName() (firstName, lastName, nickName string) { 
 return "May", "Chan", "Chibi Maruko" 
} 

func main() {

//若只想获得nickName，则函数调用语句可以用如下方式编写：
 _, _, nickName := GetName() 
 i := 0 // Error: i declared and not used。(可使⽤ "_ = i" 进行占位)
}

s := "abc"
println(&s)
s, y := "hello", 20 // 重新赋值: 与前 s 在同⼀层次的代码块中，且有新的变量被定义。
println(&s, y) // 通常函数多返回值 err 会被重复使⽤。
{
 s, z := 1000, 30 // 定义新同名变量: 不在同⼀层次代码块。
 println(&s, z)
}

const x, y int = 1, 2 // 多常量初始化
const s = "Hello, World!" // 类型推断
const ( // 常量组
 a, b = 10, 100
 c bool = false
)
func main() {
 const x = "xxx" // 未使⽤局部常量不会引发编译错误。
}

const (
 s = "abc"
 x // x = "abc"
)

const (
 a = "abc"
 b = len(a)
 c = unsafe.Sizeof(b)
)

const ( // iota被重设为0
 c0 = iota // c0 == 0 
 c1 = iota // c1 == 1 
 c2 = iota // c2 == 2 
) 
const ( 
 a = 1 << iota // a == 1 (iota在每个const开头被重设为0) 
 b = 1 << iota // b == 2 
 c = 1 << iota // c == 4 
) 
const ( 
 u = iota * 42 // u == 0 
 v float64 = iota * 42 // v == 42.0 
 w = iota * 42 // w == 84 
) 
const x = iota // x == 0 (因为iota又被重设为0了) 
const y = iota // y == 0 (同上) 

const ( // iota被重设为0
 c0 = iota // c0 == 0 
 c1 // c1 == 1 
 c2 // c2 == 2 
) 
const ( 
 a = 1 <<iota // a == 1 (iota在每个const开头被重设为0) 
 b // b == 2 
 c // c == 4

const (
 Sunday = iota // 0
 Monday // 1，通常省略后续⾏表达式。
 Tuesday // 2
 Wednesday // 3
 Thursday // 4
 Friday // 5
 Saturday // 6
)

type Color int
const (
 Black Color = iota
 Red
 Blue
)
func test(c Color) {}
func main() {
 c := Black
 test(c)
 x := 1
 test(x) // Error: cannot use x (type int) as type Color in function argument
 test(1) // 常量会被编译器⾃动转换。
}

var v1 bool
v1 = true
v2 := (1 == 2) // v2也会被推导为bool类型

var b bool
b = 1 // 编译错误
b = bool(1) // 编译错误
//以下的用法才是正确的：
var b bool
b = (1!=0) // 编译正确 
fmt.Println("Result:", b) // 打印结果为Result: true 

var value2 int32
value1 := 64 // value1将会被自动推导为int类型
value2 = value1 // 编译错误

cannot use value1 (type int) as type int32 in assignment。

value2 = int32(value1) // 编译通过

5 % 3 // 结果为：2 

var fvalue1 float32
fvalue1 = 12 
fvalue2 := 12.0 // 如果不加小数点，fvalue2会被推导为整型而不是浮点型

import "math" 
// p为用户自定义的比较精度，比如0.00001 
func IsEqual(f1, f2, p float64) bool { 
 return math.Fdim(f1, f2) < p 
} 

var value1 complex64 // 由2个float32构成的复数类型
value1 = 3.2 + 12i 
value2 := 3.2 + 12i // value2是complex128类型
value3 := complex(3.2, 12) // value3结果同 value2 

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) 

str := "Hello world" // 字符串也支持声明时进行初始化的做法
str[0] = 'X' // 编译错误

str := "Hello,世界"
n := len(str) 
for i := 0; i < n; i++ { 
 ch := str[i] // 依据下标取字符串中的字符，类型为byte 
 fmt.Println(i, ch) 
} 

str := "Hello,世界"
for i, ch := range str { 
 fmt.Println(i, ch)//ch的类型为rune 
} 

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