本文摘自网络，作者，侵删。

一.Go 入门

如下图即为Hello Go 代码：

package main

import "fmt"

func main() {

fmt.Println("Hello, 世界")
}

第一行的 package main 代表当前的 main.go 文件属于哪个包，其中 package 是 Go 语言声明包的关键字，main 是要声明的包名。在 Go 语言中 main 包是一个特殊的包，代表你的 Go 语言项目是一个可运行的应用程序，而不是一个被其他项目引用的库。

二.环境变量

在 Go 语言中，通过 var 声明语句来定义一个变量，定义的时候需要指定这个变量的类型，然后再为它起个名字，并且设置好变量的初始值。

var 变量名类型 = 表达式例：

var i int = 10

Go 语言中定义的变量必须使用，否则无法编译通过，这也是 Go 语言比较好的特性，防止定义了变量不使用，导致浪费内存的情况。
因为 Go 语言具有类型推导功能，所以也可以不去刻意地指定变量的类型，而是让 Go 语言自己推导，比如变量 i 也可以用如下的方式声明：

var i = 10

也可以一次声明多个变量，把要声明的多个变量放到一个括号中即可，如下面的代码所示：

var (
    j int= 0
    k int= 1
)

三.数据类型

整型

在 Go 语言中，整型分为：
有符号整型：如 int、int8、int16、int32 和 int64。
无符号整型：如 uint、uint8、uint16、uint32 和 uint64。

它们的差别在于，有符号整型表示的数值可以为负数、零和正数，而无符号整型只能为零和正数。字节类型 byte，它其实等价于 uint8 类型，可以理解为 uint8 类型的别名，用于定义一个字节，所以字节 byte 类型也属于整型。

浮点数

浮点数就代表现实中的小数。Go 语言提供了两种精度的浮点数，分别是 float32 和 float64。项目中最常用的是 float64，因为它的精度高，浮点计算的结果相比 float32 误差会更小。

var f32 float32 = 2.2
var f64 float64 = 10.3456

布尔型

var bf bool =false
var bt bool = true

字符串

Go 语言中的字符串可以表示为任意的数据，比如以下代码，在 Go 语言中，字符串通过类型 string 声明：

var s1 string = "Hello"
var s2 string = "世界"
fmt.Println("s1 is",s1,",s2 is",s2)
fmt.Println("s1+s2=",s1+s2)

零值

零值其实就是一个变量的默认值，在 Go 语言中，如果我们声明了一个变量，但是没有对其进行初始化，那么 Go 语言会自动初始化其值为对应类型的零值。比如数字类的零值是 0，布尔型的零值是 false，字符串的零值是 "" 空字符串等。

var zi int
var zf float64
var zb bool
var zs string
fmt.Println(zi,zf,zb,zs)

变量简短声明

i:=10
bf：=false
s1:="Hello"

指针

在 Go 语言中，指针对应的是变量在内存中的存储位置，也就说指针的值就是变量的内存地址。通过 & 可以获取一个变量的地址，也就是指针。
在以下的代码中，pi 就是指向变量 i 的指针。要想获得指针 pi 指向的变量值，通过*pi这个表达式即可。尝试运行这段程序，会看到输出结果和变量 i 的值一样。

pi:=&i
fmt.Println(*pi)

常量

常量的定义和变量类似，只不过它的关键字是 const。在 Go 语言中，只允许布尔型、字符串、数字类型这些基础类型作为常量。

const name = "sshix"

iota

iota 是一个常量生成器，它可以用来初始化相似规则的常量，避免重复的初始化。假设我们要定义 one、two、three 和 four 四个常量，对应的值分别是 1、2、3 和 4，如果不使用 iota，则需要按照如下代码的方式定义：

const(
    one = 1
    two = 2
    three =3
    four =4
)

以上声明都要初始化，会比较烦琐，因为这些常量是有规律的（连续的数字），所以可以使用 iota 进行声明，如下所示：

const(
    one = iota+1
    two
    three
    four
)
fmt.Println(one,two,three,four)

iota 的初始值是 0，它的能力就是在每一个有常量声明的行后面 +1，下面我来分解上面的常量：

one=(0)+1，这时候 iota 的值为 0，经过计算后，one 的值为 1。
two=(0+1)+1，这时候 iota 的值会 +1，变成了 1，经过计算后，two 的值为 2。
three=(0+1+1)+1，这时候 iota 的值会再 +1，变成了 2，经过计算后，three 的值为 3。
four=(0+1+1+1)+1，这时候 iota 的值会继续再 +1，变成了 3，经过计算后，four 的值为 4。

如果你定义更多的常量，就依次类推，其中 () 内的表达式，表示 iota 自身 +1 的过程。

字符串和数字互转

Go 语言是强类型的语言，也就是说不同类型的变量是无法相互使用和计算的，这也是为了保证Go 程序的健壮性，所以不同类型的变量在进行赋值或者计算前，需要先进行类型转换。以字符串和数字互转这种最常见的情况为例，如下面的代码所示：

i2s:=strconv.Itoa(i)
s2i,err:=strconv.Atoi(i2s)
fmt.Println(i2s,s2i,err)

通过包 strconv 的 Itoa 函数可以把一个 int 类型转为 string，Atoi 函数则用来把 string 转为 int。同理对于浮点数、布尔型，Go 语言提供了 strconv.ParseFloat、strconv.ParseBool、strconv.FormatFloat 和 strconv.FormatBool 进行互转。

Strings 包

Go SDK 为我们提供的一个标准包 strings。它是用于处理字符串的工具包，里面有很多常用的函数，帮助我们对字符串进行操作，比如查找字符串、去除字符串的空格、拆分字符串、判断字符串是否有某个前缀或者后缀等。掌握好它，有利于我们的高效编程。strings 文档

//判断s1的前缀是否是H
fmt.Println(strings.HasPrefix(s1,"H"))

//在s1中查找字符串o
fmt.Println(strings.Index(s1,"o"))

//把s1全部转为大写
fmt.Println(strings.ToUpper(s1))

本文来自：简书

感谢作者：我又不乱看

查看原文：2021-02-02. Hello,Go.

Go语言101

￥0元 老貘

一个与时俱进的Go编程知识库。

转载请注明出处：木庄网络博客 » 2021-02-02. Hello,Go.

2021-02-02. Hello,Go.