一.Hello World 程序

package main

import(
"fmt"
)

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

package main 表示这个文件属于main包的一部分，main包是程序的入口包
上述代码在import引入了fmt包，并在main函数中使用

二.变量

golang是一门强类型语言，每一个变量都有他自己的类型，且每个类型之间不会自动转换，没有其他语言中的自动把低精度转换为高精度。
下面是比较常见的定义变量的方法

var a int
a = 1
var b,c int = 2,3 //golang支持同时定义多个变量
var d = true //golang能根据输入的值判断变量的类型
e := "hello" //var 可以省略成 :
f :=float64(a) //float64(a)把a的值从int强制转换为float64类型
aonst g = "world" //const用来声明常量

1.int，float

在golang中int有int , int8 , int16 , int32 , int64,他们之间是所占空间大小的不同，表示数组范围大小也不同
float有float32和float64两种，前一个表示数字的精度小，范围小，所占字节小。
int和float在变量未定义值的情况下默认是0

2.string

golang中字符类型是内置类型可以通过加号拼接在变量未定义值的情况下默认是""

string中还有很多字符串操作

字符串格式化。在标准库的 FMT 包里面有很多的字符串格式相关的方法，比如 printf 这个类似于 C 语言里面的 printf 函数。不同的是，在go语言里面的话，你可以很轻松地用 %v 来打印任意类型的变量，而不需要区分数字字符串。你也可以用 %+v 打印详细结果，%#v 则更详细。

3.bool

bool类型的值只有true和false两种，在变量未定义值的情况下默认是false

三.判断、循环、分支结构

1. 判断

golang中的的判断条件外面可以不用加()但是后面同一行必须加上{
if里边的代码必须加{}
golang允许在判断条件的位置定义变量

if 判断条件 {
    代码
}

if 判断条件 {
    代码
}else{
代码
}

if num := 0; num > 1 {
    fmt.Println("大于1")
}else if num < 1{
    fmt.Println("小于1")
}else{
    fmt.Println("等于1")
}

2. 循环

在golang里边没有while和do……while只有for。for循环和if判断一样不用加(),后面必须加{
break可以中断循环，continue可以跳过本次循环

for 创建变量:循环条件:表达式 {
    代码
}

for { //这是一个死循环
    代码
}

for 循环条件 { //类似于while
    代码
}

3. 分支结构

golang里边的分支结构和C++比较类似，但是case后面不用加break，case后面可以不用值，可以用表达式

a:=3  
switch a {  
case 1:  
    fmt.Println("one")  
case 2,3:  
    fmt.Println("two or three")  
default:  
    fmt.Println("others")  
}

a:=3  
switch {  
case a==1:  
    fmt.Println("one")  
case a==2,a==3:  
    fmt.Println("two or three")  
default:  
    fmt.Println("others")  
}

四.数组、切片、map、range

1. 数组、

golang语言的数组和C，C++一样长度固定
在实际应用中一般用切片

var a [5]int //数组创建
a[4] = 100  //数组创建
fmt.Println(a,len(a))
b := [5]int{1,2,3,4,5} //数组创建
var c:= [2][3]  //数组创建

2. 切片

切片是一个可变长度的数组，可以任意时刻更改长度，有更多操作。用make创建切片,用append往切片添加数据,copy可以复制切片。

S := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println(len(s),s[2]) //3,c
s=append(s,"d"，“e”)
fmt.Println(s)
c :=make([]string,len(s))
copy(c,s)
d := []string{"a","b","c"} //另一个方式创建

3. map

map的创建和接片类似,map是键值对的形式,map用delete删除,从map获取值时会多返回一个bool值判断map中是否有这个key的值,map整体输出是随机输出的不按输入顺序

a := make(map[string]int) //make(map[key]velue)
a["c1"] = 1  
a["c2"] = 1  
a["b1"] = 2  
c := map[string]int{"bb": 1, "cc": 2}  
r, ok := a["b2"]  
fmt.Println(r, ok) //0 false
r,ok = a["b1"]  
fmt.Println(r, ok) //2 true  
fmt.Println(c)  //map[bb:1 cc:2]
fmt.Println(a)  //map[b1:2 c1:1 c2:1]
delete(a,"c1")  
fmt.Println(a)  //map[b1:2 c2:1]

4. range

range可以快速遍历数组、切片和map。

a := make(map[string]int)  
a["c1"] = 1  
a["c2"] = 1  
a["b1"] = 2  
b := []string{"a", "b", "c", "d"}  
for k, v := range a {  
fmt.Println(k, "-", v)  //c1 - 1  c2 - 1  b1 - 2

}  
for k, v := range b {  //索引（key），值 := range b
fmt.Println(k, "-", v)  //0 - a   1 - b   2 - c   3 - d 
}

五.函数

函数可以减少代码冗余,降低代码维护成本。golang的函数写法如下
golang的函数可以有多个返回值

func func1(a int, b int) (int, bool) {  //func1(传入类型)(返回类型)
if a < b {  
return 0, false  
} else {  
return a - b, true
}  
}  
func main() {  
a, b := 1, 2  
fmt.Println(func1(a, b))  // 0 , false
fmt.Println(func1(3, 2))  // 1，true
}

六.指针

golang削弱对指针的依赖，在golang中经常用对值的修改

func main() {  
a := 1  
b := &a  
fmt.Printf("a:%d ptr:%p\n", a, &a) // a:1 ptr:0xc0000a6058  
fmt.Printf("b:%p type:%T\n", b, b) // b:0xc0000a6058 type:*int  
fmt.Println(&b) // 0xc0000ca018  
}

七.结构体

1. 结构体

结构体使用type和struct关键字来定义

type 结构体名 struct{
    结构体变量名  变量类型
    结构体变量名  变量类型
}

2. 结构体方法

type 结构体名 struct{
    结构体变量名  变量类型
    结构体变量名  变量类型
}
func (变量名 结构体名) func1(传入变量) 传出值类型{

}
main{
    变量名 := 结构体名{    结构体变量名  变量值，结构体变量名  变量值}
    变量名.func1（传入变量）
}

八.错误处理

错误处理在 go 语言里面符合语言习惯的做法就是使用一个单独的返回值来传递错误信息。不同于 Java 自家家使用的异常。go语言的处理方式，能够很清晰地知道哪个函数返回了错误，并且能用简单的 if else 来处理错误。在函数里面，我们可以在那个函数的返回值类型里面，后面加一个 error，就代表这个函数可能会返回错误。那么在函数实现的时候， return 需要同时 return 两个值，要么就是如果出现错误的话，那么可以 return nil 和一个 error。如果没有的话，那么返回原本的结果和 nil。

package main  
  
import (  
    "errors"  
    "fmt"  
)  
  
type user struct {  
    name string  
    password string  
}  
func main() {  
    u,err :=findUser([]user{{"wang","1024"}},"wang")  
    if err != nil {  
        fmt.Println(err)  
        return  
    }  
    fmt.Println(u.name)  
    u,err =findUser([]user{{"wang","1024"}},"li")  
    if err != nil {  
        fmt.Println(err)  
        return  
    }  
    fmt.Println(u.name)  
}  
func findUser(users []user,name string )(v *user,err error){  
    for _,u := range users{  
        if u.name==name {  
            return &u,nil  
        }  
    }  
    return nil,errors.New("not found")  
}

Go 语言入门指南 ｜ 青训营