【Go语言教程】（四）基本语法

 

一、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  变量名  变量类型

 

var identifier type

 

第一种，指定变量类型，声明后若不赋值，使用默认值。

• 整形如int8、byte、int16、uint、uintprt等，默认值为0
• 浮点类型如float32、float64，默认值为0
• 布尔类型bool的默认值为false
• 复数类型如complex64、complex128，默认值为0+0i
• 字符串string的默认值为""
• 错误类型error的默认值为nil
• 对于一些复合类型，如指针、切片、字典、通道、接口，默认值为nil。而数组的默认值要根据其数据类型来确定。例如：var a [4]int，其默认值为[0 0 0 0]

var num int

//即默认 num = 0

或者：
var num int=100

 

第二种，根据值自行判定变量类型（编译器右值推导变量）

将int省略后，编译器会尝试根据符号右边的表达式推导num变量类型

var num = 100

 

第三种，省略var （推导声明写法）

注1   :=左侧的变量不应该是已经声明过的，否则会导致编译错误。

var num int = 100
即：
var num = 100
即：
num := 100

注2： 在多个短变量声明和赋值中，至少有一个新声明的变量出现在左值中，即便其他变量名可能是重复声明的，编译器也不会报错

package main

func main(){
	a,b:=10,20
	a,c:=30,40
        println(a,b,c)
}

//编译器不会报a重复定义

输出：

30 20 40

实例

package main
var a int
var b float32
var c bool
var d string
var e string = "csdn.com"
var f *int

func main(){
    println(a, b, c, d, e ,f)
}

 输出：

注：（false后面输出了一个空字符串）

0 +0.000000e+000 false  csdn.com 0x0

 

多变量声明实例

package main

var x, y int

var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"



func main(){
    g, h := 123, "hello"//这种不带声明格式的只能在函数体中出现
    println(x, y, a, b, c, d, e, f, g, h)
}

输出：

 

0 0 0 false 1 2 123 hello 123 hello

 

赋值使用技巧

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  特殊常量

1、iota是golang语言的常量计数器,只能在常量的表达式中使用。

例如：

fmt.Println(iota)  
编译错误： undefined: iota

2、iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

3、使用iota能简化定义，在定义枚举时很有用。

4、我们可以使用下划线“_”跳过不想要的值

5、在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。

 

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "我是字符串"   //独立值，iota += 1
            e          //"我是字符串"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
	    _          //8 跳过值
	    _          //9 跳过值
	    i          //10
	    j          //11 
     )
    fmt.Println(a,b,c,d,e,f,g,h,i,j)
}

运行结果：

0 1 2 我是字符串 我是字符串 100 100 7 10 11

6、定义在一行的情况

package main

import "fmt"

func main() {
	const (
		a, b = iota + 1, iota + 2
		c, d
		e, f
	)

fmt.Println(a,b,c,d,e,f)

}

//iota 在下一行增长，而不是立即取得它的引用

输出：1 2 2 3 3 4

7、位掩码表达式

这个工作是因为当你在一个 const 组中仅仅有一个标示符在一行的时候，它将使用增长的 iota 取得前面的表达式并且再运用它。在 Go 语言的 spec 中， 这就是所谓的隐性重复最后一个非空的表达式列表。

如果你对鸡蛋，巧克力和海鲜过敏，把这些 bits 翻转到 “on” 的位置（从左到右映射 bits）。然后你将得到一个 bit 值 00010011，它对应十进制的 19。

package main

import "fmt"
type Allergen int

func main() {
const ( 
    IgEggs Allergen = 1 << iota         // 1 << 0 which is 00000001 
    IgChocolate                         // 1 << 1 which is 00000010 
    IgNuts                              // 1 << 2 which is 00000100 
    IgStrawberries                      // 1 << 3 which is 00001000 
    IgShellfish                         // 1 << 4 which is 00010000 
)

fmt.Println(IgEggs | IgChocolate | IgShellfish)

}


输出：
19

 

五、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())
}