一、GO语言的特点
1、语法简洁；Go语言简单易学，学习曲线平缓。
2、代码风格统一。
3、执行性能好
4、开发效率高
5、支持并发。
二、helloworld
//注意这里是main包，不论放在哪个目录下，都是main，才能被直接运行main方法
package main
//包导入
import "fmt"
//定义main方法
func main() {
fmt.Println("hello,world!")
}
三、基础语法
注意：在申明变量之后或者赋值之后，需要使用到变量，否则会报错。
1、常见变量
package main
import "fmt"
func main() {
//int变量有很多中，需要区分他们的范围
//int int8/int16/int32/int64
var a int
a = 1
print(a)
//float32 float64
var f float32
f = 123.1
print(f)
//空值nil
//字符串类型
var str string
str = "hello "
//可以直接拼接
str = str + "world"
fmt.Println(str)
}
2、变量的声明方式
//声明方式1 var 变量名
var a int
a = 1
print(a)
//声明方式2 变量名 := 赋值
b := 1
print(b)
3、if-else
//if-else
a := 10
//这里的判断不需要加上(),当然加上也不会有错
if a < 10 {
fmt.Println("a小于10")
} else if a > 10 {
fmt.Println("a大于10")
} else{
fmt.Println("啊等于10")
}
//if语句可以使用定义临时变量，使用分割符号进行
if b := 10; b > 10 {
fmt.Println("b小于10")
} else if c := 10;b > 10 && c > 10 {
fmt.Println("a大于10,c也大于10")
} else{
fmt.Println("啊等于10")
}
4、for循环
1)第一种for,死循环
package main
func main() {
//for循环
cnt := 0
//当计数器为10，退出循环
for {
if (cnt == 10) {
break
}
cnt++
}
}
2）for-range(遍历数组或者map等结构)
package main
import "fmt"
func main() {
var arr [3]int
arr[0] = 1
arr[1] = 2
arr[2] = 3
//index为数组的下标，value为数组的下标对应的值
for index, value := range arr {
fmt.Println(index, "---", value)
}
}
3 ) fori
package main
import "fmt"
func main() {
for i := 0; i < 10; i++ {
fmt.Println(i)
}
}
4、switch分支结构
package main
func main() {
i := 3
//不需要break
switch i {
case 1:
print("one")
case 2:
print("two")
case 3, 4:
print("three four")
default:
print("other")
}
}
5、数组以及声明
var arr [3]int
arr[0] = 1
arr[1] = 5
arr[2] = 10
print(arr)
6、切片（可变长度）
package main
import "fmt"
func main() {
var slice1 = make([]int, 3)
slice1[0] = 1
slice1[1] = 1
slice1[2] = 1
fmt.Println(slice1)
fmt.Println(len(slice1)) //3
//需要重新赋值给切片，因为append不会修改传入的切片
slice1 = append(slice1, 10)
fmt.Println(slice1)
fmt.Println(len(slice1)) //4
//slice[start:end],取出下标为start到end-1的元素
fmt.Println(slice1[2:4]) //1 10
//slice[:end] 0-end-1
fmt.Println(slice1[:4]) //1 1 1 10
//slice[start:] start到len(slice) - 1
fmt.Println(slice1[1:4]) //1 1 10
//slice[:]
fmt.Println(slice1[:]) //1 1 1 10
}
7、map哈希
package main
import "fmt"
func main() {
//map[key类型]value类型,key是唯一的
map1 := make(map[string]int)
map1["a"] = 1
map1["b"] = 1
fmt.Println(map1) //map[a:1 b:1]
//覆盖
map1["a"] = 2
fmt.Println(map1) //map[a:2 b:1]
//根据key获取value
const key1 = "a"
fmt.Println(map1[key1])
//遍历map
for key, value := range map1 {
fmt.Println(key, "---", value)
}
const key2 = "b"
//删除key
delete(map1, key2)
fmt.Println(map1)
}
8、函数
1）无参无返回值
func f1() {
fmt.Println("无参无返回值")
}
2）有参无返回值
// func 函数名(形参名 形参类型) {
// }
func f2(name string) {
fmt.Println("有参无返回值", name)
}
3）有参有一个返回值
// func 函数名(形参名 形参类型,...) (返回值名 返回值类型) {}
func f3(a int, b int) (c int) {
return a + b
}
4）有参有两个返回值
// func 函数名(形参名 形参类型,...) (返回值名 返回值类型) {}
func f4(a int, b int) (c int, d int) {
//使用逗号分割
return a + b, a * b
}
5)声明了函数返回值还可以这样用
func main() {
fmt.Println(f1(10)) //10 + 1 + 2
}
func f1(add int) (result int) {
result = 1
return 2 + result + add
}
函数调用
f1()
f2("zs")
add := f3(10, 20)
fmt.Println(add)
add1, mul := f4(10, 20)
fmt.Println(add1,"-",mul)
9、指针
package main
import "fmt"
func main() {
//1.定义指针
var prev *int
a := 10
prev = &a //此时prev指向a对应的地址
fmt.Println(prev) //打印的是地址
fmt.Println(*prev) //取值 *prev = 10
//2.函数传入的指针和不传入指针
f2(a)
fmt.Println(a)//10
f1(prev)
fmt.Println(*prev)//11
}
func f1(a *int) {
*a ++
}
func f2(a int) {
a ++
}
10、结构体
1）调用定义
package main
import "fmt"
type people struct {
name string
age int
}
func main() {
//1.创建一个结构体对象
p1 := people{name: "zs", age: 10}
fmt.Println(p1)
p2 := people{name: "ls"}
//使用对象.属性名，进行调用赋值
p2.age = 10
fmt.Println(p2)
}
2）结构体方法以及调用
package main
import "fmt"
type people struct {
name string
age int
}
func main() {
//1.创建一个结构体对象
p1 := people{name: "zs", age: 10}
fmt.Println(p1)
fmt.Println(p1.getName())
p1.setName("张三")
fmt.Println(p1.getName())
}
func (p people) getName() (name string) {
return p.name
}
//使用指针可以修改结构体对象的属性
func (p *people) setName(name string) () {
p.name = name
}
11、错误处理
func main() {
//调用并且捕获异常
err := errorTest(10, 20)
if err != nil {
fmt.Println("出现错误原因", err)
panic(err)
}
}
func errorTest(a int, b int) (err error) {
if a+b > 10 {
return errors.New("a + b不能大于10")
}
return nil
}
12、字符串操作API
基本都在strings工具类下面
func main() {
a := "hello"
//查看是否包含一个字符串
fmt.Println(strings.Contains(a, "ll"))
//统计出现字符串的个数
fmt.Println(strings.Count(a, "l"))
//比较字符串，与其他语言类似
fmt.Println(strings.Compare(a, "hell"))
//判断前缀
fmt.Println(strings.HasPrefix(a, "he"))
//判断后缀
fmt.Println(strings.HasPrefix(a, "llo"))
}
13、字符串格式化
package main
import (
"errors"
"fmt"
)
type people struct {
name string
age int
}
func main() {
str := "str1"
a := 123
p := people{"zkx", 18}
fmt.Printf("%v\n", str) //str
fmt.Printf("%v\n", a) //正常打印
fmt.Printf("%v\n", p) //正常打印
fmt.Printf("%+v\n", p) //打印出属性名:属性值
fmt.Printf("%#v\n", p) //打印出包名+属性名:属性值
f := 123.3455
//保留2位小数，会进行四舍五入
fmt.Printf("%.2f\n", f)
}
14、JSON处理
package main
import (
"encoding/json"
"fmt"
)
type people struct {
Name string `json:name`
Age int `json:age`
}
func main() {
//JSON序列化需要属性名大写,使用`json:指定名称`修改序列化的名称
p := people{"zkx", 18}
marshal, err := json.Marshal(p)
if err != nil {
panic(err)
}
fmt.Println(marshal)
fmt.Println(string(marshal))
//自定义格式
indent, err := json.MarshalIndent(p, "", "\t")
if err != nil {
panic(err)
}
fmt.Println(string(indent))
//反序列化
var p2 people
err = json.Unmarshal(marshal, &p2)
if err != nil {
panic(err)
}
fmt.Printf("%v\n", p2)
}
15、数字解析
package main
import (
"fmt"
"strconv"
)
func main() {
float, _ := strconv.ParseFloat("12.3", 64)
fmt.Println(float)
n, _ := strconv.ParseInt("123", 10, 64)
fmt.Println(n)
n1, _ := strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n1)
atoi, err := strconv.Atoi("AAA")
fmt.Println(atoi, err)
}
