Go 语言基础语法

Go 语言基础语法

1.字符串连接

Go 语言的字符串可以通过 + 实现：

实例

package main

import "fmt"

func main() {

fmt.Println("Google" + "Runoob")

}

以上实例输出结果为：

GoogleRunoob

Go 语言的空格

Go 语言中变量的声明必须使用空格隔开，如：

var age int;

语句中适当使用空格能让程序更易阅读。

无空格：

fruit=apples+oranges;

在变量与运算符间加入空格，程序看起来更加美观，如：

fruit = apples + oranges;

Go语言数据类型

布尔型

布尔型的值只可以是常量 true 或者 false。一个简单的例子：

var b bool = true

Go 语言变量

var indentifier type

可以一次声明多个变量

var identifier1 , identifier2 type

例子

fun main(){

　　var a string = "runoob"

　　fmt.Println(a)

　　var b,c int = 1,2

　　fmt.println(b,c)

}

实际输出

Runoob 1 2

变量声明

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

实例

package main

import "fmt"

func main() {

// 声明一个变量并初始化

var a = "RUNOOB"

fmt.Println(a)

// 没有初始化就为零值

var b int

fmt.Println(b)

// bool 零值为 false

var c bool

fmt.Println(c)

}

第二种，根据值自行判定变量类型。

实例

package main

import "fmt"

func main() {

var d = true

fmt.Println(d)

}

如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：

如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：

实例

package main

import "fmt"

func main() {

var a string = "abc"

fmt.Println("hello, world")

}

尝试编译这段代码将得到错误 a declared and not used。

此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用

fmt.Println("hello, world", a)

Go 语言常量

• 显式类型定义： const b string = "abc"
• 隐式类型定义： const b = "abc"

多个相同类型的声明可以简写为

const c_name1, c_name2 = value1, value2

以下实例演示了常量的应用：

实例

package main

import "fmt"

func main() {

const LENGTH int = 10

const WIDTH int = 5

var area int

const a, b, c = 1, false, "str" //多重赋值

area = LENGTH * WIDTH

fmt.Printf("面积为 : %d", area)

println()

println(a, b, c)

}

常量还可以用作枚举：

const(

　　Unknown = 0

　　Female = 1

　　Male =2

)

数字 0、1 和 2 分别代表未知性别、女性和男性。

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过

实例

package main

import "unsafe"

const (

　　a = "123"

　　b = len(a)

　　c =unsafe.Sizeof(a)

)

func main(){

println(a, b, c)

}

以上实例运行结果为：

abc 3 16

Go 语言运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

以下实例演示了各个算术运算符的用法：

fun main(){

　　var a int = 21

　　var b int = 10

　　var c int

　　c = a + b

fmt.Printf("第一行 - c 的值为 %d\n", c )

c = a - b

fmt.Printf("第二行 - c 的值为 %d\n", c )

c = a * b

fmt.Printf("第三行 - c 的值为 %d\n", c )

c = a / b

fmt.Printf("第四行 - c 的值为 %d\n", c )

c = a % b

fmt.Printf("第五行 - c 的值为 %d\n", c )

a++

fmt.Printf("第六行 - a 的值为 %d\n", a )

a=21 // 为了方便测试，a 这里重新赋值为 21

a--

fmt.Printf("第七行 - a 的值为 %d\n", a )

}

Go 语言条件语句

if 语句

func main(){

　　var a int = 10

　　if a < 20{

　　fmt.Printf("a小于 20\n")

}

}

//注意， 和java的区别，一般情况下，Go不要加如（）

Go 语言循环语句

Go 语言 for 循环

Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

1.

for init; condition; post { }

2.

for condition { }
3.

for { }

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下





for key, value := range oldMap {

    newMap[key] = value
}


实际例子


计算 1 到 10 的数字之和：


package main


import "fmt"


func main() {


        sum := 0


        for i := 0; i <= 10; i++ {


                sum += i


        }


        fmt.Println(sum)


}

init 和 post 参数是可选的，我们可以直接省略它，类似 While 语句。

以下实例在 sum 小于 10 的时候计算 sum 自相加后的值：

package main

import "fmt"

func main() {

sum := 1

for ; sum <= 10; {

sum += sum

}

fmt.Println(sum)

// 这样写也可以，更像 While 语句形式

for sum <= 10{

sum += sum

}

fmt.Println(sum)

}

无限循环:

package main

import "fmt"

func main() {

sum := 0

for {

sum++ // 无限循环下去

}

fmt.Println(sum) // 无法输出

}

For-each range 循环

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

package main

import "fmt"

func main() {

strings := []string{"google", "runoob"}

for i, s := range strings {

fmt.Println(i, s)

}

numbers := [6]int{1, 2, 3, 5}

for i,x:= range numbers {

fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)

}

}

以上实例运行输出结果为:

0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

Go 语言函数

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。

函数定义

Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}
例子


以下实例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值


code


func max(a ,b int) int{


var result int


if (num1>num2){


result = num1


}


}

函数调用

函数返回多个值

package main

import "fmt"

func swap(x, y string) (string, string) {

return y, x

}

func main() {

a, b := swap("Google", "Runoob")

fmt.Println(a, b)

}

Go 语言变量作用域

• 函数内定义的变量称为局部变量
• 函数外定义的变量称为全局变量
• 函数定义中的变量称为形式参数

/* 函数定义-两数相加 */


func sum(a, b int) int {


   fmt.Printf("sum() 函数中 a = %d\n",  a);


   fmt.Printf("sum() 函数中 b = %d\n",  b);


   return a + b;


}

main()函数中 a = 10
sum() 函数中 a = 10
sum() 函数中 b = 20
main()函数中 c = 30

初始化局部和全局变量

Go 语言数组

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

实例


package main


import "fmt"


func main() {


   var n [10]int /* n 是一个长度为 10 的数组 */


   var i,j int


   /* 为数组 n 初始化元素 */        


   for i = 0; i < 10; i++ {


      n[i] = i + 100 /* 设置元素为 i + 100 */


   }


   /* 输出每个数组元素的值 */


   for j = 0; j < 10; j++ {


      fmt.Printf("Element[%d] = %d\n", j, n[j] )


   }


}