目录
Go语言基础语法
1,Go标记
Go程序可以由多个标记组成,可以是关键字,标识符,常量,字符串,符号。如以下GO语句由6个标记组成:
1. frat 3. Printin 4. ( 5. "Hel1o, World!" 6. )
2,行分割符
在Go程序中,- 行代表-个语句结束。 每个语句不需要像C家族中的其它语言一样以分号;结尾,因为这些工作都将由Go编译器自动完成。 如果你打算将多个语句写在同一行,它们则必须使用;人为区分,但在实际开发中我们并不鼓励这种做法。 以下为两个语句:
fmt.Print1n("He11o, Wor1d! ") fmt.Print1n("你好: nihao.com")
package main import "fmt" func main() { fmt.Println("hello") fmt.Println("world")//分行写后面不需要加分号 } [Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go" hello world
package main import "fmt" func main() { fmt.Println("hello");fmt.Println("world") //写在一行需要加分号 } [Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go" hello world [Done] exited with code=0 in 0.431 seconds
3,注释
注释不会被编译,每一个包应该有相关注释。 单行注释是最常见的注释形式,你可以在任何地方使用以//开头的单行注释。多行注释也叫块注释,均已以/*开头,并以 */结尾。如: .
//单行注释 /* 行为艺术 多行注释 */
4,标识符
标识符用来命名变量、类型等程序实体。-个标识符实际上就是一个或是多 个字母(A-Z和a- z)数字(0-9)、下划线组成的序列,但是第一个字符必须是字母或下划线而不能是数字。 以下是有效的标识符:
mahesh kumar abc move_name a_123 mynames0 _temp j a23b9 retval
以下是无效的标识符:
● 3ab (以数字开头) ● case (Go 语言的关键字) ● a+b (运算符是不允许的)
例
5,字符串连接
Go语言的字符串可以通过+实现:
package main import "fmt" func main() { fmt.Print1n("lilei " + " hanmeimei") [Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go" lilei hanmeimei [Done] exited with code=0 in 0.543 seconds
6,关键字
下面列举了Go代码中会使用到的25个关键字或保留字:
break | default | func | interface | select |
---|---|---|---|---|
case | defer | go | map | struct |
chan | else | goto | package | switch |
const | fallthrough | if | range | type |
coontinue | for | import | return | var |
除了以上介绍的这些关键字,Go语言还有36个预定义标识符:
append | bool | byte | cap | close | complex |
---|---|---|---|---|---|
int | uint | float32 | iota | nil | complex64 |
int8 | uint8 | float64 | len | panic | complex128 |
int16 | uint16 | copy | make | real | |
int32 | uint32 | false | new | recove | println |
int64 | uint64 | imag | ture | string | uintptr |
程序一般由关键字、常量、变量、运算符、类型和函数组成。 程序中可能会使用到这些分隔符:括号(),中括号[]和大括号{}。 程序中可能会使用到这些标点符号:. , ; : 和... 。
例
package main import "fmt" const ( //定义常量 a = iota //iota是从0开始每次递增 0 b //1 c //2 ) func main() { fmt.Println(a, b, c) } [Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go" 0 1 2 [Done] exited with code=0 in 0.655 seconds
7,GO语言的空格
Go语言中变量的声明必须使用空格隔开(当你没有使用空格时,当你保存crtl+s时会自动格式的统一化),如:
var age int;
语句中适当使用空格能让程序更易阅读。 无空格:
fruit=apples+oranges ;
在变量与运算符间加入空格,程序看起来更加美观,如:
fruit = apples + oranges;
8,格式化字符串
Go语言中使用fmt.Sprintf格式化字符串并赋值给新串:
package main import ( "fmt" I ) func main() { *// %d表示整型数字,%s表示字符串合 var stockcode=123 var enddate="2022-3-10" var ur1="Code=%d&endDate=%s " var target_ ur 1=fmt .Spr intf (ur1,stockcode , enddate) fmt .Print1n(target. ur1)
输出结果为:
Code=12 3&endDate=2022-3-10
例:
package main import "fmt" var number int = 100 var enddate = "this is lili" func main() { fmt.Printf("数字为%d,名字是%s", number, enddate) } 输出 [Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go" 数字为100,名字是this is lili [Done] exited with code=0 in 0.541 seconds
Go语言的数据类型
在Go编程语言中,数据类型用于声明函数和变量。 数据类型的出现是为了把数据分成所需内存大小不同的数据,编程的时候需要用大数据的时候才需要申请大内存,就可以充分利用内存。
变量:随时变化的数据
go语言是一种强语言类型,类似java。需要声明数据类型
Go语言按类别有以下几种数据类型:
序号 | 类型和描述 |
---|---|
1 | 布尔型 布尔型的值只可以是常量true或者false. -个简单的例子: var b bool = true. |
2 | 数字类型 整型int和浮点型float32、float64, Go语言支持整型和浮点型数字,并且支持复数,其中位的运算采用补码。 |
3 | 字符串类型 :字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的 |
4 | 派生类型:包括: (a) 指针类型(Pointer) (b) 数组类型(C)结构化类型(strucU(d) Channel类型(e)函数类型()切片类型(g)接口类型(interface) (h) Map类型。 |
例:bool变量声明
package main import "fmt" //布尔值类型变量,默认值是false var letgo bool func main() { fmt.Println("布尔值默认的是:", letgo) } 输出: [Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go" 布尔值默认的是: false [Done] exited with code=0 in 0.531 seconds
package main import "fmt" //布尔值类型变量,默认的是false var letgo bool = true //赋值可以直接在类型后面 func main() { fmt.Println("布尔值默认的是:", letgo) } [Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go" 布尔值默认的是: true //输出就是所赋的值 [Done] exited with code=0 in 0.548 seconds
package main import "fmt" //布尔值类型变量,默认的是false var letgo bool = true //全局变量 func main() { var letgo = false //局部变量 在函数中赋值 fmt.Println("布尔值默认的是:", letgo) } [Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go" 布尔值默认的是: false //不会使用全局变量的赋值,而是使用函数中的赋值 [Done] exited with code=0 in 0.54 seconds
PS:全局变量优先被加载,局部变量只有使用这个方法的时候才会被加载。同时都有时变量的使用时就近原则,哪个离得近就加载哪个。
例:变量声明方式
package main import "fmt" // = 和:= 的区别 var a int = 1 //第一种变量声明方式(完整书写) int类型不赋值时默认值是0 var b = 2 //第二种变量声明方式(依赖赋值推断出数据类型) func main() { //第三种变量声明方式(在函数中直接赋值,无需声明,即定义即赋值,不可在全局) c := 3 fmt.Println(a, b, c) } 输出: [Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go" 1 2 3 [Done] exited with code=0 in 0.55 seconds
数字类型
Go也有基于架构的类型,例如: int. uint 和uintptr。
序号 | 类型和描述 |
---|---|
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语言变量
变量来源于数学,是计算机语言中能储存计算结果或能表示值抽象概念。 变量可以通过变量名访问。 Go语言变量名由字母、数字、下划线组成。其中首个字符不能为数字。 声明变量的一般形式是使用var关键字:
var identifier type 声明 变量名 变量类型
可以一次声明多个变量:
var identifier1, identifier2 type 声明 变量名1,变量名2 变量类型
###
package main import "fmt" func main() { var a string = "lilei" fmt. Print1n(a) var b,c int =10,20 fmt.print1n(b,c) }
输出的结果是
lilei 10 20
例
package main import "fmt" var a, b int //未赋值输出默认值0 //变量集体声明 func main() { fmt.Println("a=", a, "b=", b) } 输出 [Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go" a= 0 b= 0 [Done] exited with code=0 in 0.575 seconds 赋值定义 package main import "fmt" var a, b int = 10, 20 //变量集体声明 func main() { fmt.Println("a=", a, "b=", b) } 输出 [Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go" a= 10 b= 20 [Done] exited with code=0 in 0.559 seconds
变量声明
第一种,指定变量类型,如果没有初始化,则变量默认为零值。
var v_name v_type v_name = value
零值就是变量没有做初始化时系统默认设置的值。
###
package main import "fmt" func main() { //声明一个变量并初始化* var a = "lilei" fmt.Println(a) //没有初始化就为零值* var b int fmt.Println(b) // bool零值为falser var c bool fmt.Println(c) }
以上实例执行结果为:
lilei 0 false
●数值类型(包括complex64/128)为0 ●布尔类型为false ●字符串为”" (空字符串)
●以下几种类型为nil:
例:
package main import "fmt" var name string //空字符串类型 func main() { fmt.Println("name=", name) } 输出 [Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go" name= [Done] exited with code=0 in 0.569 seconds
●以下几种类型为nil:
var a int var a []int var a map[string] int var a chan int var a func (string) int var a error // error是接口!
###
package main import "fmt" func main( { var i int var f f1oat64 var b bool var s string fmt .Printf("%v %v %v %q\n", i, f, b, s) }
输出的结果是:
0 0 false ""
第二种:根据值自行判断变量的类型
var v_name = value
###
package main import "fmt" func main() { var d = true fmt.Println(d) }
输出的结果为:
true
第三种,如果变量已经使用var声明过了,再使用:=声明变量,就产生编译错误,格式:
v_name := value
例如:
var intva1 int intval :=1 //这时候会产生编译错误,因为intVal 已经声明,不需要重新声明
例:
直接使用下面的语句即可:
intva1 := 1 //此时不会产生编译错误,因为有声明新的变量,因为:=是一个声明语句
ingVal:=1相等于:
var intva1 int intva1 =1
可以将var name string = "lilei"简写为name := "lilei":
package main import "fmt" func main() { name := "lilei" //var name string = "lilei" fmt.Println(name) } [Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go" lilei [Done] exited with code=0 in 0.566 seconds
多变量声明
//类型相同多个变量,非全局变量 var vname1, vname2, vname3 type vname1, vname2,vname3 = v1,v2, v3 var vname1, vname2, vname3 = v1,v2,v3 //和python很像,不需要显示声明类型,自动推断 vname1, vname2,vname3 := v1,v2,v3 //出现在:=左侧的变量不应该是已经被声明过的,否则会导致编译错误 //这种因式分解关键字的写法一般用于声明全局变量 var ( vname1 V_ type1 vname2 V_ type2
例:
package main import "fmt" func main() { //多变量声明 var a, b, c = 10, 20, 30 fmt.Println(a, b, c) } [Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go" 10 20 30 [Done] exited with code=0 in 0.553 seconds
因式分解例:
package main import "fmt" //因式分解声明变量 var ( a int b string c float32 ) func main() { a = 10 b = "lilei" c = 20.00 fmt.Println(a, b, c) } 输出: [Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go" 10 lilei 20 [Done] exited with code=0 in 0.552 seconds
####
package main var x,y int var ( //这种因式分解关键字的写法一-般用于声明全局变量 a int b bool ) var c,d int=1,2 var e,f = 123,"he11o" //这种不带声明格式的只能在函数体中出现 //g,h := 123,"he11o" func main(){ g,h := 123,"hel1o" print1n(x,y,a, b,C,d, e,f, g,h) }
以上实例执行的结果为:
0 0 0 false 1 2 123 he11o 123 he11o
实例::: package main import "fmt" var x, y int var ( a int b bool ) var c, d int = 1, 2 var e, f = 123, "nihao" func main() { g, h := 123, "wohenhao" fmt.Println(x, y, a, b, c, d, e, f, g, h) } 输出: [Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go" 0 0 0 false 1 2 123 nihao 123 wohenhao [Done] exited with code=0 in 0.545 seconds