Allbet Gaming

Go语言基础语法总结

admin 2020年07月25日 科技 36 0

1. 熟悉HelloWorld

在前面的《Go的安装和使用》这篇文章中已经写过HelloWorld.go了,现在就来逐行熟悉一下它。

package main

import "fmt"

func main() {
	fmt.Println("Hello, World!")
}

第1行:我们的Go程序是由——package组成的,包的声明形式为:package <包名>。该行的意思是:当前HelloWorld.go文件属于main包。

第2行:若是你使用过Java或Python,那你对import一定不生疏。该行的意思是:导入一个名为fmt的包。若是需要导入多个包,有两种写法:

import "fmt"
import "math"

或者使用分组形式同时导入多个包

import (
	"fmt"
	"math/rand"
)

显然第二种使用括号,以分组的形式导入加倍利便。

第3行:我们使用func关键字来声明一个函数,在这个例子中,我们声明的是main函数。若是你有过其他语言的编程履历,一定熟悉main函数的作用:程序的入口。

第4行:我们的函数内容放在函数的{}中,在该例中,挪用了fmt包中的打印方式,由此可见,Golang语言挪用函数的方式和Java、Python一样使用小数点:<包名>.<函数名>

看完这几行简朴代码,我们发现:在Go语言中,并不需要分号;来竣事语句。

2. 变量

2.1. 命名规范

Go语言要求标识符以一个字母或下划线开头,后面可以跟随便数目的字母、数字、下划线。不能使用关键字作为标识符

区分大小写,变量num和变量Num是两个变量。

2.2. 声明

Go语言的变量声明方式和其他语言(如C、Java、Python)不太一样。

好比,我们声明一个为int类型的变量a:

var a int

可以看出,Go语言声明变量的方式为:

var <变量名> <变量类型>

我们还可以同时声明多个类型相同的变量:

var <变量名1>, <变量名2>, <变量名3>, ... <变量类型>

使用分组同时声明多个类型差其余变量:

var (
	<变量名1> <变量类型1>
    <变量名2> <变量类型2>
    <变量名3> <变量类型3>
    ...
)

下面是一个详细的例子:

package main

import "fmt"

var i bool//类型在后

func main() {
	var a, b, c int//多个
	fmt.Println(i, a, b, c)
}

2.3. 初始化

当我们声明变量时,可以对其举行初始化。当有初始值时,我们可以省略变量的类型,变量会凭据对应的初始值获取准确的类型。见下例:

package main

import "fmt"

var a int = 1
var b, c bool = true, false

func main() {
	var i, j, k = 2, false, "行小观"	//省略变量类型
	fmt.Println(a, b, c, i, j, k)
    k = "行小观2号" //赋值操作
    fmt.Println(k)
}

若我们在声明变量时,不给变量赋初始值,则这些变量会被赋予“零值”。

这些零值为:

  1. 数值类型为0
  2. 布尔类型为false
  3. 字符串为""(即空字符串)

若是上例中的代码中的变量不举行初始化,即:

package main

import "fmt"

var a int
var b, c bool

func main() {
	var i int
	var j bool
	var k string
	fmt.Println(a, b, c, i, j, k)
}

则打印效果为:0 false false 0 false (变量k由于是空字符串,以是打印出来了然则看不到)

2.4. 短变量声明

前面先容了当我们声明变量时有以下几种方式:

var i int	//声明一个int变量
var i, j, k int	//同时声明多个int变量
var i int = 1	//声明一个int变量并初始化
var i, j, k int = 1, 2, 3	//同时声明多个int变量并划分初始化
var i = 1	//省略类型,声明一个int变量并初始化
var i, j, k = 1, 2, 3	//省略类型,同时声明多个int变量并划分初始化

除此之外另有一种更简练的声明变量的方式:

i := 1
i, j, k := 1, 2, 3

当我们使用:=声明变量时,不用写var也不用写类型,然则这种方式只能在函数内部使用,不能在函数外部使用。当在函数外部声明变量时,只能使用var

package main

import "fmt"

var a int = 1	//函数外部

func main() {
	var i, j int = 2, 3	//函数内部

	k := 4 //只能在函数中使用
	v1, v2, v3 := true, false, "行小观"

	fmt.Println(a, i, j, k, v1, v2, v3)
}

此外,我们声明的变量必须要使用,若是声明晰变量,然则没使用,会在编译时报错。好比:

package main

import "fmt"

func main() {
	var i bool
	var j int //声明晰,但没使用,会报错
	fmt.Println(i)
}

对于我们导入的包也有此要求,即:导入的包必须使用。

3. 数据类型

3.1. 布尔类型

布尔类型为bool,值可取truefalse,默认值为false

3.2. 字符串类型

字符串类型为string,默以为空字符串""

3.3. 数值类型

整数类型分为:

  • 有符号数:intint8int16int32 (rune)int64

  • 无符号数:uintuint8 (byte)uint16uint32uint64

其中intuint的两种类型的长度相同,取决于详细的编译器,好比在32位系统上通常为32位,在64位系统上通常为64位。

int8uint8这些类型则是Go语言直接界说好位数的类型。runebyteint32uint8的别名。

当我们需要使用整数时,应当只管使用int类型。固然,若是你有特殊的理由使用其他整数类型,便另当他论。

浮点数类型有两种:float32float64,注重没有所谓的float类型。

复数类型也有两种:complex64complex128

注重:差别类型的变量之间不能直接举行赋值或其他运算(好比加减乘除)

package main

import "fmt"

var (
	a int = 1
	b int8 = 2
	c int16
)

func main() {
	c = b	//差别类型之间举行赋值操作,[报错1]
	d := a + b	//差别类型之间举行相加运算,[报错2]
	fmt.Printf("c = %v, d = %v", c, d)
}

以上代码在编译历程中会报错:

[报错1]:cannot use b (type int8) as type int16 in assignment

[报错2]:invalid operation: a + b (mismatched types int and int8)

3.4. 类型转换

前面一节说过:差别类型的变量之间不能直接举行赋值或其他运算,以是我们可以间接地做。

好比:将int8类型转换为int类型,这样就可以间接地举行赋值和其他运算。

使用表达式T(v)将变量v的值的类型转换为T。注重是转换的是变量的值,变量自己的类型稳定。

package main

import "fmt"

var (
	a int = 1
	b int8 = 2
	c uint
	d int64
)

func main() {
	c = uint(b) //将变量b的值2的类型从int8转换为uint
	d = int64(a) + int64(b)

	fmt.Printf("c(%T):%v = b(%T):%v\n", c, c, b, b)
	fmt.Printf("a(%T):%v + b(%T):%v = d(%T):%v\n", a, a, b, b, d, d)
}

注重:Go语言中的类型转换是显示的,表达式T()是必须的,不能省略。

4. 常量

常量是牢固的值,值在程序运行时代不会改变。

常量可以界说为数值、字符串、布尔类型

常量的声明方式和变量差不多,区别在于常量需要用const关键字修饰,不能使用:=举行声明。

package main

import "fmt"

const num int = 555
var a int = 1

func main() {

	const world = "天下"
	const truth = true

	fmt.Println("Hello,", world)
	fmt.Println("num = ", num)
	fmt.Println("a = ", a)
	fmt.Println("对吗?", truth)
}

5. 初识函数

若是你之前学习过C或者Java等语言,一定已经对函数(方式)有了一定的熟悉。

简朴地来说,函数是对能完成某个功效的部门代码的抽象。当以后再需要该功效,我们只需要挪用其对用的函数即可,不必再重复编写代码。

5.1. 函数的声明

我们在前面的内容已经使用到了函数,即main()。我们使用func关键字声明函数。

func func_name() {
    
}

5.2. 函数的参数

Go语言中,函数可以有0个或多个参数。

package main

import "fmt"

func printName(name string, age int) {
	fmt.Println("我叫", name, ", 今年", age, "岁了")
}

func sayHello() {
	fmt.Println("行小观说:“你好”")
}

func main() {
	printName("行小观", 1)
	sayHello()
}

若是你有多个参数的类型相同,你可以举行简写,只需要在这几个相同的参数最后写一遍类型即可。

func foo(x int, y int, z int)
可以简写为:
func foo(x, y, x int)

5.3. 函数的类型和返回值

函数的类型在函数名之后。(尽快顺应Go的这种气概:类型在变量名后)

package main

import "fmt"

func add(x int, y int) int {
	return x + y
}

func main() {
	fmt.Println(add(1, 2))
}

当函数没有返回值时,不需要写函数的类型:

func sayHello() {//没有返回值,不写函数类型
	fmt.Println("行小观说:“你好”")
}

函数可以有0个或多个返回值

多个返回值就意味着该函数有多个返回值类型:

package main

import "fmt"

func sumAndDiff(x, y int) (int, int) { //两个返回值类型
	sum := x + y
	diff := x - y
	return sum, diff //两个返回值
}

func main() {
	a, b := sumAndDiff(5, 1)
	fmt.Println(a, b)
}

注重:和参数差别,有几个返回值就写几个返回值类型,不能简写。

Go语言还提供了另一种函数返回的方式:命名返回值。

顾名思义,我们通过给返回值举行命名,使用空return语句,这样会直接返回已命名的返回值。如上例的sumAndDiff函数可以写为:

func sumAndDiff(x, y int) (sum int, diff int) {//提前命名返回值
	sum = x + y
	diff = x - y //返回值在函数中被初始化
	return //返回值已经初始化了,不需要再在return语句中写变量了
}

下面总结一下函数的使用:

func functionName(input1, input11 type1, input2 type2 ...) (type1, type11, type2 ...){
    
    //函数体
    
    return value1, value11, value2 ...
}

或者命名返回值

func functionName(input1, input11 type1, input2 type2 ...) (output1 type1, output11 type11, output2 type2 ...){
    
    //函数体
    output1 = ...
    output11 = ...
    output2 =  ...
    ...
    return
}

6. 导着名

前面我们已经使用了import导入功效,好比improt "fmt",该行代码可以让我们在本包中使用其他包里的函数。

那么我们若何让其他包能够使用到本包的方式或变量呢?谜底是:将方式或变量导出

在Go语言中,若是一个名字以大写字母开头,那么它就是已导出的,这意味着其余包可以使用它。(相当于Java中的public的作用)

好比我们常用的打印函数fmt.Println(...),可以看到Println()的首字母是大写的,以是我们能够导入fmt包后使用该方式。

7. 流程控制语句

7.1. if语句

if语句是条件判断语句,用来判断是否知足某种条件,若是知足,则执行某段代码;若是不知足,则不执行。

if ... {
    //代码
} else if ... {
    //代码
} else {
    //代码
}

注重花样:条件判断语句不需要使用小括号()

下面是几个例子:

if a > 0 {//若是知足a>0,则打印Hello, World
    fmt.Println("Hello, World")
}
if a > 0 {//若是知足a>0,则打印 Hello, World
    fmt.Println("Hello, World!")
} else {//否则(即不知足a>0),则打印 你好,天下!
    fmt.Println("你好,天下!")
}
if a > 5 {//若是知足a>5,则打印 Hello, World
    fmt.Println("Hello, World!")
} else if a <= 5 && a > 0 {//若是知足0<a<=5,则打印 好好学习,天天向上
    fmt.Println("好好学习,天天向上")
} else {//否则(即上面的条件都不知足),则打印 你好,天下!
    fmt.Println("你好,天下!")
}

Go语言的if语句有一个特征:可以在条件表达式前执行一个简朴的语句。下面是一个例子:

package main

import "fmt"

func sum(x, y int) int {
	return x + y
}

func main ()  {
	if i := sum(1, 2); i > 0 {
		fmt.Println("Hello, World!")//作用域内,能打印i
	}
    //fmt.Println(i)//作用域外,不能打印i
}

在if语句中,使用sum(x, y int)函数盘算出i的值,再举行判断。注重:变量i的作用域只在if语句中有用。

7.2. for语句

for语句是Go语言中的循环控制语句。它有几种形式:

(一)基本形式:

for 初始化语句; 条件表达式; 后置语句 {
    //循环体代码
}
  • 初始化语句:在第一次循环前之前,且只执行这一次
  • 条件表达式:每次循环都市盘算该表达式,若是知足(值为true)则继续循环;若是不知足(值为false),则跳出循环
  • 后置语句:每次循环执行完都市执行该语句

下面是一个例子,循环打印5次"Hello,World!"

for i := 0; i < 5; i++ {
    fmt.Println("Hello, World!", i)
}

注重该例的初始化语句i := 0是一个短变量声明,变量i只在该for循环中生效。

(二)省略形式:

for循环中的初始化语句和后置语句是可以省略的。

i := 0
for ; i < 5; i++ {
    fmt.Println("Hello, World!", i)
}
i := 0
for ; i < 5; {
    fmt.Println("Hello, World!", i)
    i++
}

从某种意义上来讲,上面两个例子并没有省略初始化语句或后置语句,只是改变了位置。

(三)while形式

诸如C、Java等语言中都有while循环,然则Go语言中没有while循环,然则我们可以使用for循环来实现“while循环”。

实在(二)省略形式中的第二个for循环例子就已经可以看做是while循环了。我们再稍做改善:

i := 0
for i < 5 {//去掉两个分号,只写条件表达式
    fmt.Println("Hello, World!", i)
    i++
}

(四)无限循环形式

//打印无限多个Hello, World!
for  {
    fmt.Println("Hello, World!")
}

7.3. break和continue

上面提到的循环语句只有当条件表达式的值为false时,才会住手循环。但现实开发中,我们可能在条件表达式的值为true的情形下,需要退出循环。这种时刻,就需要使用breakcontinue语句。

break语句用来跳出当前循环,continue语句用来跳过本次循环。

下面是两个实例(改善上面循环打印5次"Hello,World!"的例子):

实例1:增添需求,当打印完第2遍Hello,World!时,住手打印

for i := 0; i < 5; i++ {
    if i == 2 {
        break
    }
    fmt.Println("Hello, World!", i)
}

实例2:增添需求,不打印第3遍Hello,World!

for i := 0; i < 5; i++ {
    if i == 2 {
        continue
    }
    fmt.Println("Hello, World!", i)
}

7.4. switch语句

我们可以使用if...else if...else if...举行一连串的条件判断,然则这样过于繁杂。switch语句就是用来简化这个问题的。

switch 变量 {
    case 选项1 :
    	//操作1代码
    case 选项2 :
    	//操作2代码
    case 选项3 :
    	//操作3代码
    case 选项n:
    	//操作n代码
	default :
    	//默认操作
}

switch语句中有许多case和一个default,只有当变量和case的选项相匹配时,才会执行对应的操作代码。若是没有case的选项可以匹配,则默认执行default的代码。

下面是一个例子:

package main

import "fmt"

func sum(x, y int) int {
	return x + y
}

func main ()  {
    result := sum(3, 2)
	switch result {
	case 1 :
		fmt.Println("效果为1")
	case 2, 3, 4:	//多种情形聚合在一起
		fmt.Println("效果为2或3或4")
	case sum(1, 4):	//支持表达式
		fmt.Println("效果为5")
	default:
		fmt.Println("其他效果")
	}
}

从上面的例子可以看出,Go语言中switch的case支持常量(不必为整数)、表达式、多个值聚合。注重:不论是常量、表达式,照样多个值聚合,都要保证常量、表达式的值、多个值的类型和switch的变量相同。

switch语句的匹配顺序是自上到下。Go语言自动为每个case提供了break语句,以是在众多选项中只能执行1个casedefault,然后竣事,剩余的不再执行。

然则可以使用fallthrough强制执行剩余的case:

result := sum(1, 1)
switch result {
    case 1 :
    fmt.Println("效果为1")
    fallthrough
    case 2, 3, 4:
    fmt.Println("效果为2或3或4")
    fallthrough
    case sum(1, 4):
    fmt.Println("效果为5")
    fallthrough
    default:
    fmt.Println("其他效果")
}

照样上面的谁人例子,然则在每个case中使用fallthrough,现在的打印效果为:

效果为2或3或4
效果为5
其他效果

若有错误,还请指正。

文章首发于民众号『行人观学』

,

欧博客户端

欢迎进入欧博客户端(Allbet Game):www.aLLbetgame.us,欧博官网是欧博集团的官方网站。欧博官网开放Allbet注册、Allbe代理、Allbet电脑客户端、Allbet手机版下载等业务。

Allbet Gaming声明:该文看法仅代表作者自己,与阳光在线无关。转载请注明:Go语言基础语法总结
发布评论

分享到:

allbet:入住新家1年,卫生间越用越舒心,全靠妻子的6个小决议
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。