本文为转载,原文:Golang 学习笔记(1)—— 基础
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
字符串。
注意
:
- 在go语言中,语句末尾的分号
;
是可以省略的 - 在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
相同,对于嵌套循环,可以用标签来指定要继续哪一层循环。
有疑问加站长微信联系(非本文作者)