什么是Go语言
Go 语言是谷歌 2009 年首次推出并在 2012 年正式发布的一种全新的编程语言，可以在不损失应用程序性能的情况下降低代码的复杂性。Google 对 Go 寄予厚望，其设计是让软件充分发挥多核心处理器同步多工的优点，并可解决面向对象程序设计的麻烦。它具有现代的程序语言特色，如垃圾回收，帮助开发者处理琐碎但重要的内存管理问题。Go 的速度也非常快，几乎和 C 或 C++ 程序一样快，且能够快速开发应用程序。
GO语言特征
- 高性能，高并发
- 自动立即回收
- 语法简单，学习曲线平缓
- 丰富的标准库
- 快速编译
- 跨平台
- 函数多返回值
- 并发编程
Go语言命名方式
- 首字符可以是任意的Unicode字符或者下划线
- 剩余字符可以是Unicode字符、下划线、数字
- 字符长度不限
Go语言声明方式
- var（声明变量）, const（声明常量）, type（声明类型） ,func（声明函数）
Go语言的保留字与关键字
- 关键字
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
- 保留字
Constants: true false iota nil
Types: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
Functions: make len cap new append copy close delete
complex real imag
panic recover
Go语言的Helloworld
package main // 声明 main 包，表明当前是一个可执行程序
import "fmt" // 导入内置 fmt
func main(){ // main函数，是程序执行的入口
fmt.Println("Hello World!") // 在终端打印 Hello World!
}
Go的基本语法
变量
package main
import "fmt"
func main() {
var a int = 27 //var + 变量名 + 指定类型
var a = true //var + 变量名 （自动判断类型）
a := 1 // := 符号 <==> var a int = 1
//多变量声明
var a, b int = 1
var a,b = 1
a, b := "abc",1
//常量
const s string = "abc"
const s := "abc"
//匿名变量
a, _ := 1, 2 // _符号
}
if-else
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
} else {
/* 在布尔表达式为 false 时执行 */
}
循环
go语言中只有for循环一种，没有while，do while循环，但是可以通过for的不通用法达到一样的效果，循环可以通过break跳出，也可以通过continue继续。
for 条件表达式 {
}
for { //等于while
}
switch
a := 2
switch a {
case 1:
//...
case 2:
//...
case 3:
//...
default:
//...
}
//Switch可以支持条件语句
t := time.now()
switch {
case t.Hour() < 12:
//...
case t.Hour() > 12:
//...
default:
//...
}
数组
Go 语言数组声明需要指定元素类型及元素个数，语法格式如下
var a [10] int
a[1] = 1
b := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
var twoD[2][3]int
切片
切片就是一种简化版的动态数组。因为动态数组的长度不固定，切片的长度自然也就不能是类型的组成部分了。数组虽然有适用它们的地方，但是数组的类型和操作都不够灵活，而切片则使用得相当广泛。 我们可以用make来创建一个切片，像数组一样去取值，使用append来追加元素。
s := make{[]string,3}
s[0] = "a"
s[1] = "b"
s[2] = "c"
s.append(s,"d")
s.append(s,"e","f")
fmt.println(s[0:2])//a,b
fmt.println(s[2:])//c,d,e,f
fmt.println(s[1:3])//b,c
map
map表的底层原理是哈希表，我们可以用make来创建一个map，并指定key和value的类型
m := make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.println(m)//map[one:1,two:2]
//m["one"] = 1
//m["three"] = false
delete(m,"one")
m2 := map[string]int{"one":1, "two":2}
range
对于切片和map，我们可以使用range来快速遍历，遍历的时候，range会返回两个值，一个是索引，一个是对应的值，不需要索引时可以采用_来忽略掉。
nums := []int{2,3,4}
sum := 0
for i,num := range nums{
sum += num
}
fmt.println(sum)//9
m := map[string]string{"A":"a","B":"b"}
for k,v := range m{
fmt.println(k,v)//A a,B b
}
函数
在Go语言中，函数是第一类对象，我们可以将函数保持到变量中，Go语言的函数跟其他不一样的是，函数类型是后置的，支持返回两个值，在业务中通常都是返回两个值，一个结果，一个为error。
package main
import "fmt"
func add(a int, b int) int{
return a+b
}
func exists(m map[string]int,key string)(v string,ok bool){
v,ok = m[key]
return v,ok
}
指针
go语言也有指针，不过与c和c++比起来它的操作有限，主要是用来修改传入的参数。
func add(n int){
n += 2
}
func add(n *int){
*n += 2
}
func main(){
n := 2
add(n)//n = 2
add(&n)//n = 4
}
结构体
结构体是带类型的字段的集合，类似于java中的类
type user struct{
name string
pwd string
}
a := user{name:"luo",pwd:"123456"}
b := user{"luo","123456"}
c := user{name:"luo"}
c.pwd = "123456"
//结构体方法
func(u user) checkPwd(password string) bool{
return u.pwd == password
}
func(u *user) resetPwd(password string){
u.pwd = password
}
a.resetPwd9("11111")
a.checkPwd("123456")//true
错误处理
错误处理在go语言中的常用用法就是使用一个单独的返回值来传递错误信息。在函数里面，我们在返回值类型后边加一个error，就代表该函数啃可能返回错误信息，返回的时候就需要同时返回两个值（nil和error）
func findUser(users []user,name string)(v *user,e rrerror){
for _,u := range users{
if u.name == name{
return &u,nill;
}
}
return nil,error.New("Not Found")
}
字符串操作
a := "hello"
strings.Contains(a,"ll")//true
string.Count(a,"l")//2
strings.HasPreFix(a,"he")//true
strings.HasSuffix(a,"lo")//true
strings.index(a,"ll")//2
strings.Split("a-b-c-d","-")// abcd
strings.Replace(a,"e","E",-1)//hEllo
strings.Reapeat(a,2)//hellohello
strings.Join([]string{"he","llo"},"-")//he-llo
strings.ToUpper
strings.ToLower
len(a)//5
