go语言基础语法

文档

Golang 官方网站：

https://golang.google.cn/

Golang 官方标准库API :

https://pkg.go.dev/std

推荐：Golang 中文网官方标准库API
https://studygolang.com/pkgdoc

代码解读

package main

import (
	"fmt"
)

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

1、go文件的后缀是.go
2、package main ：定义了包名。package：是关键字，main是包的名字。你必须在源文件中非注释的第一行指明这个main.go文件属于哪个包，如：package main。表示该go文件所在的包是 main, 在 go 中，每个文件都必须归属于一个包。

3、import “fmt” ：导入的包。告诉 Go 编译器这个程序需要使用 fmt 包，引入该包后，就可以使用 fmt 包的函数，比如：fmt.Println。
fmt包作用：实现了格式化I/O。即将向外输出内容和获取输入内容，进行格式化输出和输入。

fmt是Go中最常用的包之一，主要实现了格式化I/O(输入/输出)。

Print系列函数中包含三个重要的函数：Print()，Printf()，Println()。

Print()将参数的内容进行标准输出。
Println()则是在标准输出后进行换行。
Printf()用于格式化字符串的输出。

重点说明一下Printf()函数。
fmt.Printf()进行格式化输出的时候需要使用占位符。使用方法如下：
fmt.Printf("占位符", 变量)
占位符用于声明以什么样的格式来输出变量的内容。

func main() {
    var n = 10
    fmt.Printf("%T\n", n) //查看变量数据类型
    fmt.Printf("%v\n", n) //查看变量的值
    fmt.Printf("%b\n", n) //查看变量对应的二进制
    fmt.Printf("%d\n", n) //查看变量对应的十进制
    fmt.Printf("%o\n", n) //查看变量对应的八进制
    fmt.Printf("%x\n", n) //查看变量对应的十六进制
}

4、func main() ：程序的入口，程序从func main起步。func 是一个关键字，表示创建一个函数 main()。 main 是函数名，是一个主函数，即我们程序的入口。
5、fmt.Println(“hello,word”) : 表示调用 fmt 包中的函数Println，输出 “Hello,Word!”
fmt是 format的缩写。 format [ˈfɔːmæt] 总体安排，格式化

6、main包和main函数的关系。
在 Go 语言里，命名为 main 的包具有特殊的含义。 Go 语言的编译程序会试图把这种main名字的包编译为二进制可执行文件。
（1）、所有用 Go 语言编译的可执行程序都必须有一个名叫 main 的包。
（2）、一个可执行程序有且仅有一个 main 包。
当编译器发现某个包的名字为 main 时，它一定也会发现名为 main()的函数，否则不会创建可执行文件。 main()函数是程序的入口，所以，如果没有这个函数，程序就没有办法开始执行。程序编译时，会使用声明 main 包的代码所在的目录的目录名作为二进制可执行文件的文件名。
编译时，先找到main包，然后再找到main包中的main()函数，开始编译和执行。

go run 和go build

go run命令会编译源码，并且直接执行源码的 main() 函数，但不会在当前目录留下可执行文件，不打包

go build 把go的源文件编译并且和它所依赖的包打包成可执行文件。

具体参考GO语言介绍及开发环境搭建 “打包”

go run 运行go源文件要比go build 打包生成的可执行文件之后再运行要慢一些，所以在生产环境上我们其实是要求上传go build打包后的可执行文件。go build 打包后的包要比go源文件大好多，其实是因为打包依赖了其他的文件。

变量

Go 语言变量名由字母、数字、下划线组成，只能以字母或下划线开头

声明变量的一般形式是使用var关键字：var 变量名变量类型

变量使用步骤：
1. 声明变量(也叫定义变量)
2. 变量赋值
3. 使用变量

变量声明的三种方法
第一种：指定变量类型，声明后若不赋值，使用默认值

// int 的默认值是0
var i int
fmt.Printf("变量i的默认值:%v\n", i)

//变量 i 赋值
i = 6

//使用变量
fmt.Println("i=", i)

第二种：根据值自行判定变量类型(类型推导)

var number = 6
fmt.Println("number=", number)

第三种：省略 var关键词声明变量方法：变量名 := “变量的值”
注：省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误。:= 的冒号不能省略，否则错误

name := "jack"
fmt.Println("name=", name)

注：4种声明方法效果一样：
方法1： var name string
name = “jack”
方法2： var name string = “jack”
方法3： name := “jack”
方法4： var sex = “man”

同时声明多个变量，并指定变量作用域
作用域：就是变量作用的范围
局部变量和全局变量的区别如下：
局部变量：
1 定义在函数{}里面的变量是局部变量，只能在{}里面有效
2 执行到定义的那句话，开始分配内存空间，离开作用域自动进行释放
全局变量：
1 定义在函数外部的变量称为全局变量
2 全局变量在任何地方都可以进行使用

package main

import (
    "fmt"
)

//声明多个全局变量
var (
    num1  = 300
    num2  = 900
    name3 = "tom"
)

func main() {
    //声明3个局部变量
    var (
        num4  int    = 10
        num5  int    = 20
        name6 string = "mk"
    )
    //输出全局变量
    fmt.Println("num1=", num1, "num2=", num2, "name3=", name3)
    //输出局部变量
    fmt.Println("num4=", num4, "num5=", num5, "name6=", name6)
}

常量

变量可以修改，常量不可以修改

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
常量的定义格式：
const 常量名字 [type] = value

const num1 int = 200
fmt.Printf("num1:%d", num1)

扩展：iota

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次，iota 可理解为 const 语句块中的行索引。
iota 可以被用作枚举值：

const (
        a = iota  //iota 0    a=0
        b = "gin" //iota 1    b="gin"
        c = "mk"  //iota 2    c="mk"
        d = iota  //iota 3    d=3
 )
    fmt.Println("a:", a)  //0
    fmt.Println("b:", b)  // gin
    fmt.Println("c:", c)  // mk
    fmt.Println("d:", d)  //3

数据类型

Go语言提供了各种数据类型，可分为基本的数据类型和复杂的数据类型。
基本的数据类型就是基本的构造块，例如字符串、数字和布尔值。
复杂的数据类型是用户自己定义的结构，由一种或者多种基本的数据类型组成

基本的数据类型包括 bool、string、int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64、uintptr、byte、rune、float32、float64、complex64、complex128
float  [fləʊt] 浮点型， 浮动   ； complex64  [ˈkɒmpleks]  复数，复杂的

整数类型

类型名	有无符号	字节数	表数范围
int8	有符号	8 位整型	-128 至 127
int16	有符号	16位整型	-32768 至 32767
int32	有符号	32 位整型	-2147483648 至 2147483647
int64	有符号	64 位整型	-9223372036854775808 至 9223372036854775807
uint8	无符号	8 位整型	0 至 255
uint16	无符号	16 位整型	0 至 65535
uint32	无符号	32 位整型	0 至 4294967295
uint64	无符号	64 位整型	0 至 18446744073709551615

注：通常我们声明一个int类型用于存放整数的变量时，直接通过int关键词来声明，此时int所指定的具体类型取决于操作系统，编译32位程序时则为int32，编译64位时则为int64，uint也一样。

rune类型是Unicode字符类型，和int32类型等价，通常用于表示一个Unicode码点，rune可以和int32可以互换。 rune [ruːn] 符号,符文
byte是unit8类型的等价类型，byte一般用于强调数值是个原始的数据，而不是一个小的整数。
uintptr是一种无符号的整数类型，用于存放指针，uintptr类型只有在底层编程才需要，特别是Go语言和C语言函数库或操作系统接口交互的地方。

浮点类型

Go语言提供了两种精度的浮点数：float32、float64
浮点数的存储分为三部分：符号位+指数位+尾数位，在存储过程中尾数部分可能丢失。
注：float64 的精度比 float32 的要准确,需要保存一个高精度的数时应使用float64，开发中也推荐使用float64。
这些浮点数类型的取值范围可以从很微小到很巨大。浮点数的取值范围极限值可以在math包中找到。math.MaxFloat32、mathMaxFloat64分别表示两种浮点数类型的取值范围

类型名	字节数	表数范围
float32	4字节	-3.403E38 至 3.403E38
float64	8字节	-1.798E308 至 1.798E308

E代表10，38指10的38次方，
例如：
2000 = 2.0e3
13600，精确到十位，记作：1.360X10^4
13200 ，精确到百位，记作：1.32X10^4
322000，精确到千位，记作：3.22X10^5
注：浮点数都是有符号的。

字符编码概述-字符类型

ASCII码概述：
ASCII ((American Standard Code for Information Interchange): 美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是最通用的信息交换标准，并等同于国际标准ISO/IEC 646。ASCII第一次以规范标准的类型发表是在1967年，最后一次更新则是在1986年，到目前为止共定义了128个字符。只占一个字节

Unicode概述：
统一码（Unicode），也叫万国码、单一码，是计算机科学领域里的一项业界标准，包括字符集、编码方案等。Unicode是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。
Unicode 是容纳世界所有文字符号的国际标准编码，使用四个字节为每个字符编码。
缺点：所有文字符号都占用4个字节，浪费空间。比如a 使用ASICII码表示时，只占用一个字节的空间。使用Unicode则需要占用4个字节，多用了3倍的空间。

布尔类型

布尔类型也叫 bool 类型，bool 类型数据只允许取值 true 和 false，bool 类型占 1 个字节，bool 类型适于逻辑运算，一般用于程序流程控制，例如：if 条件控制语句和for 循环控制语句

var b = false
fmt.Println("b=", b)
//注意事项
//1. bool类型占用存储空间是1个字节
//2. bool类型只能取true或者false
fmt.Println("b 的占用空间 =", unsafe.Sizeof(b))

字符串string类型

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码。

//string的基本使用
    var str1 string = "welcome to xuegod,hello world!"
    fmt.Println(str1)

    //在Go中字符串是不可变的,字符串一旦赋值了，字符串就不能修改了：
    //var str = "hello"
    //str[0] = 'a' //修改字符串中单个字符是不可以的，但是可以给变量重新赋值。

    //字符串的两种表示形式:
    //(1) 双引号, 会识别转义字符
    //(2) 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
    str2 := "abc\nabc"
    fmt.Println(str2)

    //使用反引号 `` 反引号在输出时\n不会被解析。
    str3 := `abc\nabc
    abc\nabc
    abc\nabc
`
    fmt.Println(str3)

    //字符串拼接方式
    var str = "welcome " + "to"
    str += "  xuegod!"
    str = str + " aaaa"
    fmt.Println(str)

    //当一个拼接的操作很长时，怎么办，可以分行写,但是注意，需要将+保留在上一行.
    str4 := "hello" + " world " + "hello" +
        " world " + "hello" + " world "
    fmt.Println(str4)

注意事项
1. Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文乱码问题不会再困扰程序员。
2. 字符串一旦赋值了，字符串就不能修改了，Go语言中字符串是不可变的。
3. 字符串的两种引号区别：
双引号, 会识别转义字符
反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
4. 当一行字符串太长时，可以通过字符串拼接换行书写，拼接符号要在行尾。

基本数据类型的默认值

数据类型	默认值
整型	0
浮点型	0
字符串	“”
布尔值	FALSE

指针变量

指针：是一种存储变量内存地址（Memory Address）的变量。指针的值为另一个变量的内存地址。
指针变量的重要性：
（1）、节省内存。如： a=b 是把b的内容复制给a, 那么如果b的内容需要占用1G内存，a也会占用1G内存，加起来就是2G内存，太浪费内存空间了。
（2）、函数调用时只传地址（一个指针），而不用传整份数据，速度也快。避免多余的副本。

声明指针变量的格式：var var_name *var-type
var_name 为指针变量名
var-type 为指针类型
* 用于指定变量，作为一个指针变量，而不是普通变量

注意事项：var-type的类型要和目标变量类型一致
var a int = 10
*int在指定时要和变量a的类型一致。
var ptr1 *int = &a

var a *int /* 指向整型*/
var a *float32 /* 指向浮点型 */

var a *string /* 指向字符串类型 */