Go基础语法（一）

先讲一下，写这种笔记的目的：

1. 自己在学的过程中能一字一句读下来并且写出来，便于了解加深记忆，这样做比只看教程记忆会更加深刻。
2. 当我某些细的点遗忘的时候我可以快速查询，由于笔记是我自己写的我知道知识点写在哪部分。
3. 可以分享出来给其余酷爱go的入门者或者者在上学的同学看，由于这边记录的是把官方内容精简了些。

什么是Golang

Go 亦称为 Golang（译注：按照 Rob Pike 说法，语言叫做 Go，Golang 只是官方网站的网址），是由谷歌开发的一个开源的编译型的静态语言。

Golang 的主要关注点是使得高可用性和可扩展性的 Web 应用的开发变得简便容易。（译注：Go 的定位是系统编程语言，只是对 Web 开发支持较好）

Go 语言少量优点：

• 并发是语言的一部分（并非通过标准库实现），所以编写多线程程序会是一件很容易的事。后续教程将会探讨到，并发是通过 Goroutines 和 channels 机制实现的。
• Golang 是一种编译型语言。源代码会编译为二进制机器码。而在解释型语言中没有这个过程，如 Nodejs 中的 Python。
• 语言规范十分简洁。所有规范都在一个页面展现，你甚至都可以用它来编写你自己的编译器呢。
• Go 编译器支持静态链接。所有 Go 代码都可以静态链接为一个大的二进制文件（译注：相对现在的磁盘空间，其实根本不大），并可以轻松部署到云服务器，而不必担心各种依赖性。

安装

Mac OS

官网下载https://golang.org/dl/ 安装程序。双击开始安装，会将 Golang 安装到 /usr/local/go 目录下，同时 /usr/local/go/bin 文件夹也会被增加到 PATH 环境变量中。
(这里只详情Mac OS下的安装，其余平台请自行查阅)

建立工作区

在 Mac 或者 Linux 操作系统下，Go 工作区应该设置在 $HOME/go。所以我们要在 $HOME 目录下创立 go 目录。
也可以通过设置 GOPATH ，用其余目录来作为工作区。我这边使用的ide是这个

所有 Go 项目都应该依次在 src 里面设置自己的子目录。我们在 src 里面创立一个目录 hello 来放置整个 hello 项目。

创立上述目录之后，其目录结构如下：

go   src      hello          hello.go

hello.go中写入代码：

package mainimport "fmt"func main() {      fmt.Println("Hello World")}

1. 使用命令go run hello.go名运行：

   
   image.png
2. 使用 go install hello 命令
   当你输入 go install hello 时，go 工具会在工作区中搜索 hello 包。接下来它会在工作区的 bin 目录下，创立一个名为 hello（Windows 下名为 hello.exe）的二进制文件。运行 go install hello 后，其目录结构如下所示：

go  bin    hello  src    hello      hello.go

代码中第一行：
package main ，每一个 Go 文件都应该在开头进行 package name 的公告（译注：只有可执行程序的包名应当为 main）。包（Packages）用于代码的封装与重用，这里的包名称是main。

变量

变量：变量指定了某存储单元（Memory Location）的名称，该存储单元会存储特定类型的值。在 Go 中，有多种语法用于公告变量。

package mainimport (    "fmt"    "math")func main() {    var age int // 变量公告    fmt.Println("my age is", age)    age = 10   //变量赋值    fmt.Println("my age is", age)    age = 30  //变量赋值    fmt.Println("my age is", age)    var name string = "allen" // 公告变量并初始化    fmt.Println("my name is", name)    var num = 29 // 可以推断类型    fmt.Println("my num is", num)    var width, height int = 100, 50 // 公告多个变量    fmt.Println("width is", width, "height is", height)    var a, b int //省略初始化，默认值为0    fmt.Println("width is", a, "height is", b)    //一个语句中声名不同类型变量    var (        c  = "jie"        d    = 24        e int    )    fmt.Println("my c is", c, ", d is", d, "and e is", e)    m, n := "allen", 29 // 简短公告    fmt.Println("m name is", m, "n is", n)    //变量也可以在运行时进行赋值    q, p := 145.8, 543.8    e1 := math.Min(q, p)    fmt.Println("minimum value is ", e1)}

1. 公告单个变量 ：var name type
2. 公告变量并初始化 ： var name type = initialvalue
3. 类型推断（Type Inference） ： 假如变量有初始值，那么 Go 能够自动推断具备初始值的变量的类型。因而，假如变量有初始值，即可以在变量公告中省略 type。例：var name = initialvalue
4. 公告多个变量 ： var name1, name2 type = initialvalue1, initialvalue2。
5. 一个语句中公告不同类型的变量 ：
   var (
   name1 = initialvalue1,
   name2 = initialvalue2
   )
6. 简短公告 : name := initialvalue，
   简短公告要求 := 操作符左边的所有变量都有初始值。
   简短公告的语法要求 := 操作符的左边至少有一个变量是尚未公告的。
7. 因为 Go 是强类型（Strongly Typed）语言，因而不允许某一类型的变量赋值为其余类型的值。

类型

基本类型：

• bool
• 数字类型
  int8, int16, int32, int64, int
  uint8, uint16, uint32, uint64, uint
  float32, float64
  complex64, complex128
  byte
  rune
• string

有符号整型：

int：根据不同的底层平台（Underlying Platform），表示 32 或者 64 位整型。除非对整型的大小有特定的需求，否则你通常应该使用 int 表示整型。

在 Printf 方法中，使用%T打印变量类型。
Go 的 unsafe 包提供了一个 Sizeof 函数，该函数接收变量并返回它的字节大小。

func main()  {    a := true    b := false    fmt.Println("a:", a, "b:", b)    c := a && b //仅当 a 和 b 都为 true 时，操作符 && 才返回 true    fmt.Println("c:", c)    d := a || b //当 a 或者者 b 为 true 时，操作符 || 返回 true    fmt.Println("d:", d)    var a1 int = 89    b1 := 95    fmt.Println("a1 is", a1, "and b is", b1)    fmt.Printf("type of a is %T, size of a is %d", a1, unsafe.Sizeof(a1)) // a 的类型和大小    fmt.Printf("\ntype of b is %T, size of b is %d", b1, unsafe.Sizeof(b1)) // b 的类型和大小}

在32位系统下，字节大小为4，64位下，字节大小为8。

无符号整型

uint：根据不同的底层平台，表示 32 或者 64 位无符号整型。

浮点型

float32：32 位浮点数
float64：64 位浮点数

package mainimport (      "fmt")func main() {    a, b := 5.67, 8.97 //a 和 b 的类型根据赋值推断得出,float64 是浮点数的默认类型    fmt.Printf("type of a %T b %T\n", a, b)    sum := a + b    diff := a - b    fmt.Println("sum", sum, "diff", diff)    no1, no2 := 56, 89    fmt.Println("sum", no1+no2, "diff", no1-no2)}

a 和 b 的类型根据赋值推断得出，float64 是浮点数的默认类型。

复数类型

complex64：实部和虚部都是 float32 类型的的复数。
complex128：实部和虚部都是 float64 类型的的复数。

其余数字类型

byte 是 uint8 的别名。
rune 是 int32 的别名。

string 类型

在 Golang 中，字符串是字节的集合。假如你现在还不了解这个定义，也没有关系。我们可以暂且认为一个字符串就是由很多字符组成的。后面会在一个教程中深入学习字符串。

package mainimport (      "fmt")func main() {      first := "Zhao"    last := "Alle"    name := first +" "+ last    fmt.Println("My name is",name)}

类型转换

Go 有着非常严格的强类型特征。Go 没有自动类型提升或者类型转换。

package mainimport (      "fmt")func main() {    i := 55      //int    j := 67.8    //float64    sum := i + int(j) //j is converted to int    fmt.Println(sum)    q := 10    var w float64 = float64(q) // 若没有显式转换，该语句会报错    fmt.Println("w", w)}

把 v 转换为 T 类型的语法是 T(v)。
赋值的情况也是如此。把一个变量赋值给另一个不同类型的变量，需要显式的类型转换。

常量

定义：在 Go 语言中，术语"常量"用于表示固定的值。
使用关键字 const 表示常量。

package mainfunc main() {      const a = 55 // 允许    a = 89       // 不允许重新赋值}

1. 常量不能再重新赋值为其余的值。因而上面的代码将不能正常工作，它将出现一个编译错误: cannot assign to a
2. 常量的值会在编译的时候确定。由于函数调用发生在运行时，所以不能将函数的返回值赋值给常量。

字符串常量

const a = "Hello World"
上面的例子，我们把 Hello World 分配给常量 a。现在常量 a 是没有类型的。

无类型的常量有一个与它们相关联的默认类型（上边默认类型是string），并且当且仅当一行代码需要时才提供它。在公告中 var b = "Sam" ， b 需要一个类型，它从字符串常量 Sam 的默认类型中获取。

创立一个带类型的常量：
const c string = "Hello World"
常量c就是一个string类型的。

Go 是一个强类型的语言，在分配过程中混合类型是不允许的。

布尔常量

布尔常量和字符串常量用法相同，他们是两个无类型的常量 true 和 false。

package mainfunc main() {      const trueConst = true    type myBool bool    var defaultBool = trueConst // 允许    var customBool myBool = trueConst // 允许    defaultBool = customBool // 不允许}

数字常量

包含整数、浮点数和复数的常量

func main() {    const a = 5    var intVar int = a    var int32Var int32 = a    var float64Var float64 = a    var complex64Var complex64 = a    fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)}

常量a 的值是 5 ，a 的语法是通用的（它可以代表一个浮点数、整数甚至是一个没有虚部的复数），因而可以将其分配给任何兼容的类型。这些常量的默认类型可以被认为是根据上下文在运行中生成的。 var intVar int = a 要求 a 是 int，所以它变成一个 int 常量。 var complex64Var complex64 = a 要求 a 是 complex64，因而它变成一个复数类型。

数字表达式

func main() {      var a = 5.9/8    fmt.Printf("a's type %T value %v",a, a)}

在上面的程序中， 5.9 在语法中是浮点型，8 是整型，5.9/8 是允许的，由于两个都是数字常量。除法的结果是 0.7375 是一个浮点型，所以 a 的类型是浮点型。

假如内容对你有帮助，记得关注作者给个赞哦~，后续会持续升级。