【GO语言基础】Go基础语法总结

Go使用指南–基础语法

前言

​ Go语言是一种是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。

​ 语言类型一般分为三种：有无类型、弱类型、强类型。其中，无类型不检查，甚至不区分指令和数据；弱类型的检查很弱，仅能严格的区分指令和数据；强类型的则严格的在编译期进行检查。

​ 强类型语言在没有强制类型转化前，不允许两种不同类型的变量相互操作。例如，弱类型语言允许变量类型的隐式转换，允许强制类型转换等，如字符串和数值可以自动转化；而强类型语言一般不允许这么做。

​ Go属于编译型语言，其相对于Python解释型语言而言，编译型语言的首先将源代码编译生成机器语言，再由机器运行机器码（二进制）。而解释性语言的每一句代码在被执行的时候才翻译。这样解释性语言每执行一次就要翻译一次，效率比较低。

1. 变量

1.1 变量的概念

变量本质是计算机分配的一块内存，用于存储指定数据

变量的存储存在瞬时性，当程序执行结束后，存放数据的内存空间将会被释放，而变量将会消失

Go语言的变量名为：数字、字母、下划线组成，首字符不能为数字

1.2 变量的定义

var 变量名 变量类型

如下例子：

// 可执行的go程序必须引入package main
package main

import "fmt"

// main函数入口点
func main() {
   var a int
   var b float32

   var c, d float64

   fmt.Println(a,b,c,d)

   a = 5
   // = 使用必须使用先var声明例如
   c, d = 9, 10
   // := 是声明并赋值。并且系统自动推断类型，不需要var关键字
   e, f := 11, 12

   fmt.Print(a, b, c, d, e, f)

}

注意：‘=’ 和 ‘:=’ 的区别，‘=’ 使用必须使用先var声明例如。而 ‘:=’ 是声明并赋值。并且系统自动推断类型，不需要var关键字。

2. 数据类型

基本数据类型（原生数据类型）：整型、浮点型、布尔型、字符串、字符（buye、rune）

符合数据类型（衍生数据类型）：指针（pointer）、数组（array）、切片（slice）、映射（map）、函数（function）、结构体（struct）、通道（channel）

3. 判断表达式

if/else的使用

package main

import "fmt"

// if/else的使用
func main() {

   a := 10
   b := 11
   if a > b{
      fmt.Println("a大于b")
   } else {
      fmt.Print("b大于a")
   }
}

4. 循环表达式

for循环是一个循环控制结构，可以执行指定次数的循环。

语法1：for 表达式，如 for a:=0; a<10; a++

语法2: 无限循环，for true {} 等价 for {}

package main

import "fmt"

// for循环的使用
func main() {
   //标准for循环，注意表达式不带花括号
   for a:=0; a<10; a++ {
      fmt.Println(a)
   }
   b := 0
   
   //无限循环，后不跟表达式
   // go 里面没有while关键字，可以用for+break实现
   //for true{
   for {
      fmt.Println(b)
      b++
      if  b >= 10 {
         //break默认跳出本次循环，就近原则
         break
      }
   }
}

5. Go函数

函数定义语法：

func function_name( [parameter list（参数列表）] ) [return_types（返回类型）] {
   函数体，业务逻辑代码
}

注意：有些功能不需要返回值，这种情况下 return_types 不是必须的。

如下定义计算两个浮点数的和的sum方法：

package main

import "fmt"

// 参数定义时，一定要定义参数的类型。如果有返回值也要定义返回值的类型
func sum(a float32, b float32) float32 {
   return a+b
}

func main() {
   fmt.Println("the result is :", sum(2.2,2.9))
}
// 2.2+2.9的结果为5.1000004，是存在误差的

6. Go数组

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type 如 var 变量名a [10] int

初始化数组语法1:

var a = [元素个数]int{元素1，元素2，元素3...}	注意：初始化数组中 {} 中的元素个数不能大于 [] 中的数字

初始化数组语法2:

var a = [...]int{元素1， 元素2，元素3...}    注意：忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小

如下定义数组。

package main

import "fmt"

func main() {
   // 定义数组arr0，长度为3，且元素为int类型
   // 初始化数组中 {} 中的元素个数不能大于 [] 中的数字
   var arr0 = [3]int{1,2,3}
   fmt.Println(arr0)

   // 如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小
   var arr1 = [...]float32{5,3,3.5}
   fmt.Println(arr1)
   // 通过下标大于数组内的元素，且下标不能越界
   fmt.Println(arr1[0], arr1[2])
   
   // 定义长度为3，且存储int类型的数组
	var arr2 [3] int
	for a :=0; a<3; a++ {
		arr2[a] = a
	}
	fmt.Println(arr2)
}

7. Go指针

一个指针变量指向了一个值的内存地址。

在使用指针前你需要声明指针。指针声明格式如下：

var var_name *var-type

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针

package main

import "fmt"

func main () {
   var a int
   /* 声明指针变量 */
   var b *int

   /* 声明实际变量 */
   a = 5
   fmt.Println("a=", a)

   // 将a变量的实际内存地址赋值给b
   b = &a
   fmt.Println("b=", b)

   // *指针，表示使用指针访问值
   fmt.Println("b值为", *b)

   // 修改指针指向的值，则a变量被修改
   *b = 6
   fmt.Println("a=", a)


}