【Go语言教程】(四)基本语法

 

一、GO 语言结构

package main 
//定义了包名, 必须在源文件中非注释的第一行指明这个文件属于哪个包
//package main表示一个可独立执行的程序,每个 Go 应用程序都包含一个名为 main 的包 

import "fmt" 
//使用 fmt 包(的函数,或其他元素),fmt 包实现了格式化 IO(输入/输出)的函数

func main() { 
//程序开始执行的函数。main 函数是每一个可执行程序所必须包含的
   fmt.Println("Hello World!") //将字符串输出到控制台, 
}


二、Go 语言数据类型

序号类型描述
1uint8无符号 8 位整型 (0 到 255)
2uint16无符号 16 位整型 (0 到 65535)
3uint32无符号 32 位整型 (0 到 4294967295)
4uint64无符号 64 位整型 (0 到 18446744073709551615)
5int8有符号 8 位整型 (-128 到 127)
6int16有符号 16 位整型 (-32768 到 32767)
7int32有符号 32 位整型 (-2147483648 到 2147483647)
8int64有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
1float32IEEE-754 32位浮点型数
2float64IEEE-754 64位浮点型数
3complex6432 位实数和虚数
4complex12864 位实数和虚数
1byte类似 uint8
2rune类似 int32
3uint32 或 64 位
4int与 uint 一样大小
5uintptr无符号整型,用于存放一个指针

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

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值