go实战基础 （一）

package main
import "fmt"
func main() {
    // fmt.Println("你好golang")
    fmt.Println("你好golang")
    fmt.Print("aaa")
    fmt.Print("bbb")
    fmt.Print("ccc")
    fmt.Println("aaa")
    fmt.Println("bbb")
    fmt.Println("ccc")
    fmt.Println("go", "python", "php", "javascript")
    fmt.Print("go", "python", "php", "javascript")
}

package main
import "fmt"
func main() {
    // fmt.Println("你好 golang")
    // fmt.Print("你好 golang")
    // fmt.Printf("你好 golang")
    /*
        fmt.Println("你好 golang")
        fmt.Print("你好 golang")
    */
    //     ctrl+/ 单行注释       ctrl+/ 也可以解除单行注释
    /*
        Print Println区别
            1、一次输入多个值的时候 Println 中间有空格 Print 没有
            2、Println 会自动换行，Print 不会
    */
    // fmt.Println("你好 golang")
    // fmt.Print("你好 golang")
    // fmt.Print("A")
    // fmt.Print("B")
    // fmt.Print("C")
    // fmt.Println("A")
    // fmt.Println("B")
    // fmt.Println("C")
    // fmt.Print("A", "B", "C")
    // fmt.Println("A", "B", "C")
    /*
        Println 和 Printf 区别
            1、Println默认会换行，Printf默认不会
            2、Printf是格式化输出 比Println功能更强大更灵活
    */
    // var a = "aaa" //go语言中变量定义以后必须要使用
    // fmt.Println(a)
    // var a = "aaa" //go语言中变量定义以后必须要使用
    // fmt.Printf("%v", a)
    // var a int = 10
    // var b int = 3
    // var c int = 5
    // fmt.Println("a=", a, "b=", b, "c=", c)
    // fmt.Println("a=", a, "b=", b, "c=", c)
    // fmt.Printf("a=%v b=%v c=%v\n", a, b, c)    //   \n表示换行
    // fmt.Printf("a=%v b=%v c=%v", a, b, c)
    //类型推导方式定义变量
    a := 10
    b := 20
    c := 30
    fmt.Printf("a=%v b=%v c=%v\n", a, b, c)
    //使用Printf打印一个变量的类型
    fmt.Printf("a=%v a的类型是%T", a, a)
}

package main
import "fmt"
func getUserinfo() (string, int) {
    return "zhangsan", 10
}
var g = "全局变量"
// gl := "全局变量 _端变量声明法  错误写法"
func main() {
    fmt.Println(g)
    // fmt.Println(gl)
    /*
       1、 var 声明变量
           var 变量名称 类型
           变量名称的命名：Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。Go 语言中关键字 和保留字都不能用作变量名。
    */
    // var username string
    // fmt.Println(username)   //变量声明后没有初始化的话  值为空
    // var a1="张三"
    // fmt.Println(a1)
    // var 1a string   //错误：go变量的首个字符不能为数字
    // fmt.Println(1a)
    // var m_a="李四"   //正确 不推荐
    // fmt.Println(m_a)
    // var if="李四"  //错误  Go 语言中关键字 和保留字都不能用作变量名。
    // fmt.Println(if)
    //go语言变量的定义以及初始化
    //第一种初始化变量的方式
    // var username string
    // username = "张三"
    // fmt.Println(username)
    //第二种初始化变量的方式
    // var username string = "张三"
    // fmt.Println(username)
    //第三种初始化变量的方式
    // var username = "张三"
    // fmt.Println(username)
    /*
        Go 语言中的变量需要声明后才能使用，同一作用域内不支持重复声明
        var username = "张三"
        var age = 20
        var sex="男"
        fmt.Println(username,age,sex)
        var username = "李四"
    */
    /*
        var username = "张三"
        var age = 20
        var sex="男"
        username = "李四"   //赋值
        fmt.Println(username,age,sex)  //输出：李四 20 男
    */
    /*
        2、 一次定义多个变量
            var 变量名称, 变量名称 类型
            var (
                变量名称 类型
                变量名称 类型
            )
    */
    /*
        var a1, a2 string
        a1 = "aaa"
        a2 = "aaaaaaaaaaa"
        fmt.Println(a1, a2)
    */
    /*
        var a1, a2 string
        a1 = "aaa"
        a2 = 123 //错误写法  go语言中定义的类型是string类型 赋值的时候必须赋值string类型的数据
        fmt.Println(a1, a2)
    */
    /*
        var (
            username string
            age      int
            sex      string
        )
        username = "张三"
        age = 20
        sex = "男"
        fmt.Println(username, age, sex)
    */
    /*
        var (
            username = "张三"
            age      = 20
        )
        fmt.Println(username, age)
    */
    /*
        3、短变量声明法 在函数内部，可以使用更简略的 := 方式声明并初始化变量。
        注意：短变量只能用于声明局部变量，不能用于全局变量的声明
    */
    // var username = "张三"
    /*
        username := "张三"
        fmt.Println(username)
        fmt.Printf("类型:%T", username)
    */
    // 使用端变量一次声明多个变量，并初始化变量
    // a, b, c := 12, 13, 20
    // fmt.Println(a, b, c)
    // a, b, c := 12, 13, "C"
    // fmt.Println(a, b, c)
    // fmt.Printf("a类型:%T b类型:%T c类型:%T", a, b, c)
    /*
        4、匿名变量 在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。
        匿 名变量用一个下划线_表示，例如
        func getUserinfo() (string, int) {
            return "zhangsan", 10
        }
    */
    // var username, age = getUserinfo()
    // fmt.Println(username, age) //zhangsan 10
    var username, _ = getUserinfo()
    fmt.Println(username) //zhangsan
    //匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明
    var _, age = getUserinfo()
    fmt.Println(age) //10
}

package main
func main() {
    // var username = "张三"
    // username = "李四"
    // username = "王五"
    // fmt.Println(username)
    //1、go语言中的常量
    // const pi = 3.14159
    // fmt.Println(pi)
    // const A = "A"
    // A = "AAA"  //cannot assign to A  常量的值不可以改变
    // fmt.Println(A)
    //2、多个常量也可以一起声明
    // const (
    //     A = "A"
    //     B = "B"
    // )
    // fmt.Println(A, B)
    //3、const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同。
    // const (
    //     n1 = 100
    //     n2
    //     n3
    //     n4
    // )
    // fmt.Println(n1, n2, n3, n4)
    /*
        4、iota 是 golang 语言的常量计数器,只能在常量的表达式中使用。
            iota 在 const 关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量 声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)
    */
    // const a = iota
    // fmt.Println(a)
    // const (
    //     n1 = iota
    //     n2
    //     n3
    //     n4
    // )
    // fmt.Println(n1, n2, n3, n4) //0 1 2 3
    // const (
    //     n1 = iota
    //     _
    //     n3
    //     n4
    // )
    // fmt.Println(n1, n3, n4) //0  2 3
    //iota 声明中间插队
    // const (
    //     n1 = iota //0
    //     n2 = 100  //100
    //     n3 = iota //2
    //     n4        //3
    // )
    // fmt.Println(n1, n2, n3, n4)
    //多个 iota 定义在一行
    // const (
    //     n1, n2 = iota + 1, iota + 2 //1  2
    //     n3, n4                      //2 3
    //     n5, n6                      //3 4
    // )
    // fmt.Println(n1, n2)
    // fmt.Println(n3, n4)
    // fmt.Println(n5, n6)
    //定义变量
    // n1, n2 := 20, 30
    // fmt.Println(n1, n2)
    //5、go语言中变量的名字是区分大小写的
    // var age = 20
    // var Age = 30
    // fmt.Println(age, Age)
    // var username = "zhangsan"
    // var DNS = "192.112.23.2"
}

package main
import (
    "fmt"
    "github.com/shopspring/decimal"
)
func main() {
    price, err := decimal.NewFromString("136.02")
    if err != nil {
        panic(err)
    }
    quantity := decimal.NewFromInt(3)
    fee, _ := decimal.NewFromString(".035")
    taxRate, _ := decimal.NewFromString(".08875")
    subtotal := price.Mul(quantity)
    preTax := subtotal.Mul(fee.Add(decimal.NewFromFloat(1)))
    total := preTax.Mul(taxRate.Add(decimal.NewFromFloat(1)))
    fmt.Println("Subtotal:", subtotal)                      // Subtotal: 408.06
    fmt.Println("Pre-tax:", preTax)                         // Pre-tax: 422.3421
    fmt.Println("Taxes:", total.Sub(preTax))                // Taxes: 37.482861375
    fmt.Println("Total:", total)                            // Total: 459.824961375
    fmt.Println("Tax rate:", total.Sub(preTax).Div(preTax)) // Tax rate: 0.08875
}

package main
import (
    "fmt"
    "github.com/shopspring/decimal"
)
func main() {
    // //加
    var num1 float64 = 3.1
    var num2 float64 = 4.2
    d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(num2))
    fmt.Println(d1)
    //减去
    m1 := 8.2
    m2 := 3.8
    m3 := decimal.NewFromFloat(m1).Sub(decimal.NewFromFloat(m2))
    fmt.Println(m3)
    // 减法 Sub，乘法 Mul， 除法 Div 用法均与上述类似
}

package main
import "strings"
func main() {
    //1、定义string类型
    // var str1 string = "你好golang"
    // var str2 = "你好 go"
    // str3 := "你好golang"
    // fmt.Printf("%v--%T\n", str1, str1)
    // fmt.Printf("%v--%T\n", str2, str2)
    // fmt.Printf("%v--%T\n", str3, str3)
    //2、字符串转义符
    // str1 := "this \nis str" //换行
    // fmt.Println(str1)
    // str2 := "C:\\Go\\bin" //C:\Go\bin    输出反斜杠
    // fmt.Println(str2)
    /*
        C:Go"bin
    */
    // str2 := "C:Go\"bin"
    // fmt.Println(str2)
    // 3、多行字符串   `(反引号)  tab键上面
    // str1 := `this is str
    // this is str
    //                 this is str111
    // this is str
    // this is str
    // `
    // fmt.Println(str1)
    // 4、len(str) 求长度
    // var str1 = "aaaa" //长度4
    // fmt.Println(len(str1))
    // var str1 = "你好" //长度6
    // fmt.Println(len(str1))
    // 5、+ 或者 fmt.Sprintf拼接字符串
    // str1 := "你好"
    // str2 := "golang"
    // str3 := str1 + str2
    // fmt.Println(str3)
    // str1 := "你好"
    // str2 := "golang"
    // str3 := fmt.Sprintf("%v %v", str1, str2)
    // fmt.Println(str3)
    // str1 := "反引号间换行将被作为字符串中的换" +
    //     "文本将会原样输出" +
    //     "行，但是所有的转义字符均无效"
    // fmt.Println(str1)
    //6、strings.Split 分割字符串  strings需要引入strings包
    // var str1 = "123-456-789"
    // arr := strings.Split(str1, "-")
    // fmt.Println(arr) //[123 456 789] 切片 （简单的理解切片就是数组  在golang中切片和数组还有一些区别）
    //7、strings.Join(a[]string, sep string) join 操作  表示把切片链接成字符串
    // var str1 = "123-456-789"
    // arr := strings.Split(str1, "-")
    // str2 := strings.Join(arr, "*")
    // fmt.Println(str2) //123*456*789
    // arr := []string{"php", "java", "golang"} //切片 后期会详细讲
    // // fmt.Println(arr)
    // str3 := strings.Join(arr, "-")
    // // fmt.Println(str3)
    // fmt.Printf("%v - %T", str3, str3)
    //8、 strings.contains 判断是否包含
    // str1 := "this is str"
    // str2 := "thisxxx"
    // flag := strings.Contains(str1, str2)
    // fmt.Println(flag)
    //9、strings.HasPrefix,strings.HasSuffix 前缀/后缀判断
    // str1 := "this is str"
    // str2 := "this"
    // flag := strings.HasPrefix(str1, str2)
    // fmt.Println(flag)
    // str1 := "this is str"
    // str2 := "str"
    // flag := strings.HasSuffix(str1, str2)
    // fmt.Println(flag)
    //10、 strings.Index(),strings.LastIndex() 子串出现的位置  查找不到返回-1 查找到返回下标位置 下标是从0开始的
    // str1 := "this is str"
    // str2 := "is"
    // num := strings.Index(str1, str2)
    // print(num) //返回2
    // str1 := "this is str"
    // str2 := "is"
    // num := strings.LastIndex(str1, str2)
    // print(num)  //返回5
    // str1 := "this is str"
    // str2 := "s"
    // num := strings.LastIndex(str1, str2)
    // print(num)  // 返回 8
    str1 := "this is str"
    str2 := "xxx"
    num := strings.Index(str1, str2)
    print(num) //-1 查找不到返回-1
}

package main
import "fmt"
func main() {
    /*
        Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。
        注意：
        1.布尔类型变量的默认值为false。
        2.Go 语言中不允许将整型强制转换为布尔型.
        3.布尔型无法参与数值运算，也无法与其他类型进行转换。
    */
    // var flag = true
    // fmt.Printf("%v--%T", flag, flag)
    //1.布尔类型变量的默认值为false。
    // var b bool
    // fmt.Printf("%v", b)
    //2.string型变量的默认值为空。
    // var s string
    // fmt.Printf("%v", s)
    //3.int型变量的默认值为0。
    // var i int
    // fmt.Printf("%v", i)
    //4.float型变量的默认值为0。
    // var f float32
    // fmt.Printf("%v", f)
    //5、Go 语言中不允许将整型强制转换为布尔型.
    // var a = 1
    // if a { //错误写法
    //     fmt.Printf("true")
    // }
    //6.布尔型无法参与数值运算，也无法与其他类型进行转换。
    // var s = "this is str"
    // if s { //错误写法
    //     fmt.Printf("true")
    // }
    var f1 = false
    if f1 { //正确写法
        fmt.Printf("true")
    } else {
        fmt.Printf("false")
    }
}

package main
func main() {
    //1、golang中定义字符  字符属于int类型
    // var a = 'a'
    // fmt.Printf("值：%v  类型:%T", a, a) //值：97  类型:int32
    //当我们直接输出 byte（字符）的时候输出的是这个字符对应的码值
    //2、原样输出字符
    // var a = 'a'
    // fmt.Printf("值：%c  类型:%T", a, a) //值：a  类型:int32
    //3、定义一个字符串输出字符串里面的字符
    // var str = "this"
    // fmt.Printf("值：%v 原样输出%c  类型:%T", str[2], str[2], str[2])
    //4、一个汉子占用 3个字节(utf-8), 一个字母占用一个字节
    // unsafe.Sizeof() 没法查看string类型数据所占用的存储空间
    // var str = "this" //占用4个字节
    // fmt.Println(len(str))
    // var str = "你好go" //8
    // fmt.Println(len(str))
    // 5、定义一个字符 字符的值是汉子
    //golang中汉子使用的是utf8编码 编码后的值就是int类型
    // var a = '国'
    // fmt.Printf("值：%v  类型:%T\n", a, a) //Unicode编码10进制  值：22269  类型:int32
    // fmt.Printf("值：%c  类型:%T", a, a)
    //6、通过循环输出字符串里面的字符
    // s := "你好 golang"
    // for i := 0; i < len(s); i++ {   //byte
    //     fmt.Printf("%v(%c) ", s[i], s[i])
    // }
    // s := "你好 golang"
    // for _, v := range s { //rune
    //     fmt.Printf("%v(%c) ", v, v)
    // }
    //7、修改字符串
    // s1 := "big"
    // byteStr := []byte(s1)
    // byteStr[0] = 'p'
    // fmt.Println(string(byteStr))
    // s1 := "你好golang"
    // runeStr := []rune(s1)
    // runeStr[0] = '大'
    // fmt.Println(string(runeStr))
}

package main
func main() {
    //1、整型和整型之间的转换
    // var a int8 = 20
    // var b int16 = 40
    // fmt.Println(int16(a) + b)
    //2、浮点型和浮点型之间的转换
    // var a float32 = 20
    // var b float64 = 40
    // fmt.Println(float64(a) + b)
    //3、整型和浮点型之间的转换
    // var a float32 = 20.23
    // var b int = 40
    // fmt.Println(a + float32(b))
    //注意：转换的时候建议从低位转换成高位，高位转换成低位的时候如果转换不成功就会溢出，和我们想的结果不一样。
}

package main
import (
    "fmt"
    "strconv"
)
func main() {
    //1、通fmt.Sprintf() 把其他类型转换成 String 类型
    //注意：Sprintf 使用中需要注意转换的格式 int 为%d  float 为%f  bool 为%t   byte 为%c
    /*
        var i int = 20
        var f float64 = 12.456
        var t bool = true
        var b byte = 'a'
        str1 := fmt.Sprintf("%d", i)
        fmt.Printf("值：%v 类型：%T\n", str1, str1)
        str2 := fmt.Sprintf("%.2f", f)
        fmt.Printf("值：%v 类型：%T\n", str2, str2)
        str3 := fmt.Sprintf("%t", t)
        fmt.Printf("值：%v 类型：%T\n", str3, str3)
        str4 := fmt.Sprintf("%c", b)
        fmt.Printf("值：%v 类型：%T\n", str4, str4)
    */
    //2、通过strconv  把其他类型转换成string类型
    /*
        FormatInt
        参数1：int64 的数值
        参数2：传值int类型的进制
    */
    // var i int = 20
    // str1 := strconv.FormatInt(int64(i), 10)
    // fmt.Printf("值：%v 类型：%T\n", str1, str1)
    /*
        参数 1：要转换的值
        参数 2：格式化类型 'f'（-ddd.dddd）、
             'b'（-ddddp±ddd，指数为二进制）、
             'e'（-d.dddde±dd，十进制指数）、
             'E'（-d.ddddE±dd，十进制指数）、
             'g'（指数很大时用'e'格式，否则'f'格式）、
             'G'（指数很大时用'E'格式，否则'f'格式）。
         参数 3: 保留的小数点 -1（不对小数点格式化）
         参数 4：格式化的类型 传入 64  32
    */
    // var f float32 = 20.231313
    // str2 := strconv.FormatFloat(float64(f), 'f', 4, 32)
    // fmt.Printf("值：%v 类型：%T\n", str2, str2)
    // str3 := strconv.FormatBool(true) //没有任何意义
    // fmt.Printf("值：%v 类型：%T\n", str3, str3)
    a := 'b' //没有任何意义
    str4 := strconv.FormatUint(uint64(a), 10)
    fmt.Printf("值：%v 类型：%T\n", str4, str4) //值：98 类型：string
}

package main
import (
    "fmt"
    "strconv"
)
func main() {
    //1、string类型转换成整型
    // str := "123456"
    // fmt.Printf("%v--%T\n", str, str)
    /*
        ParseInt
        参数1：string数据
        参数2：进制
        参数3：位数 32 64 16
    */
    // num, _ := strconv.ParseInt(str, 10, 64)
    // fmt.Printf("%v--%T", num, num)
    /*
        ParseFloat
        参数1：string数据
        参数2：位数 32 64
    */
    // str := "123456.333xxxx"
    // num, _ := strconv.ParseFloat(str, 64)
    // fmt.Printf("%v--%T", num, num)
    //不建议把string类型转换成bool型
    b, _ := strconv.ParseBool("xxxxxxx") // string 转 bool
    fmt.Printf("值：%v 类型：%T", b, b)
}

package main
import "fmt"
func main() {
    //1、定义int类型
    // var num int = 10
    // num = 22
    // fmt.Printf("num=%v 类型:%T", num, num)
    //2、int8的范围演示
    // var num int8 = 98
    // fmt.Printf("num=%v 类型:%T", num, num)
    // (-128 到 127)  错误
    // var num int8 = 130 //constant 130 overflows int8
    // fmt.Printf("num=%v 类型:%T", num, num)
    // var num int16 = 130 //ok
    // fmt.Printf("num=%v 类型:%T", num, num)
    //3、uint8的范围(0-255)
    // var n1 uint8 = -2 //constant -2 overflows uint8
    // fmt.Printf("n1=%v 类型:%T\n", n1, n1)
    // var n2 uint8 = 200 //constant -2 overflows uint8
    // fmt.Printf("n2=%v 类型:%T\n", n2, n2)
    //4、int8 int16 ... 占用的存储空间大小  unsafe.Sizeof 查看不同长度的整型 在内存里面的存储空间
    // var a int8 = 15
    // fmt.Printf("num=%v 类型:%T\n", a, a)
    // fmt.Println(unsafe.Sizeof(a)) // 1个字节
    // var a int32 = 15
    // fmt.Printf("num=%v 类型:%T\n", a, a)
    // fmt.Println(unsafe.Sizeof(a)) // 4个字节
    //5、int类型转换
    // var a1 int32 = 10
    // var a2 int64 = 21
    // fmt.Println(int64(a1) + a2) //把a1转换成64位
    // fmt.Println(a1 + int32(a2)) //把a2转换成32位
    //高位向底位转换的时候要注意
    // var n1 int16 = 130
    // fmt.Println(int8(n1)) //-126  有问题了
    // var n2 int16 = 110
    // fmt.Println(int8(n2)) //110
    // fmt.Println(int64(n2)) //110
    //6、数字字面量语法  %d 表示10进制输出 %b表示二进制输出 %o 八进制输出 %x 表示16进制输出(了解)
    // num := 30
    // fmt.Printf("num=%v 类型：%T\n", num, num)
    // fmt.Println(unsafe.Sizeof(num)) //表示64位的计算机 int就是int64   占用8个字节
    num := 12
    fmt.Printf("num=%v\n", num) //%v 原样输出
    fmt.Printf("num=%d\n", num) //%d 表示10进制输出
    fmt.Printf("num=%b\n", num) //%b 表示二进制输出
    fmt.Printf("num=%o\n", num) //%o 表示八进制输出
    fmt.Printf("num=%x\n", num) //%x 表示16进制输出
}