以下是记录我学习Go时练习的小程序段，已经过编译通过，在此记录，以供翻阅复习
package main
import "fmt"
func main(){
var i int
var f float64
var b bool
var s string
fmt.Printf("%v %v %v %q\n",i,f,b,s);
}
//0 0 false ""
//第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误.
/*
var intVal int
intVal :=1 // 这时候会产生编译错误
intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
*/
package main
import "fmt"
func main(){
//声明一个变量并初始化
var a="RUNOOB"
fmt.Println(a)
//没有初始化就为零值
var b int
fmt.Println(b)
//bool零值为false
var c bool
fmt.Println(c)
}
/*
以上实例执行结果为：
RUNOOB
0
false
*/
package main
var x,y int
var(
a int
b bool
)
var c,d int =1,2
var e,f = 123,"hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
g,h:=456,"world"
println(x,y,a,b,c,d,e,f,g,h)
}
//以上实例执行结果为：
//0 0 0 false 1 2 123 hello 123 hello
/*
多变量声明
//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断
vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误
// 这种因式分解关键字的写法一般用于声明全局变量
var (
vname1 v_type1
vname2 v_type2
)
*/
//如果你声明了一个局部变量却没有在相同的代码块中使用它
//同样会得到编译错误.
package main
import "fmt"
func main(){
var a string="abc"
/*
fmt.Println("hello,world");
a declared and not used 一个声明没有被使用 会报错
*/
fmt.Println("helloWorld",a);
//这个a值必须被使用 输出：helloWorld abc
}
/*
全局变量是允许声明但不使用
多变量可以在同一行中进行赋值
var a, b int
var c string
a, b, c = 5, 7, "abc"
上面这行假设了变量 a，b 和 c 都已经被声明，否则的话应该这样使用：
a, b, c := 5, 7, "abc"
*/
//如果你想要交换两个变量的值，
//则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。
/*
空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
_ 实际上是一个只写变量，你不能得到它的值
这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。
*/
//空白标志符在函数返回值时的使用
package main
import "fmt"
func main(){
_,numb,strs:=numbers()//只获取函数返回值的后两个
fmt.Println(numb,strs)
}
//一个可以返回多个值的函数
func numbers()(int,int,string){
a,b,c:=1,2,"str"
return a,b,c
}
/*
输出结果：
2 str
*/
/*常量是在程序运行时不会被修改的值
常量的定义格式：
const identifier [type]=value
也可以省略说明符[type]，因为编译器可以根据变量的值来推断其类型
显示类型定义const b string="abc"
隐式类型定义const b="abc"
*/
package main
import "fmt"
func main(){
const LENGTH int =10
const WIDTH int =5
var area int
const a,b,c =1,false,"str" //多重赋值
area =LENGTH*WIDTH
fmt.Println("面积为：",area)
println()
println(a,b,c)
}
/*
常量还可以用作枚举
const (
Unknown=0
Female=1
Male=2
)
数字0，1，2分别用来代表未知性别，女性和男性。
常量可以用len(),cap(),unsafe.Sizeof()函数来计算表达式的值。常量表达式中函数必须是内置函数，否则编译不过
*/
package main
import "unsafe"
const (
a="abc"
b=len(a)
c=unsafe.Sizeof(a)
)
func main(){
println(a,b,c)
}
/*
以上实例运行结果为：
abc 3 16
*/
/*
iota:特殊常量，可以认为是一个被编译器修改的常量
iota在const关键字出现时被重置为0 （const内部的第一行之前），const中每新增一行常量声明将使iota计数一次（iota可理解为const语句块中的行索引）
iota可以用作枚举值：
const(
a = iota
b = iota
c = iota
)
第一个iota等于0，每当iota在新的一行被使用时，他的值都会自动加1；
所以a=0,b=1,c=2可以简写为如下形式：
const(
a = iota
b
c
)
*/
package main
import "fmt"
func main(){
const (
a = iota //0
b //1
c //2
d = "ha" //独立值，iota+=1
e //"ha" iota+=1
f=100 //iota +=1
g //100 iota+=1
h=iota //7,恢复计数
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i)
}
//实际运行结果
//0 1 2 ha ha 100 100 7 8
package main
import "fmt"
const(
i=1<<iota
j=3<<iota
k
l
)
const (
a=1
b
c
d // b、c、d没有初始化，使用上一行(即a)的值
)
func main(){
fmt.Println("i=",i)
fmt.Println("j=",j)
fmt.Println("k=",k)
fmt.Println("l=",l)
fmt.Println(a,b,c,d)
}
/*iota表示从0开始自动加1，所以i=1<<0,j=3<<1,k=3<<2,l=3<<3*/
/*输出结果：
i= 1
j= 6
k= 12
l= 24
1 1 1 1
*/
//算术运算符
package main
import "fmt"
func main(){
var a int = 21
var b int = 10
var c int
c=a+b
fmt.Println("第一行 -c的值为\n",c)
c=a-b
fmt.Println("第一行 -c的值为\n",c)
c=a*b
fmt.Println("第一行 -c的值为\n",c)
c=a/b
fmt.Println("第一行 -c的值为\n",c)
c=a%b
fmt.Println("第一行 -c的值为\n",c)
a++
fmt.Println("第一行 -a的值为\n",a)
a=21 //这里对a进行重新赋值为21
a--
fmt.Println("第一行 -a的值为\n",a)
}
/*
以上实例运行结果：
第一行 - c 的值为 31
第二行 - c 的值为 11
第三行 - c 的值为 210
第四行 - c 的值为 2
第五行 - c 的值为 1
第六行 - a 的值为 22
第七行 - a 的值为 20
*/