前言
Go的基础语法学好后，对后面项目的进行有极大的帮助！
如果还没安装好环境的童鞋，可以先参照博主的这篇文章进行搭建
Go的程序结构
Go 语言的基础组成有以下几个部分：
- 包声明
必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。 - 引入包
import （“fmt”） 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了==格式化 IO（输入/输出）==的函数。 - 函数
func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。 - 变量
当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。 - 语句 & 表达式
就是函数中的每一行代码 - 注释
/…/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。注释不会被编译器所编译
打印 Hello World 程序实例
package main //包声明
import ( //引入包
"fmt"
)
/*
* 多行注释
*/
func main() { //main函数，主程序入口
fmt.Println("Hello World") //语句&表达式
}
注意点
需要注意的是 { 不能单独放在一行，所以以下代码在运行时会产生错误：(Go在代码风格上强制约束受到许多开发者的厌恶，但那又怎样，Go还是强的一匹😄)
package main
import "fmt"
func main()
{ // 错误，{ 不能在单独的行上
fmt.Println("Hello, World!")
}
Go的基础语法
行分隔符
在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。
如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。
以下为两个语句：
fmt.Println("Hello, World!") //不需要加分号
fmt.Println("菜鸟教程：runoob.com")
标识符
标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(AZ和az)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
以下是有效的标识符：
mahesh kumar abc move_name a_123
myname50 _temp j a23b9 retVal
以下是无效的标识符：
1ab（以数字开头）
case（Go 语言的关键字）
a+b（运算符是不允许的）
字符串连接
Go 语言的字符串可以通过 + 实现：
package main
import "fmt"
func main() {
fmt.Println("Google" + "Runoob") //打印结果为 GoogleRunoob
}
Go语言的保留关键字
| break | default | func | interface | select |
|---|---|---|---|---|
| case | defer | go | map | struct |
| chan | else | goto | package | switch |
| const | fallthrough | if | range | type |
| continue | for | import | return | var |
Go 语言的空格
Go 语言中变量的声明必须使用空格隔开，如：
var age int;
语句中适当使用空格能让程序更易阅读。
无空格：
son=father+monther
在变量与运算符间加入空格，程序看起来更加美观，如：
son = father + monther
Go语言常见数据类型
数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
-
布尔型
布尔型的值只可以是常量 true 或者 false。
一个简单的例子： var b bool = true。 -
数字类型
整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。 -
字符串类型:
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 -
派生类型:
- 指针类型（Pointer）
- 数组类型
- 结构化类型(struct)
- Channel 类型
- 函数类型
- 接口类型（interface）
- Map 类型
Go语言定义变量
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字：
var identifier type
可以一次声明多个变量：
var identifier1, identifier2 type
实例
package main
import "fmt"
func main() {
var a string = "优快云"
fmt.Println(a)
var b, c int = 1, 2
fmt.Println(b, c)
}
变量声明
第一种，指定变量类型，如果没有初始化，则变量默认为零值。
var v_name v_type
v_name = value
零值就是变量没有做初始化时系统默认设置的值。
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)
}
字符串的零值为 “”（空字符串）
以下几种类型的零值为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 是接口
第二种，根据值自行判定变量类型。
var v_name = value
package main
import "fmt"
func main() {
var d = true // var b bool = true 简写为 var b = true
fmt.Println(d)
}
第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：
v_name := value
例如：
var intVal int
intVal :=1 // 这时候会产生编译错误
intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
可以将 var f string = “Runoob” 简写为 f := “Runoob”：
package main
import "fmt"
func main() {
f := "Runoob" // var f string = "Runoob"
fmt.Println(f)
}
多变量声明
//类型相同多个变量, 非全局变量
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
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
}
输出结果为
Go 语言常量
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
常量的定义格式：
const identifier [type] = value
你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。
- 显式类型定义： 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)
}
打印结果
Go的条件语句
if 语句
Go 编程语言中 if 语句的语法如下：
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
}
实例
package main
import "fmt"
func main() {
var a int = 6
if a <= 6 {
fmt.Print(a)
} else {
fmt.Println(a + 1)
}
}
Switch语句
switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。
switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。
switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。
Switch实例
package main
import "fmt"
func main() {
var a int = 6
switch a {
case 6:
fmt.Print(a)
case 7:
fmt.Println(a + 1)
default:
fmt.Println("default")
}
}
Go循环语句
- for循环语句
for 循环是一个循环控制结构，可以执行指定次数的循环。
Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。- for init; condition; post { }
- for condition { }
- for { }
- init： 一般为赋值表达式，给控制变量赋初值；
- condition： 关系表达式或逻辑表达式，循环控制条件；
- post： 一般为赋值表达式，给控制变量增量或减量。
- for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap {
newMap[key] = value
}
实例
- 计算 1 到 10 的数字之和
package main
import "fmt"
func main() {
var sum int = 0
for i := 1; i <= 10; i++ {
sum += i
}
fmt.Print(sum)
}
For-each range 循环
这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。
package main
import "fmt"
func main() {
strings := []string{"google", "runoob"}
//i 代表遍历时候的数组下标，s代表数组每一项的值
for i, s := range strings {
fmt.Println(i, s)
}
//i 代表遍历时候的数组下标，number代表数组每一项的值
numbers := []int{1, 2, 3, 4}
for i, number := range numbers {
fmt.Println(i, number)
}
}
Go 语言函数
函数是基本的代码块，用于执行一个任务。
Go 语言最少有个 main() 函数。
你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数声明告诉了编译器函数的名称，返回类型，和参数。
Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。
函数定义
func function_name( [parameter list] ) [return_types] {
函数体
}
函数定义解析：
- func：函数由 func 开始声明
- function_name：函数名称，函数名和参数列表一起构成了函数签名。
- parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
- return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下
- return_types 不是必须的。 函数体：函数定义的代码集合。
实例
以下实例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值：
package main
import "fmt"
func max(num1, num2 int) int {
var result int
if num1 > num2 {
result = num1
} else {
result = num2
}
return result
}
func main() {
fmt.Print(max(1, 2))
}
函数返回多个值
比如交换函数
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("A", "B")
fmt.Println(a, b)
}
Go默认采用的函数传值是值传递方式
Go的引用传递实例
package main
import "fmt"
func swap(x *int, y *int) {
var tmp int
tmp = *x
*x = *y
*y = tmp
}
func main() {
var a, b int = 1, 2
//因为要引用传递，所以用 & 符号将变量的地址值传递过去
swap(&a, &b)
fmt.Println(a, b)
}
Go 语言数组
Go 语言提供了数组类型的数据结构。
数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。
相对于去声明 number0, number1, …, number99 的变量，使用数组形式 numbers[0], numbers[1] …, numbers[99] 更加方便且易于扩展。
数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。
声明数组
Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：
var variable_name [SIZE] variable_type
定义数组实例
package main
import "fmt"
func main() {
var nums [10]int
var sum int = 0
for i := 0; i <= 9; i++ {
nums[i] = i
}
for i := 1; i <= 9; i++ {
sum += nums[i]
}
fmt.Println("数组的和为 = ", sum)
}
我们也可以通过字面量在声明数组的同时快速初始化数组：
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
如果数组长度不确定，可以使用 … 代替数组的长度，编译器会根据元素个数自行推断数组的长度：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
如果设置了数组的长度，我们还可以通过指定下标来初始化元素：
// 将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}
初始化数组中 {} 中的元素个数不能大于 [] 中的数字。
如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
数组程序实例
package main
import "fmt"
func main() {
var i, j, k int
// 声明数组的同时快速初始化数组
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* 输出数组元素 */
for i = 0; i < 5; i++ {
fmt.Printf("balance[%d] = %f\n", i, balance[i])
}
balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* 输出每个数组元素的值 */
for j = 0; j < 5; j++ {
fmt.Printf("balance2[%d] = %f\n", j, balance2[j])
}
// 将索引为 1 和 3 的元素初始化
balance3 := [5]float32{1: 2.0, 3: 7.0}
for k = 0; k < 5; k++ {
fmt.Printf("balance3[%d] = %f\n", k, balance3[k])
}
}
打印结果
语法篇一总结
从一些基础的语法上看，与C语言和Python语言会更接近一些，学习要保证持续性，加油！
看到这的童鞋给博主点个赞呗！👍👍😄
坚持分享，坚持原创，喜欢博主的靓仔靓女们可以看看博主的首页博客！
您的点赞与收藏是我分享博客的最大赞赏！
博主博客地址: https://blog.youkuaiyun.com/weixin_43967679
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
