Golang 学习笔记（01）—— 基础

##Golang介绍
Go语言是由Google开发的一个开源项目，目的之一为了提高开发人员的开发效率。Go语言语法灵活、简洁、清晰、高效。它的并发特性可以方便地用于多核处理器和网络开发，同时灵活新颖的类型系统可以方便地编写模块化的系统。go可以快速编译，同时具有垃圾内存自动回收功能，并且还支持运行时反射。Go是一个高效、静态类型，但是又具有解释语言的动态类型特征的系统级语法。

##语言基础
###第一个go程序
我们学习每一门语言都少不了一个hello world的开始。现在我们就献上我们的第一个程序

package main
import "fmt"
func main(){
    fmt.Println("hello world")
}

运行结果如我们所料：

####代码解释
第一行，package定义了程序包main。第二行，引入了fmt包，func main()定义了main函数，func是定义函数的关键字，在main函数中调用了fmt包中的Println方法输出hello world字符串。

注意：

1. 在go语言中，语句末尾的分号;是可以省略的
2. 在go语言中，代码片段的起始花括号{不能换行，否则程序报错。

基本类型

类型	长度（字节）	说明
bool	1	true, false。 不能把非零值当做true
byte	1	uint8 别名
rune	4	int32 别名。代表一个Unicode字符
int/uint	4	依据所运行的平台，可能是32bit或64bit。
int8/uint8	1	1-128 ~ 127; 0 ~ 255
int16/uint16	2	-32768 ~ 32767; 0 ~ 65535
int32/uint32	4	-21亿 ~ 21亿；0 ~ 42亿
complex64	8	复数类型，即32位实数+32位虚数
complex128	16	复数类型，即64位实数+64位虚数
uintptr		能够保存指针的32位或64位整数
array		数组，值类型，如：[2]int
struct		结构体，值类型
string		值类型
slice		引用类型，如：[]int
map		引用类型
channel		引用类型
Interface		接口类型
function		函数类型

###定义变量

package main import "fmt" func main(){ var b bool //定义指定类型的变量 var n int //定义指定类型的变量 var i int = 3 //定义指定类型的变量，并赋予默认值 var( //多变量的定义 aa int = 4 str string ) var i1,i2,i3 int = 1,2,3 //多个同类型的变量定义，并赋值 var strName = "bob" //go会自动检测变量的类型 strSex := "male" //:=定义变量，并给变量赋值，可省略var关键字 fmt.Println("n = ", n) fmt.Println("i = ", i) fmt.Println("b = ", b) fmt.Println("aa = ", aa) fmt.Println("str = ", str) fmt.Println("i1 = ", i1, "i2 = ", i2, "i3 = ", i3) fmt.Println("strName = ", strName) fmt.Println("strSex = ", strSex) }

编译运行：

你会发现，b=false, n=0, str=; 对于未赋值的变量，Go会自动初始化，数值类型为0，布尔类型为false，字符串类型为空。

注意：
在Go语言中定义了未使用的变量，编译会报错；引入未使用的包编译也会报错。

###常量
常量必须是编译期能确定的，常量的定义使用const，常量的类型可以是char, string, bool和数字常量。因为编译态的限制，定义他们的表达式必须是常量表达式，可以被编译器求值。例如，1<<3是常量表达式，math.Sin(math.Pi/4)不是， 因为math.Sin的函数调用发生在运行态。

常量的定义与变量类似，只是关键字变成了const：

const PI = 3.1415926535
const msg = "hello"
const(
	z = false
	a = 123
)
const x, y = "xxxx", "yyyy"

go语言中没有枚举类型，可以用常量模拟。可以用iota生成从0开始的自动增长的枚举值。按行递增，可以省略后续行的iota关键字。

const(
    Sunday = iota      //0
	Monday             //1
	TuesDay            //2
)

也可以在同一行使用多个iota，他们各自增长

const(
	U, V = iota, iota  //U=0,V=0
	W, X               //W=1,X=1
	Y, Z               //Y=2,Z=2
)

如果某行不想递增，可单独提供初始值。不过想要恢复递增，必须再次使用iota

const(
	A1 = iota //0
	A2        //1
	str = "hello"  //hello
	s              //没有赋值，跟上一行一样
	A3 = iota  //恢复递增，值为4
	A4         //5
)

##流程控制

if else

go的if与C和java中的是相似的，区别在于没有小括号

func main(){
	a := 2
	if a==2{
		fmt.Println("a=2")
	}
}

在if和条件之间可以包括一些初始表达式，以上代码可以写成：

func main(){
	if a := 2; a==2{
		fmt.Println("a=2")
	}
}

但是请记住，if和条件之间只能有一个初始化表达式，否则会编译报错。

Switch

go的switch非常灵活，表达式不必是常量或整数，执行的过程从上到下，直到找到匹配项；而如果switch没有表达式，他会匹配true。
go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch，但是可以使用fallthrough强制执行后面的case代码，fallthrough相当于去掉了case后面默认的break。

func main(){
	i := 5
	switch i{
		case 1:
			fmt.Println("i is equal to 1")
		case 2:
			fmt.Println("i is equal to 2")
		case 3,4,5,6:
			fmt.Println("i is equal to 3,4,5 or 6")
		default:
			fmt.Println("others")
	}
}

结果如下：

如果在最后一个case后面加上fallthrough

func main(){
	i := 5
	switch i{
		case 1:
			fmt.Println("i is equal to 1")
		case 2:
			fmt.Println("i is equal to 2")
		case 3,4,5,6:
			fmt.Println("i is equal to 3,4,5 or 6")
			fallthrough
		default:
			fmt.Println("others")
	}
}

结果如下，依然执行了defaul内的代码：

不指定switch条件表达式，或直接为true时，可以替代if...else if...else...，如：

func main(){
	i := 5
	switch {
		case i < 0:
			fmt.Println("小于零")
		case i > 0:
			fmt.Println("大于零")
		default:
			fmt.Println("等于零")
	}
}

结果：

for

go只有一个关键字用于引入循环。但它提供了除do-while外C语言当中所以可用的循环方式。
go的for循环有如下三种形式：

for init; condition; post{} //和C的for一样
for condition{}             //和while一样
for{}                       //死循环

如：

func main(){
	str := "Chain"
	for i, j := 0, len(str); i < j; i++{
		fmt.Println(string(str[i]))
	}
}

运行结果：

使用break可以提前终止当前循环，嵌套循环时，可以在break后面指定能够标签，用来终止指定的循环，如：

func main(){
	oute:
		for i := 0; i < 5; i ++{
			for j := 0; j < 3; j++{
				if(i > 2){
					break oute
				}
				fmt.Println("i=",i,"j=", j)
			}
		}
}

结果：

continue用于终止本次循环体的执行，继续下一个循环，与breck相同，对于嵌套循环，可以用标签来指定要继续哪一层循环。

转载于:https://my.oschina.net/u/921799/blog/3045741