本章分四块来讲解Go语言基础

• Go语言关键字
• 第一个Go程序 hello world
• Go语言变量和常量
• Go的基础数据类型
• Go的基础数据类型底层存储结构

第一章、Go语言的关键字

Go语言一共有25个关键字

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

接下来介绍每一个关键字的作用，在这一章可以大概了解是什么意思，不用深究，在后面会碰到它们

• break:在循环语句中，用于提前终止当前循环。
• default:在switch语句中，用于指定默认情况，当没有任何一个case匹配时执行该分支。
• func:用于声明一个函数。
• interface:用于定义一个接口类型，接口定义了一组方法的签名。
• select:用于在多个通讯操作中进行选择，当其中一个通讯操作可以进行时执行对应的分支。
• case:用于switch语句中指定一个或者多个条件，当条件匹配时执行对应的分支。
• defer:用于延迟执行一个函数调用，通常用于资源释放或清理操作。
• go:用以启动一个并发的goroutine，即一个轻量级线程。
• map:用于声明和操作映射(键值对)数据结构，结构体可以包含不同类型的字段。
• struct:用于定义自定义的复合数据结构，结构体可以包含不同类型的字段。
• chan:用于声明和操作管道，管道通常用于在goroutine之间的通讯。
• else:在if语句中，用于指定条件不满足时执行的分支。
• goto:用于无条件跳转到指定标签处的语句，通常应避免使用。
• package:用于声明Go源代码文件所属的包。
• switch:用于基于表达式值进行条件判断，根据不同的值执行相对应的下一个case分支。
• if:用于基于条件进行判断，当条件满足时执行对应的分支。
• range:用于迭代数组、切片、映射、字符串或通讯中的元素
• type:用于声明自定义类型，可以是基本类型的别名或者复合类型的定义.
• continueL在循环语句中，用于跳过当前循环中剩余的代码，进行下下一次循环迭代。
• for:用于循环执行一段代码块，可以是基于计数器的循环或者条件判断的循环。
• import:用于导入其他包的代码，使得在当前包中可以使用导入包的函数和变量。
• return:用于从函数中返回结果值，并终止函数的执行.
• var:用于声明变量，可以是指定类型的变量或者不具体类型的变量.

这些关键字是Go语言的重要构建块，通过组合和使用它们，可以实现各种功能和控制流程。

第二章、第一个Go程序

大家接触的第一个程序代码就是打印Hello world了吧？所以在这里也不意外.

package main
import "fmt"

func main(){
    fmt.Printf("Hello world!");
}

输出结果如下:

Hello world

解析: 打赢 1.Go语言是通过包来进行组织的，所有的Go语言的可执行程序中，必须包含一个名为main的包，这个main也必须包含一个main函数作为程序的入口点，

2.Go和C语言类似，都有一个main函数入口，当你使用go build或者go run命令编译或者运行Go程序的时候，编译器会识别main包并且生成可执行文件.

3.为了打印 Hello world我们调用了一个Printf函数，这个函数来自于fmt包,并且使用import映入该包:import "fmt"。

包的概念和node es6的包还有python中的package类似，它们都有一个特别的好处:模块化,可以将你的程序分成多个模块，利于封装和反复利用。

最后:Go语言是天然支持UTF-8编码的，也就是说任何的字符都可以直接输出，你甚至可以用UTF-8的任意字符作为标识符.

第三章、Go语言的变量

3.1变量

Go语言定义变量的方式有很多种方法，其中var关键字是Go最基本的定义变量的方法.

和c语言不一样，Go语言把变量类型放在变量名后面，就像这样:

//定义一个a变量，类型是int
var a int；

如果你想定义多个变量

//定义三个都是int类型的变量a b c
var a, b, c int;

定义变量并且初始化

var a int = 10;

同时初始化多个变量

var a, b, c int = 10,11,12;

上面的写法有点繁琐？所以Go语言设计者也设计了一种比较简单的写法，我们可以直接忽略类型声明，上面的代码就变成了这样:

/*
定义三个变量，它们分别初始化为相应的值
a 为 10，b 为字符串‘abc'  ，c 为 float64的3.14
然后 Go 会根据其相应值的类型来帮你初始化它们
*/
var a,b,c = 10,'abc',3.14;

如果你还觉得有点繁琐，也可以把var去掉，写成:

a,b,c :=10,'abc',3.14;

这一句可以使用:=可以直接取代了var和type，这种声明叫做简短式声明。不过他又一个限制，就是它只能用于函数的内部，在函数的外部使用则会无法编译通过，一般使用var方式来定义全局变量。

_(下划线)是个特殊的变量名，任何赋予他值都会被丢弃。在这个例子种，我们将35赋值给了b，同时丢弃了34。

_,b := 34,35;

注意简短式声明只能在函数内部使用！！！

Go对于一句声明，但是没有使用的变量在编译阶段会报错，例如:

package main
func main(){
    var i int;
}

这样一条会报错，因为i声明了但是没有使用.

3.2常量

常量是在程序编译阶段就确定夏利的值，在程序运行的时候无法改变该值。在Go语言种，常量可定义为数值、b布尔值或者字符串等类型. 它的具体语法如下:

const a = 10 
// 如果需要，也可以明确指定常量的类型： 
const Pi float32 = 3.1415926

但值得注意的是，如果一个自定义类型的常量中包含一个指针，如果指针对应的数据发生了改变，并不会引起报错。

Go 常量和一般程序语言不同的是，可以指定相当多的小数位数 (例如 200 位)， 若指定給 float32 自动缩短为 32bit，指定给 float64 自动缩短为 64bit，详情参考 链接

第四章、Go的基础数据类型

Go语言内置包含了四种基础类型，分别是Boolean、数值类型、字符串类型、错误类型

4.1Boolean类型

在 Go 中，布尔值的类型为 bool，值是 true 或 false，默认为 false。

// 示例代码
var isActive bool  // 全局变量声明
var enabled, disabled = true, false  // 忽略类型的声明
func test() {
    var available bool  // 一般声明
    valid := false      // 简短声明
    available = true    // 赋值操作
}

4.2数值类型

4.2.1整数类型

Go语言的整数类型有无符号和有符号两种,同时支持int和uint,这两种类型的长度相同，但具体长度取决于不同编译器的实现，Go语言也有直接定义好位数的类型:

rune  int8  int16  int32  int64
byte  uint8 uint16 uint32 uint64

其中rune是int32的别称，byte是uint8的别称.

需要注意的一点是，这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错。

例如以下代码会报错:

var a int8;
var b int32;
c := a + b;

另外，尽管int的长度是32bit，但是int和int32并不可以互用.

4.2.2浮点数类型

Go语言的浮点数类型有float32和float61两种(没有float类型)，默认是float64.

另外，Go语言还支持复数！！！ 天哪，我想起了复变函数的欧拉公式了。

它的默认类型是complex128(64位的实数+64位虚数).如果要小一点,也有complex64(32位的实数+32位的虚数).复数的形式是RE + IMi，其中RE是实数部分,IM是虚数部分,而最后的i是虚数单位，下面是一个复数使用的例子:

var a complex64 = 10 + 10i;
fmt.Printf("它的值是:%v",a);

打印结果10 + 10i

4.3字符串类型

Go语言的字符串都是采用UTF-8字符集编码。字符串是用一对双引号""或反引号`` 括起来定义，它的类型是string

//示例代码

// 示例代码
var a string  // 声明变量为字符串的一般方法
var b string = ""  // 声明了一个字符串变量，初始化为空字符串
func test() {
    e, f, g := "e", "f", "g"  // 简短声明，同时声明多个变量
    name := "asong"  // 同上
    hobby = "game"  // 常规赋值
}

在 Go 中字符串是不可变的，例如下面的代码编译时会报错：

var s string = "hello"
s[0] = 'b'
//报错

如果你真的想修改的话，可以采用以下的方法:

s := "hello"
c := []byte(s)  // 将字符串 s 转换为 []byte 类型
c[0] = 'b'
s1 := string(c)  // 再转换回 string 类型
fmt.Printf("%s\n", s1)

Go 中可以使用 + 操作符来连接两个字符串

s := "hello,"
m := " world"
a := s + m
fmt.Printf("%s\n", a)
//输出hello world

修改字符串也可以写成:

s := "hello"
s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作
fmt.Printf("%s\n", s)

如果想要声明多行字符串可以像node的ES6中一样 使用``来声明

a := `hello
    world`
//打印结果
hello
    world

这里的换行也会给打印出来

4.4错误类型

Go语言有一个内置的error类型，专门用来处理错误信息，Go的package里面还有个专门的包errors来处理错误.

err := errors.New("出错啦~")
if err != nil {
    fmt.Print(err)
}

第五章、Go的基础数据类型底层存储结构

下面这张图来源于 Russ Cox Blog 中一篇介绍 Go 数据结构 的文章，大家可以看到这些基础类型底层都是分配了一块内存，然后存储了相应的值。

总结:本章主要讲解了Go语言的一些基础，包括:

• Go语言关键字
• 第一个Go程序 hello world
• Go语言变量和常量
• Go的基础数据类型
• Go的基础数据类型底层存储结构

下一章:Go语言基础，包含:

• Go语言一些技巧
• Go程序设计的一些规则
• Go语言基本引用类型(arrary、slice、map)