Golang基础

一.go的四个运行命令

go 命令文件名要么根据绝对路径去找,要么能在当前cmd路径下找到
go 命令项目名去src下找

go run 编译并执行,不保存编译后的文件
2 go build 编译并保存
默认放在当前cmd路径下
-o 路径
3 go install 编译并放在gopath下的bin目录下
4 go fmt 格式化代码

//表明当前文件是可执行文件
//准确的说:表明当前文件属于可执行程序的根目录,可以加上func main
package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("hello world")
	time.Sleep(10 * time.Second)
}

二.变量

5种声明方式：
1 var 变量名... 类型字面量有默认值，int 0，bool false,string ""

	var a,d int
	var b string
	var c bool
	fmt.Println(a) // 0
	fmt.Printf("%q
",b) // ""
	fmt.Println(c)  // false
	fmt.Println(d)  // 0

2 var 变量名1... 类型字面量 = 变量值1... 声明变量，给定初始值

	var a,v int = 10,100
	var b string = "老王"
	var c bool = true
	fmt.Println(a,b,c,v) // 10 老王 true 100

3.var 变量名1... = 变量值1...

	var a,b,c = 100,10,false
	fmt.Println(a,reflect.TypeOf(a)) // 100 int
	fmt.Println(b,reflect.TypeOf(b)) // 10 int
	fmt.Println(c,reflect.TypeOf(c)) // false bool
	b  = 100
	fmt.Println(a==b)   //true

4.变量名1... := 变量值1...
适用条件:1.只能用于局部
2.边至少有一个变量未被声明

	var a int
	b,a := "10",100
	fmt.Println(a,reflect.TypeOf(a))
	fmt.Println(b,reflect.TypeOf(b))

5 var(
变量名... 类型字面量
变量名1... 类型字面量 = 变量值1...
变量名1... = 变量值1...
)

   var (
   	a int
   	b string = "隔壁老王"
   	c,d = 10.2,true
   )
   fmt.Println(a,b,c,d)//0 隔壁老王 10.2 true

变量赋值:
1 先声明后使用
2 赋值类型要一直
3 a,b,c = 值1,值2,值3
4 交叉赋值

变量的命名规范:
推荐使用驼峰体
小写开头,只用于本包下使用
大写开头,用于开放

	var a,b = 10,100
	a,b = b,a
	fmt.Println(a,b)//100 10

三.常量

go 常量内存权限只读
定义常量的三种方式

const 常量名1... 类型字面量 = 值1... 没有初始值

	const a,b int = 100,10
	fmt.Println(a)//100

const 常量名1... = 值1...

    const c,d = 100,true
	fmt.Println(c,d)//100 true

3 const( 常量组若没有指定类型和值,会继承上面最靠近它的飞空常量,并且列数要相等
....
...
)

const(
    a,e int = 10,100
    b,f string = "张三","lxxdsb"
    c,m
    d,n
)
fmt.Println(a,b)
fmt.Println(c,reflect.TypeOf(c))//10 张三
fmt.Println(d,reflect.TypeOf(d))//张三 string
fmt.Println(m,reflect.TypeOf(m))//lxxdsb string

自增常量组:
1 iota 常量计数器从0开始计数,类型默认为int
2 _ 占位符占着茅坑不拉shit
3 iota中断定义一个值
4 iota 恢复继续写iota ,会继续计数(计数不会中断)
5 多个iota

const (
		_ = iota
		a
		b
		c string = "老王"
		d  = iota
		e
		f
		h
	)
	fmt.Println(a,b,c) // 1 2 老王
	fmt.Println(d,e,f,h)// 4 5 6

type 名字类型字面量自定义类型,给类型起别名
6 iota 可以修改类型
7 iota 可以参与运算

type myint int
const (
    a myint= iota
    b
)
fmt.Println(a,b,reflect.TypeOf(b))//0 1 main.myint

四.运算符

数字与数字间加减乘除,只要其中一个是小数,结果是浮点型,整形与整形,结果一定是整形
程序只会在特定情况下(遇到浮点型,不管是变量还是数字),会把整形数字转成浮点型数字,再进行运算,
但是,不会自动转换整形变量,(常量当做普通数字处理)

//var a = 1+2
//fmt.Println(a,reflect.TypeOf(a))

//var a = 2.1 + 1
//fmt.Println(a,reflect.TypeOf(a))

//var a = 3/2
//fmt.Println(a,reflect.TypeOf(a))

//var a = 10/3
//	//fmt.Println(a,reflect.TypeOf(a))

//var a = ((1/2)+0.5)*3
//fmt.Println(a,reflect.TypeOf(a))


//var a = 3
//const b = 2.5
//var c = a/2.5
//fmt.Println(c,reflect.TypeOf(c))

//fmt.Println(true || false && true && false)


//var a = 60
//var b = 13
////      00001100
//fmt.Println(a&b)

//var a = 100
//var b = &*&a   //*类型
//var c = &a
//fmt.Println(b,c)

//fmt.Println(b,reflect.TypeOf(b))
//*b += 200
//fmt.Println(a)

五.流程控制

if 判断

5个知识点
1 if 条件 {
代码体...
}

	var age int
    // 用户交互，输入年龄
	fmt.Scanln(&age)

	if age>20 {
		fmt.Println("阿姨好")
	}else{
		fmt.Println("小姐好")
	}

2 if-else

3 if-else if - else

4 if嵌套

var score int
fmt.Print("输入你的分数:")
if _, err := fmt.Scanln(&score); err != nil {
    fmt.Println("输入有误")
}else{
    if score >= 90{
        fmt.Println("优秀")
    }else if score>= 70{
        fmt.Println("良好")
    }else{
        fmt.Println("挨打！")
    }
}

5 if [可执行语句;]条件{ 可执行语句里要是声明变量,只能用短声明

if a:=1;true{
    fmt.Println(a)
    fmt.Println("我又进来了")
}

switch

2 switch分支选择
一 switch[可执行语句;] 判断量{
case 被判断量1,被判断量2: if 判断量被判断量1 || 判断量被判断量2
代码
case 被判断量3:
代码
default:
代码
}

break 基本用不上
fallthrough 放在判断末尾，直接进入下case的代码

var people string
fmt.Print("有人来了:")
fmt.Scanln(&people)

var isugly = true

switch people {
case "帅哥","老板":
    fmt.Println("你好呀")
case "姑娘":
    if isugly{
        fmt.Println("假装没看见")
    }else {
        fmt.Println("加个微信吧！")
    }
default:
    fmt.Println("问路请出门右拐")
}

二 switch [可执行语句;]{
case 条件1,条件2...
代码提
case 条件3
代码体

switch score := 100; {
case score>=90:
    fmt.Println("牛逼")
case score>=80:
    fmt.Println("也牛逼")
}

for 循环:

格式:
for 初始条件;循环条件;追加条件{
循环体代码....
}

//var a = 1
//for fmt.Println("我是初始条件");a<=3;fmt.Println("我是追加语句"){
//	a += 1
//}

省略形式:
for ;循环条件;追加条件{
循环体代码....
}

for a:=1;a<=3;{
    fmt.Printf("我执行了第%v遍
",a)
    a++
}

for 初始条件;循环条件;{
循环体代码....
}

for a:=1;a<=3;{
    fmt.Printf("我执行了第%v遍
",a)
    a++
}

for 循环条件{
循环体代码....
}

a:=1
for a<=3{
    fmt.Printf("我执行了第%v遍
",a)
    a++
}

for {
循环体代码....
}
是一个死循环

a := 1
for {
    fmt.Printf("我执行了第%v遍
",a)
    a++
}

for 循环的退出:
1 break 跳出本层循环
2 continue 结束本次循环，直接进入下一次
3 变量开关

for a,tag:=1,true;tag;a++{
    if a==3 {
        tag = false
    }
    fmt.Printf("我执行了第%v遍
",a)

}

什么是标签:
记录被标签者的信息
在程序中记录当前代码位置
为什么要有标签:
标记不是目的,目的是使用.记录位置是为了快速找到它
怎么用标签:
定义标签: 直接在代码上加上标签名(大写加数字用以和变量区分开),定义了就一定要使用
用标签:
1 break+标签
2 continue + 标签
3 goto + 标签降低了代码的可读性和可维护性
注意点:
1 只能用于函数内部跳转
2 不能跳过变量声明

LABEL1:
    for a:=1;a<=5;a++{
        fmt.Printf("外层执行了第%v遍
",a)
        for i:=1;i<=5;i++{
            fmt.Printf("内层执行了第%v遍
",i)
            if i == 3{
                continue LABEL1
            }
        }
    }
    
    
    for a:=1;a<=5;a++ {
        fmt.Printf("外层执行了第%v遍
", a)
        if a==3{
            goto LABEL2
        }
    }

LABEL2:
    fmt.Println("我是label,我被执行了")
    fmt.Println("我是label,我被执行了2")

六.基本数据类型

整型:
有符号:int , int8 ,int16,int32,int64
无符号:uint,uint8,uint16,uint32,uint64

int8: -128-127
正常使用:int,int64,uint,uint64

浮点型:
float32,float64

flaot32:显示8位,精确到7位
float64:显示17位，精确到16位（含整数位）

强制类型转换:
数字类型和数字类型之间进行转换,转换类型要能够完全表示被转换类型

var a int64  = 1111111
var b int8 = int8(a)
fmt.Println(b,reflect.TypeOf(b))// 71 int8

字符串类型:
string
strings包:字符串常用操作

判断是否以...开头
HasPrefix(str,"....")

str := "我真的真的真的真的很帅"

fmt.Println(strings.HasPrefix(str, "我"))// true
fmt.Println(strings.HasPrefix(str,"你"))// false
fmt.Println("----------------")

2 以....结尾
HasSuffix(str,"...")

fmt.Println(strings.HasSuffix(str,"帅"))// true
fmt.Println(strings.HasSuffix(str,"丑"))//false
fmt.Println("----------------")

3 是否包含....
Contains(str,"....")

fmt.Println(strings.Contains(str,"真的"))//ture
fmt.Println(strings.Contains(str,"假的"))//false
fmt.Println("----------------")

4 是否包含...中任意字符
ContainsAny(str,"....")

fmt.Println(strings.ContainsAny(str,"真的"))
fmt.Println(strings.ContainsAny(str,"你的"))
fmt.Println("----------------")

5 查找...的第一次出现的索引
Index(str,"....")

fmt.Println(strings.Index(str,"假的"))//-1
fmt.Println(strings.LastIndex(str,"真的"))//22
fmt.Println(strings.LastIndex(str,"1"))//-1
fmt.Println("----------------")

6 查找...的最后一次出现的索引
LastIndex(str,"....")

fmt.Println("----------------")
fmt.Println(strings.LastIndex(str,""))//33
fmt.Println("----------------")

7 替换
Replace(str,oldstr,newstr,n)

fmt.Println(strings.Replace(str,"真的","超级",1))//我超级真的真的真的很帅
fmt.Println(strings.Replace(str,"真的","超级",2))//我超级超级真的真的很帅
fmt.Println(strings.Replace(str,"真的","超级",-1))//我超级超级超级超级很帅
fmt.Println("----------------")

8 统计字符串出现次数
Count(str,"...")

fmt.Println(strings.Count(str,"真的"))//4
fmt.Println(strings.Count(str,""))//12
fmt.Println(strings.Count(str,"dsb"))//0
fmt.Println("字符个数:",strings.Count(str,"")-1)//11

9 大小写转换
ToUpper(str)/ToLower(str)

str2 := "老s王dSB abs BS"
fmt.Println(strings.ToUpper(str2))//老S王DSB ABS BS
fmt.Println(strings.ToLower(str2))//老s王dsb abs bs
fmt.Println(strings.ToTitle(str2))//老S王DSB ABS BS

10 去除指定字符(首/尾)
Trim(str,"...")
TrimLeft()
TrimRight()
TrimSpace(str)

11 分割
Split(str,"...") 根据指定分隔符号,转成切片[a b c d]
```go
str4:="a,b,c,d"
fmt.Println(strings.Split(str4,","))//[a b c d]


12  拼接
	Join(字符串切片,"拼接符")
```go
    myslice := strings.Split(str4,",") 
	fmt.Println(strings.Join(myslice,"@"))//a@b@c@d