GO 语言结构
package main
//定义了包名, 必须在源文件中非注释的第一行指明这个文件属于哪个包
//package main表示一个可独立执行的程序,每个 Go 应用程序都包含一个名为 main 的包
import "fmt"
//使用 fmt 包(的函数,或其他元素),fmt 包实现了格式化 IO(输入/输出)的函数
func main() {
//程序开始执行的函数。main 函数是每一个可执行程序所必须包含的
/* 这是我的第一个简单的程序 */
fmt.Println("Hello, World!") //将字符串输出到控制台,
}
Go 语言数据类型
序号 | 类型 | 描述 |
---|---|---|
1 | uint8 | 无符号 8 位整型 (0 到 255) |
2 | uint16 | 无符号 16 位整型 (0 到 65535) |
3 | uint32 | 无符号 32 位整型 (0 到 4294967295) |
4 | uint64 | 无符号 64 位整型 (0 到 18446744073709551615) |
5 | int8 | 有符号 8 位整型 (-128 到 127) |
6 | int16 | 有符号 16 位整型 (-32768 到 32767) |
7 | int32 | 有符号 32 位整型 (-2147483648 到 2147483647) |
8 | int64 | 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) |
1 | float32 | IEEE-754 32位浮点型数 |
2 | float64 | IEEE-754 64位浮点型数 |
3 | complex64 | 32 位实数和虚数 |
4 | complex128 | 64 位实数和虚数 |
1 | byte | 类似 uint8 |
2 | rune | 类似 int32 |
3 | uint | 32 或 64 位 |
4 | int | 与 uint 一样大小 |
5 | uintptr | 无符号整型,用于存放一个指针 |
Go 语言变量
声明变量的一般形式是使用 var 关键字:
var identifier type
第一种,指定变量类型,声明后若不赋值,使用默认值。
var v_name v_type
v_name = value
第二种,根据值自行判定变量类型。
var v_name = value
第三种,省略var, 注意 :=左侧的变量不应该是已经声明过的,否则会导致编译错误。
v_name := value
// 例如
var a int = 10
var b = 10
c := 10
实例
package main
var a = "菜鸟教程"
var b string = "runoob.com"
var c bool
func main(){
println(a, b, c)
}
多变量声明实例
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 := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
}
赋值使用技巧
1. 同一类型的多个变量可以声明在同一行
var a, b, c int
2. 多变量可以在同一行进行赋值
var a, b int
var c string
a, b, c = 5, 7, "abc"
3.假设了变量 a,b 和 c 都已经被声明,否则的话应该这样使用
a, b, c := 5, 7, "abc"
4.交换两个变量的值
a, b = b, a
空白标识符 _ 也被用于抛弃值,如值 5 在:_, b = 5, 7 中被抛弃
5.一个函数返回多个返回值
val, err = Func1(var1)。
GO语言常量
常量是一个简单值的标识符,在程序运行时,不会被修改的量。
常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型。
常量的定义格式
常量的定义格式:
const identifier [type] = value
显式类型定义: const b string = "abc"
隐式类型定义: const b = "abc"
const c_name1, c_name2 = value1, value2
常量还可以用作枚举:
const (
Unknown = 0
Female = 1
Male = 2
)
iota 特殊常量
在每一个const关键字出现时,被重置为0,然后再下一个const出现之前,每出现一次iota,其所代表的数字会自动增加1。
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
感觉很奇怪```
Go 语言运算符
同C语言完全一致。
http://www.runoob.com/go/go-operators.html
条件语句
语句 | 描述 |
---|---|
if 语句 | if 语句 由一个布尔表达式后紧跟一个或多个语句组成。 |
if…else 语句 | if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。 |
if 嵌套语句 | 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。 |
switch 语句 | switch 语句用于基于不同条件执行不同动作。 |
select 语句 | select 语句类似于 switch 语句,但是select会随机执行一个可运行的case。如果没有case可运行,它将阻塞,直到有case可运行。 |
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* 使用 if 语句判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n" )
}
fmt.Printf("a 的值为 : %d\n", a)
}
循环语句
语句 | 描述 |
---|---|
for 循环 | 重复执行语句块 |
循环嵌套 | 在 for 循环中嵌套一个或多个 for 循环 |
break 语句 | 经常用于中断当前 for 循环或跳出 switch 语句 |
continue 语句 | 跳过当前循环的剩余语句,然后继续进行下一轮循环。 |
goto 语句 | 将控制转移到被标记的语句。 |
实例:
package main
import "fmt"
func main() {
var b int = 15
var a int
numbers := [6]int{1, 2, 3, 5}
/* for 循环 */
for a := 0; a < 10; a++ {
fmt.Printf("a 的值为: %d\n", a)
}
for a < b {
a++
fmt.Printf("a 的值为: %d\n", a)
}
for i,x:= range numbers {
fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
}
GO语言函数
func function_name( [parameter list] ) [return_types] {
函数体
}
函数定义解析:
func:函数由 func 开始声明
function_name:函数名称,函数名和参数列表一起构成了函数签名。
parameter list:参数列表,参数就像一个占位符,当函数被调用时,你可以将值传递给参数,这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的,也就是说函数也可以不包含参数。
return_types:返回类型,函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值,这种情况下 return_types 不是必须的。
函数体:函数定义的代码集合。
/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
/* 声明局部变量 */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
函数返回多个值
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}
Go 语言函数闭包
Go 语言支持匿名函数,可作为闭包。匿名函数是一个”内联”语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量,不必申明。
package main
import "fmt"
func getSequence() func() int {
i:=0
return func() int {
i+=1
return i
}
}
func main(){
/* nextNumber 为一个函数,函数 i 为 0 */
nextNumber := getSequence()
/* 调用 nextNumber 函数,i 变量自增 1 并返回 */
fmt.Println(nextNumber())
fmt.Println(nextNumber())
fmt.Println(nextNumber())
/* 创建新的函数 nextNumber1,并查看结果 */
nextNumber1 := getSequence()
fmt.Println(nextNumber1())
fmt.Println(nextNumber1())
}
1
2
3
1
2