一个完整的项目需要更复杂的逻辑，不是简单的 hello 世界可相比的。这些逻辑通过变量，常量，类型，函数方法，接口，结构体组成
变量声明
变量代表可变的数据类型，也就是谁，他在程序执行的过程中可能会被一次甚至多次修改
在Go语言中，通过var声明语句来定义一个变量，定义的时候需要指定这个变量的类型，然后再为他起个名字，并且设置好变量的初始值。所以，var声明一个变量的格式如下：

var 变量名 类型 =表达式

现在通过一个实例来演示如何定义一个变量，并且设置他的初始值

package main

import "fmt"

func main() {
    var i int = 10
    
    fmt.Println(i)
}

观察上面例子中 main函数的内容，其中 var i int=10 就是定义一个类型为 int(整数)，变量名为i的变量，他的初始值为10；

这里为了运行程序，加了一行 fmt.printIn(i),表示打印变量的值；

这样做一方面是因为Go语言中定义的变量必须使用，否则无法通过编译，这也是Go语言比较好的特性，防止定义了变量不使用，导致浪费内存的问题，另外一方面，在运行程序的时候可以查看变量i 的结果。

通过输入Go run ch02/main.go 命令回车运行，即可看到如下结果

$ go run ch02/main.go 

10

打印的结果是10，和变量的初始值一样。
因为go语言具有类型推到功能，所以也可以不去刻意指定变量的类型，而是让Go语言自己去推导，比如变量i也可以用如下的方式声明

var i=10

这个变量i的类型默认是int类型
你也可以一次声明多个变量，把要声明的多个变量放到一个括号里即可，如下面的代码所示

var ( j int=0 k int =1)

同理因为类型推导，以上多个变量声明也可以用一下代码的方式书写：

var  ( j=0 k=1)

这样就更简洁了。其实不止int类型，后面的float64, bool,string 等基础类型都可以被自动推导，也可以省略定义类型。

基础类型

任何一门语言都有对应的基础类型，这些基础类型和现实中的事物一一对应，比如整型对应着 1、2、3、100 这些整数，浮点型对应着 1.1、3.4 这些小数等。Go 语言也不例外，它也有自己丰富的基础类型，常用的有：整型、浮点数、布尔型和字符串，下面我就为你详细介绍。
整型
在Go语言中，整型分为：
有符号整型： 如 int,int8,int16,int32和int 64.
无符号整型： 如 unit,unit8, unit16,unit32和unit64
他们的差别在于，有符号整型表示数值可以为负数，零，和正数，而无符号整型只能是零和正数。

除了有用“位”大小表示整型外，还有int和unit这2个没有具体bit大小的整型，他们的大小可能是32bit 也可能是64 bit，和硬件设备CPU有关。

在整型中，如果能确定int的bit就选择比较明确的int类型，因为这会让你的程序具备很好的移植性。
在Go语言中，还有一种字节类型byte,他其实等价于unit8类型，可以理解为unit8类型的别名用于定义一个字节，所以字节 byte 类型也属于整型。
浮点数
浮点数就代表现实中的小数，Go语言提供了2种精度的浮点数，分别是float32和float64.项目中最常使用的是float64，因为他的精度高，浮点计算的结果相比float32误差会更小。
下面的代码示例定义了2个变量f32和f64，他们的类型分别为float32和float64.

    var f32 float32 = 2.3
    var f64 float64 = 10.3456
    fmt.Println("f32 is", f32, ":f64 is", f64)

运行这段程序后，会看到如下结果：

$ go run ch02/main.go

f32 is 2.2 ,f64 is 10.3456

布尔型
一个布尔型的值只有2种：true和false他们代表现实中的是和否，他们的值会经常被用于一些判断中，比如if语句等，Go语言中的布尔型使用关键字bool定义
下面的代码声明了2个变量

    var bf bool = false
    var bt bool = true
    fmt.Println("bf is ", bf, ",bt is ", bt)

布尔值可以用于一元操作符 ！，表示逻辑非的意思也可以用于二元操作符 &&、||，它们分别表示逻辑和、逻辑或。

字符串

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

    var s1 string = "hello"
    var s2 string = "世界"
    fmt.Print("s1 is ", s1, ",s2 is", s2)

运行程序就可以看到打印的字符串结果
在Go语言中，可以通过操作符+把字符串连接起来，得到一个新的字符串，比如将上面的s1和s2连接起来，如下：

fmt.Println("s1+s2=",s1+s2)

由于s1表示字符串 “hello”,s2表示字符串 "世界"，在终端输入 go run ch01/main.go后，就可以打印出他们连接起来的结果 “Hello世界”，如下代码所示：

s1+s2= Hello世界

字符串也可以通过+ =运算操作符。

零值

零值其实是一个变量的默认值，在Go语言中，如果我们声明了一个变量，但是没有对其进行初始化，那么Go语言会自动初始化其值为对应类型的零值。比如数字类的零值是0，布尔型的零值是false。字符串的零值是 “” 空字符等。
通过下面的代码示例，可以看到验证这些基础类型的零值：

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

变量

变量简短声明
有没有发现，上面我们演示的示例都是有一个 var 关键字，但是这样写代码很繁琐，借助类型推导，Go语言提供了变量的简短声明 :=,结构如下：

变量名 :=表达式

借助Go语言简短声明功能，变量声明就会非常简洁，比如以上示例中的变量，可以通过如下代码简短声明：

j := 120
    bf1 := false
    s12 := "Hello"
    fmt.Println(j)
    fmt.Println(j, s12, bf1)

在实际项目中，如果你能声明的变量初始化，那么选择简短声明方式，这种方式也是使用最多的。

指针

在Go 语言中，指针对应的是变量在内存中的存储位置，也就是说指针的值就是变量的内存地址。通过 & 可以获取一个变量的地址，也就是指针

在以下的代码中，pi就是指向变量 i的指针。要想获得指针的pi指向的变量值，通过 *pi这个表达式即可，尝试运行这段程序，会看到输出的结果和变量 i的值一样。

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

赋值

在讲变量的时候，变量是可以修改的，这就是赋值语句要做的事，最常做的赋值语句就是 =,如下代码所示

    i = 20
    fmt.Println("i的新值是", i)

这样变量i被修改了，他的新值是20

常量

一门编程语言，有变量就有常量，Go语言也不例外，在程序中，常量的值是指在编译期就确定好的。一旦确定好之后就不能被修改，这样可以防止在运行期被恶意篡改
常量的定义

常量的定义和变量类似，只不过他的关键字是const
下面的示例定义了一个常量name,，因为go语言可以类型推导，所以在常量声明时也可以省略

const name="hahh"

在go语言中，只允许布尔型，字符串，数字类型这些基础类型作为常量
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)

运行程序会发现打印的值和上面初始化的一样，也是，1,2,3，4
iota 的初始值是0，他的能力就是在每一个有变量声明的行后面+1,下面分解上面的常量

1. one=(0)+1,这时候iota的值为0，经过计算后，one 的值为 1
   2，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语言是强类型的语言，也就是说不同类型的变量是无法相互使用和计算的，这也是为了保证Go程序的健壮性，所以不同类型的变量在进行赋值或者计算前。需要先进行类型转换。涉及的类型转换知识点很多
以字符串和数字互换为例，

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

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

对于数字类型之间，可以通过强制转换的方式，如下代码所示：

i2f := float64(i)
    f2i := int(f64)
    fmt.Println(i2f, f2i)

这种使用方式比简单，采用“类型（要转换的变量）”格式即可。采用强制转换的方式转换数字类型，可能会丢失一些精度，比如浮点型转为整型时，小数点部分会全部丢失，你可以自己运行上述示例，验证结果。

把变量转换为相应的类型后，就可以对相同类型的变量进行各种表达式运算和赋值了。

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

//判断s1的前缀是否是h
    fmt.Println(strings.HasPrefix(s1, "h"))
    //在s1中查找字符串o

    fmt.Println(strings.Index(s1, "o"))

    //把s1全部转为大写

    fmt.Println(strings.ToUpper(s1))