Go语言基础语法_2_2021-10-29_if v, err := t.(int)-CSDN博客

用户数据输入

从命令行中输入一个变量，如果是String类型是没有问题，但是int类型，目前得出错误的值。

package main

import "fmt"

func main() {
    var name string
    fmt.Println("请输入名字 ：")
    fmt.Scan(&name)

    fmt.Println("你输入的名字是：" + name)

    var age int
    fmt.Println("请输入的年龄 ")
    fmt.Println(&age)
    fmt.Println("你输入的年龄是", age)

    var height float64
    fmt.Println("请输入身高：")
    fmt.Scan(&height)
    fmt.Println("身高", height)

}

输出结果：
请输入名字 ：
ioewi
你输入的名字是：ioewi
请输入的年龄 
0xc0000b2018
你输入的年龄是 0
请输入身高：
b
身高 0

流程控制

我们经常需要代码在满足一定条件进进行执行，或者需要重复执行代码多次，此时需要选择条件语句（if-else ,if-sele ）或选择语句。

条件语句的笑话：
程序员老婆给程序员打电话，下班回家买10个包子，如果看到西瓜，买一个。
程序员到家，买了一个包子；
老婆怒道：你怎么只买了一个包子。
程序员说：你不是说我看到西瓜，就买一个包子。

if

package main

import "fmt"

func main() {

    var yes string
    fmt.Scan(&yes)
    fmt.Println("老婆的想法:")
    fmt.Println("十个包子")

    if yes == "Y" || yes == "y" {
        fmt.Println("买一个西瓜")
    }

    fmt.Println("老公的想法 ")
    if yes == "Y" || yes == "y" {
        fmt.Println("买成一个包子")
    } else {
        fmt.Println("买10个包子")
    }

    var score int
    fmt.Println("请输入成绩:")
    fmt.Scan(&score)
    if score >= 90 {
        fmt.Println("A")
    } else if score >= 80 {
        fmt.Println("B")
    } else if score >= 70 {
        fmt.Println("C")
    } else if score >= 60 {
        fmt.Println("D")
    } else {
        fmt.Println("F")
    }

}

switch

package main

import "fmt"

func main() {
	var yes string
	fmt.Scan(&yes)
	fmt.Println("老婆的想法:")
	fmt.Println("十个包子")

	switch yes {
	case "Y", "X": //可以写多个变量，Java中只允许写一个变量
		fmt.Println("买一个西瓜")
		break
	case "y":
		fmt.Println("买两个西瓜")
		break
	default:
		fmt.Println("什么都不买")
		break

	}

	var score int
	fmt.Println("请输入成绩：")
	fmt.Scan(&score)
	switch {
	case score >= 90:
		fmt.Println("A")
	case score >= 80:
		fmt.Println("B")
	case score >= 70:
		fmt.Println("C")
	default:
		fmt.Println("F")
	}
}

for

package main

import "fmt"

func main() {

    //索引 => 记录已经加到的n
    sum := 0
    // 初始化子语句 ，条件子语句 ，后置子语句
    for i := 0; i < 100; i++ {
        sum += i
    }
    fmt.Println(sum)

    sum = 0

    i := 0
    for i <= 100 {
        sum += i
        i++
    }
    fmt.Println(sum)

    for { //表示一个死循环
        i++
        if i > 3000 {

            break
        }
    }
    desc := "我爱中国"
    // 字符串，数组，切片，映射，管道 ,如果遍历一个字符串，只能用for range去遍历
    for i,ch := range  desc {
        fmt.Printf("%T %q\n",i,ch)
    }
}

goto

package main

import "fmt"

func main() {

    /*  var yes string
            fmt.Println("请输入你的操作：（y 或 Y）")

            fmt.Scan(&yes)

            if yes != "Y" || yes != "y" {
                goto end
            }

            fmt.Println("买一个西瓜")

        end:
    */

    // 1... 100
    i := 0
    sum := 0
start:
    if i > 100 {
        fmt.Println("执行结束 ")
        goto forward
    }
    sum += i
    i++
    fmt.Println("i=", i)
    goto start
forward:
    fmt.Println("sum is ", sum)

    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if j == 5 {
                //break只能跳出本层循环
                break
            }
            fmt.Println(i, j)
        }
    }
    
    //如果跳出多层循环，可以使用beak  begain
begain:
    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if j == 5 {
                //break只能跳出本层循环
                break begain
            }
            fmt.Println(i, j)
        }
    }
}

作业：

打印乘法口诀

package main

import "fmt"

func main() {
    /**
    1 * 1 = 1
    1 * 2 = 2 2 * 2 = 4
    1* 3 = 3 2 * 3 = 6   3 * 3 = 9
    .......
    1*9 = 9  ............9 * 9 = 81
    */
    for i := 1; i <= 9; i++ {
        for j := 1; j <= i; j++ {
            // - 号表示左对齐   ， 2 表示占位2 个字符
            fmt.Printf("%d * %d = %-2d\t",j,i, i*j)
        }
        fmt.Println("")

    }
}
1 * 1 = 1       
1 * 2 = 2       2 * 2 = 4       
1 * 3 = 3       2 * 3 = 6       3 * 3 = 9       
1 * 4 = 4       2 * 4 = 8       3 * 4 = 12      4 * 4 = 16      
1 * 5 = 5       2 * 5 = 10      3 * 5 = 15      4 * 5 = 20      5 * 5 = 25      
1 * 6 = 6       2 * 6 = 12      3 * 6 = 18      4 * 6 = 24      5 * 6 = 30      6 * 6 = 36      
1 * 7 = 7       2 * 7 = 14      3 * 7 = 21      4 * 7 = 28      5 * 7 = 35      6 * 7 = 42      7 * 7 = 49      
1 * 8 = 8       2 * 8 = 16      3 * 8 = 24      4 * 8 = 32      5 * 8 = 40      6 * 8 = 48      7 * 8 = 56      8 * 8 = 64      
1 * 9 = 9       2 * 9 = 18      3 * 9 = 27      4 * 9 = 36      5 * 9 = 45      6 * 9 = 54      7 * 9 = 63      8 * 9 = 72      9 * 9 = 81

猜数字游戏
a) 生成一个[0,100)的随机数
b)让用户重复猜5次（从命令行输入，当数字太大，提示太大，猜的太小，提示太小，你还有N次猜测机动，猜中了，提示猜中了，如果5都没有猜中的话，则提示你的没有猜中）
挑站，当5次都没有猜中的话，提示太笨，重新开始新的猜数游戏

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    //设置随机数种子
    rand.Seed(time.Now().Unix())

    // 生成随机数 0-100
    guess := rand.Intn(100)
    const maxGuessNum = 5
    fmt.Println("生成的随机数：" ,guess)
start:
    for i := 0; i < maxGuessNum; i++ {
        var input int
        fmt.Println("请输入你猜中的数字")
        fmt.Scan(&input)

        if guess == input {
            fmt.Println("太聪明了 ，你第%d次就猜对了", i+1)
            break
        } else if guess > input {
            fmt.Println("你猜的数字太小了，你还有%d次猜的机会", maxGuessNum-i-1)
        } else {
            fmt.Println("你猜的数字太了，你还有%d次猜的机会", maxGuessNum-i-1)
        }
        if i == maxGuessNum-1 {
            fmt.Println("太笨了，你还要来一次吗？如果需要输入Y,否则输入Other，退出游戏")
            var flag string
            fmt.Scan(&flag)
            if flag == "Y" {
                goto start
            } else {
                goto end
            }
        }
    }
end:
    fmt.Println("游戏结束 ")

}

写代码注意：

随机种子，在程序初始化只用初始化一次
清楚了解代码执行逻辑，删除冗余
注意变量定义的位置。
注意变量定义的位置。
注意代码格式（缩进和对齐）
注意对不同的分支中相同的逻辑代码进行合并
尝试，fmt.printLn(),fmt.println(""),fmt.printf("\n")
掌握fmt.Printf对齐方式
代码要做减法，使得逻辑最清晰

数组

数组是相同的数据类型，的数据项目组成的一组长度固定的序列，数组的元素，数组的长度必需是非负整数的常量，长度也是类型是之一。
声明：
数组的声明需要指定组成元素的类型以及存储元素的数量（长度），其长度不可以修改，数组的每个元素会根据对应的类型的零值进行

var names [10] string
var score [10] int

fmt.Printf("%T,%T\n",names,scores)
fmt.Printf("%q\n",names)
fmt.Println(scores)

例子：

package main

import "fmt"

func main() {
    var nums [10]int
    fmt.Println(nums)         // [0 0 0 0 0 0 0 0 0 0]
    fmt.Printf("%q \n", nums) //['\x00' '\x00' '\x00' '\x00' '\x00' '\x00' '\x00' '\x00' '\x00' '\x00']
    fmt.Printf("%T \n", nums) // [10]int

    var t2 [5]bool
    var t3 [3]string
    fmt.Println(t2)         // [false false false false false]
    fmt.Println(t3)         //[  ] ,看到什么都没有打印，其实是5个空字符串
    fmt.Printf("%q \n", t3) // ["" "" ""] ,将对应类型的零值进行填充

    // 字面量,数组初始化
    nums = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println(nums) // [1 2 3 4 5 6 7 8 9 10]
    // 给数组的第一个和最后一个赋值，[10 0 0 0 0 0 0 0 0 20]
    nums = [10]int{0: 10, 9: 20}
    fmt.Println(nums)
    // 可以根据... 去推算数组的长度
    nums = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //[1 2 3 4 5 6 7 8 9 10]
    fmt.Println(nums)
    // 定义一个数组长度为3的数组，可以不定义他的长度，可以用...来代替,可以根据数组的长度来推导出xx的长度
    xx := [...]int{1, 2, 3}
    fmt.Println(xx) //[1 2 3]

    //初始化数组的前三个元素的数组
    nums02 := [10]int{10, 20, 30}
    fmt.Println(nums02)                    // [10 20 30 0 0 0 0 0 0 0]
    fmt.Printf("%T %#v\n", nums02, nums02) //[10]int   [10]int{10, 20, 30, 0, 0, 0, 0, 0, 0, 0}

    //数组的声明也赋值
    nums03 := [...]int{1, 2}
    fmt.Printf("%T %#v\n", nums03, nums03) // [2]int       [2]int{1, 2}

    //获取数组的长度,数组的长度一旦定义了，就不能改变了
    fmt.Println("获取数组的长度",len(nums))                    // 10
    // 遍历数组
    for i := 0; i < len(nums03); i++ {
        fmt.Println(nums03[i])
    }
    nums04 := [3]int{1, 2, 3}
    nums05 := [3]int{1, 2, 3}
    nums06 := [4]int{1, 2, 3, 4}
    nums07 := [4]int{1, 3, 4, 5}
    fmt.Println(nums04 == nums05) // true
    // invalid operation: nums04 == nums06 (mismatched types [3]int and [4]int) ,如果长度不相等，编译报错
    //fmt.Println(nums04 == nums06)
    fmt.Println(nums06 == nums07)                       //false

    //索引,访问元素必需在索引范围之内
    fmt.Println("nums04的第一个元素 ：",nums04[0]) // nums04的第一个元素 ： 1

    //fmt.Println(nums04[-1]) Invalid array index '-1' (must be non-negative)
    nums04[0],nums04[1] = 1000,2000 //同时给数组中的元素赋值

    for index,value := range nums04{
        fmt.Println(index,value)
    }
    //0 1000
    //1 2000

    var value int       //for里面的作用域和外部的作用域是不一样的
    //只想获取值，不想要index，那可以以一个空白标识符来标识，来丢弃不想要的值
    for _,value :=range nums04{
        fmt.Println(value)
    }
    fmt.Println(value)

    /*  var value int
    _,value = 1,4
    fmt.Println(value)*/
    // 切片
    fmt.Printf("%T \n",nums04[0:]) //[]int
    // [2000 3]
    fmt.Println(nums04[1:])
    //切片的容量，不能超过数组的长度
    //fmt.Println(nums04[1:4])
    fmt.Println("--------------------")
    // 最后一个参数是数组的容量
    fmt.Println(nums04[1:3:3])

    fmt.Printf("%v \n",nums04[1:3]) // [2000 3]

    // 多维数组
    //定义一个长度为2
    var marrays =  [3][2]int{{1,2},{3,4},{5,6}}
    fmt.Println(marrays)            // [[1 2] [3 4] [5 6]]
    fmt.Printf("%T\n",marrays)          // [3][2]int
    marrays[0] = [2]int{1,3}        // 修改第一维数组
    fmt.Println(marrays)
    marrays[1][1] = 1000
    fmt.Println(marrays)    //[[1 3] [3 1000] [5 6]]

    //定义三维数组,多维数组不能用可推导长度，多维数组的长度一定要是一一致的，数组的类型必需是一致的
    var marray3 = [4][3][2] int{{{1,2},{3,4},{5,6}},{{7,8},{9,10},{11,12}},{{13,14},{15,16},{17,18}},{{19,20},{21,22},{23,24}}}
    fmt.Println(marray3) // [[[1 2] [3 4] [5 6]] [[7 8] [9 10] [11 12]] [[13 14] [15 16] [17 18]] [[19 20] [21 22] [23 24]]]

}

复合数组类型
字面量：

指定数组长度：[length]type{v1,v2,…vlength}
使用初始化元素数量推到数组长度：[…]type{v1,v2…}
对指定位置的元素进行初始化：[length]type[im:vm…]

切片：

切片是长度可变的数组（具体相同的数据类型的数据项，）切片由三部分组成

指针：指向切片第一个元素指向的数组元素地址
切片的元素的数量
容量：切片开始到结束位置元素的位置

声明：切片声明需要指定组成的元素的类型，但不需要指定存储元素的数量（长度），在切片声明后，会被初始化为nil,表示暂时不存在切片。

array[start:end]/array[start🔚cap]( end <= cap)

初始化

使用字面量初始化：[]type{v1,v2,…vn}
使用字面量初始化空切片，[] type{}
指定长度和容易字面量初始化:[]type{im:vm,in,vnm}
使用make函数初始化：make([]type,len/make([]type,len,cap),通过make函数创建长度为len,容量为cap的切片，len的长度小于等于cap)
使用数组切片操作的初始化，array[start:end]或array[start:end :cap]

可以通过len和cap来获取数组的长度和容量
可以通过索引对切片元素进行访问，和修改切片里的元素
新创建切片的长度和容易计算：len:end-start,cap:src_cap-start
切片的共享底层数组，若某个切片元素发生变量，则数组和其他切片也会发生变化。
新创建切片长度和容易计算：len:end-start,cap=len:end-start,cap:cap-start
可以用for len或for range来遍历切片
len :
len函数是Go语言中的内置函数

package main

import (
    "fmt"
)

func main() {
    //声明一个切片
    var nums []int
    fmt.Printf("%T %d %d \n", nums, len(nums), cap(nums)) //[]int 0 0

    var names []string
    fmt.Printf("%T %d %d %d \n", names, names == nil, len(names), cap(names)) // []string %!d(bool=true) 0 0

    // 字面量
    nums = []int{1, 2, 3}
    fmt.Println(nums) // [1 2 3]

    nums = []int{1, 2, 3, 4}                                //[1 2 3]
    fmt.Printf("%#v  %d %d \n", nums, len(nums), cap(nums)) // []int{1, 2, 3, 4} 4 4

    //通过数组切片赋值
    var arrays [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    nums = arrays[1:10]
    fmt.Println(nums) //通过数组切片，  [2 3 4 5 6 7 8 9 10]

    // make 函数,第一个参数是类型，第三个参数，是长度，第三个参数是容量
    nums = make([]int, 3)                                  //在底层初始化一个长度为3的数组，赋值给这个切片
    fmt.Printf("%#v %d %d \n", nums, len(nums), cap(nums)) // []int{0, 0, 0} 3 3
    fmt.Println(nums)

    nums = make([]int, 3, 5) //初始化前面三个参数是0，后面两个参数没有被初始化
    fmt.Println(nums)        // [0 0 0]

    // 元素的操作（增，删，改，查）
    fmt.Println(nums[0]) // 0
    fmt.Println(nums[1]) //0
    nums[2] = 4
    //  fmt.Println(nums[3])                // panic: runtime error: index out of range [3] with length 3
    //fmt.Println(nums[4])
    //nums[3]= 4                        //
    // 为nums添加一个值
    nums = append(nums, 1)

    fmt.Printf("%#v %d %d \n", nums, len(nums), cap(nums)) // []int{0, 0, 4, 1} 4 5
    nums[3] = 10
    fmt.Println(nums) // [0 0 4 10]
    //  nums[5]=6                           // panic: runtime error: index out of range [5] with length 4

    nums = append(nums, 1)
    nums = append(nums, 1)
    nums = append(nums, 1)
    fmt.Println(nums) // [0 0 4 10 1 1 1]

    // 切片遍历
    for _, value := range nums {
        fmt.Println(value)
    }

    // 切片操作
    nums = nums[1:5]
    fmt.Println(nums) //      [0 4 10 1]

    fmt.Println("%T \n", nums[1:5]) //  [4 10 1 1]

    nums = make([]int, 3, 10)
    n := nums[1:3:10] //设置的容量不能比原来的大
    //  长度是2  新的容量是 原来容量-start
    fmt.Printf("%T %#v  %d %d \n", n, n, len(n), cap(n)) // []int []int{0, 0}  2 9
    n = nums[2:3]
    // cap = src_cap - start
    fmt.Printf("%T %#v  %d %d \n", n, n, len(n), cap(n)) // []int []int{0}  1 8

    nums02 := nums[1:3]
    fmt.Println(nums02) // [0 0]
    nums02[0] = 1
    fmt.Println(nums02) // [1 0]
    // 删除
    // copy
    nums04 := []int{1, 2, 3}
    nums05 := []int{10, 20, 30, 40}
    //copy(nums05,nums04)
    //fmt.Println(nums05)                   // [1 2 3 40]
    copy(nums04, nums05)
    fmt.Println(nums04) // [10 20 30] 复制不会扩容

    // 删除 第一个元素和最后一个元素
    nums06 := []int{1, 2, 3, 4, 5, 6}
    fmt.Println(nums06[1:])             // [2 3 4 5 6]
    fmt.Println(nums06[:len(nums06)-1]) //[1 2 3 4 5]
    //删除中间的一个元素
    copy(nums06[2:], nums06[3:])
    fmt.Println(nums06[:len(nums06)-1]) // [1 2 4 5 6]

    // 堆栈:每次添加在除尾，移除元素在队尾，（先进后出）

    stack := []int{}
    stack = append(stack, 1)
    stack = append(stack, 2)
    stack = append(stack, 3)
    stack = append(stack, 4)
    fmt.Println(stack[:len(stack)-1])               // [1 2 3]

    //队列 ：每次添加都在队尾，移除元素在除头，先进先出

    queue := []int{}
    queue = append(queue, 1)
    queue = append(queue, 2)
    queue = append(queue, 3)
    queue = append(queue, 4)
    fmt.Println(queue[0])             //1
    fmt.Println(queue[1:])            //[2 3 4]
    fmt.Println(queue[:len(queue)-1]) // [1 2 3]


	//数组的值的类型
	slice01 := []int{1,2,3}
	slice02 := slice01
}

sort

package main

import (
    "fmt"
    "sort"
)

func main() {

    nums := []int{4, 5, 7, 8, 6}
    sort.Ints(nums)
    //对nums排序
    fmt.Println(nums) // [4 5 6 7 8]

    names := []string{"test","name","zhangsan","lisi"}
    sort.Strings(names)//对字符串进行排序
    fmt.Println(names) //[lisi name test zhangsan]

    
    hight := []float64{1.2,1.0,2.5,3.2,2.3}
    sort.Float64s(hight) //对float类型进行排序
    fmt.Println(hight) // [1 1.2 2.3 2.5 3.2]


}

复合数组类型-映射(java中的hashmap)
定义：
映射是存储一系列无序的key/value对，通过key来对value进行操作（增，删，查）
key/value规则
映射的key只能为可使用==运算符值的类型（字符串，数字，布尔，数组）value可以为任意类型的s

package main

import (
    "fmt"
)

func main() {
    users := []string{"烟灰", "祥哥", "zhangsan", "lisi", "zhangsan", "wangwu", "zhaoliu", "zhangsan"}
    counts := map[string]int{}
    for _, user := range users {
        //fmt.Println(user)
        _, ok := counts[user]
        if !ok {
            counts[user] = 1
        } else {
            counts[user] = counts[user] + 1
        }
    }
    fmt.Println(counts) // map[lisi:1 wangwu:1 zhangsan:3 zhaoliu:1 烟灰:1 祥哥:1]

    counts1 := map[string]int{}
    for _, user := range users {
        counts1[user]++
    }
    fmt.Println(counts1) // map[lisi:1 wangwu:1 zhangsan:3 zhaoliu:1 烟灰:1 祥哥:1]


    dream := "I have a dream\n \nFive score years ago, a great American, in whose symbolic shadow we stand today, signed the Emancipation Proclamation. This momentous decree came as a great beacon";

    dreamMap := map[rune]int {}
    for _ ,v :=range  dream{
        dreamMap[v]++
    }

    for ch ,cnt := range dreamMap{
        fmt.Printf("%c %d \n",ch,cnt)
    }


}
g 43 
P 1 
G 3 
z 1 
C 2 
c 52 
w 40 
E 1 
l 97 
T 1 
O 3 
S 4 
...

7.字符串常用函数

字符串/字节切片
strings
string包提供了操作UTF-8字符串常用的函数和结构体
a)常用函数
Compare:比较字符串
Contains：是否包含子字符串
Count: 子字符串出现的次数
EqualFold:不区分大小写怕比较
Fields:按空白字符串分割字符串
HasPrefix:是否以字符串作为前缀
HasSuffix:是否以字符串作为后缀
Index: 获取子字符串首次出现的位置
Split :分割字符串为切片
Join:将字符串切片连接
LastIndex:获取字符串最后一次出现的位置。
…

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Compare("abc", "bad"))    // -1
    fmt.Println(strings.Contains("abc", "a"))     //true
    fmt.Println(strings.ContainsAny("abc", "cb")) //
    fmt.Println(strings.Count("abc", "a"))        //出现的次数
    fmt.Printf("%q \n", strings.Fields("abc cd")) //按空白字符分隔开 ，["abc" "cd"]

    fmt.Println(strings.HasPrefix("abc", "a")) // 以什么开头 true
    fmt.Println(strings.HasSuffix("bcd", "d")) // 以什么结尾

    fmt.Println(strings.Index("abc", "c"))      // 2 返回第一次出现的位置
    fmt.Println(strings.LastIndex("abac", "a")) // 2 返回最后一次出现的位置

    fmt.Println(strings.Split("abcdef", "e")) // [abcd f]
    a := []string{"a", "b", "c"}
    fmt.Println(strings.Join(a,"_")) // a_b_c               第一个参数是一个切片，第二个参数是连接的_


    fmt.Println(strings.Repeat("abc",3))                    // abcabcabc
    fmt.Println(strings.ReplaceAll("abcabcabc","ab","x"))   // xcxcxc ,将ab 替换成x
    fmt.Println(strings.Replace("abcabcabc","ab","x",1))    // xcabcabc ,将ab 替换成x,只替换一个
    fmt.Println(strings.Replace("abcabcabc","ab","x",-1))   // xcxcxc ,将ab 替换成x,-1，表示替换所有
    fmt.Println(strings.ToLower("ABC"))                 // abc
    fmt.Println(strings.ToUpper("abc")) //ABC 全部大写
    fmt.Println(strings.ToTitle("abc")) //ABC
    fmt.Println(strings.Trim("abc","c"))    //ab
    fmt.Println(strings.TrimSpace("abcxx iewoiew \t"))              //abcxx iewoiew 去前后的空白字符
   
}

8.字节切片

package main

import (
    "bytes"
    "fmt"
)

func main() {
    b := []byte{'a','b','c'}
    fmt.Printf("%T %#v\n", b) // []uint8 %!v(MISSING)
    fmt.Println(b)            // [97 98 99]


    s := string(b)
    fmt.Printf("%T %#v \n",s,s) // string "abc"


    fmt.Println(bytes.Compare([]byte{'a','b'},[]byte{'c','d'})) // -1

    fmt.Println(bytes.Index([]byte("abcdef"),[]byte("def"))) //3
    fmt.Println(bytes.Contains([]byte("abcdef"),[]byte("defd")))     //false
}

9.字符串类型转换

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 字符串=>其他类型
    // => bool
    if v, err := strconv.ParseBool("true"); err == nil {
        fmt.Println(v, err) // true 
    }
    //转化成int
    if v, err := strconv.Atoi("1023"); err == nil {
        fmt.Println(v) //1023
    }

    if v,err := strconv.ParseInt("64",16,64); err == nil {
        fmt.Println(v)                  // 100
    }

    //转化为64类型
    if v,err := strconv.ParseFloat("64.4 ",64); err == nil {
        fmt.Println(v)                  // 100
    }




    //其他类型向string类型转化

    xx :=fmt.Sprintf("%d",12)
    fmt.Println(xx)


    yy :=fmt.Sprintf("%.3f",12.32389328)
    fmt.Println(yy) // 12.324

    fmt.Println(strconv.FormatBool(false)) // false
    fmt.Printf("%q \n",strconv.Itoa(12)) //"12"
    fmt.Printf("%q \n",strconv.FormatInt(12,16)) //"c"
    fmt.Printf("%q \n",strconv.FormatFloat(10.1 ,'E',-1,64)) //"1.01E+01" ,用科学计数法来表示

}

10.冒泡排序

package main

import "fmt"

func main() {
    heights := []int {10,6,7,9,5}
    //先把最高的人排到最后
    for i := 0 ;i < len(heights);i ++{
        for j := i + 1  ; j < len(heights)  ; j ++{
            if heights[i] > heights[j]{
                heights[i],heights[j] = heights[j],heights[i]
            }
        }
    }
    fmt.Println(heights)
}

作业：

代码github地址

求数组中的最大值到第二大值

package main

import "fmt"

func main() {
    numbs := []int{1, 3, 5, 8, 9, 11, 20, 30, 4, 6, 5}
    maxNum := numbs[0]
    secondNum := numbs[0]
    //求数组中的最大值到第二大值
    for _, v := range numbs {
        if v > maxNum {
            secondNum = maxNum
            maxNum = v
        } else if v > secondNum {
            secondNum = v
        }
    }
    fmt.Println(maxNum) //30 得到最大值
    fmt.Println(secondNum)

}

获取映射中的key切片，value切片

package main

import "fmt"

func main() {
    users := map[string]int{"zhangsan": 1, "lisi": 9, "wangwu": 10}
    keySlice := make([]string, len(users))
    valueSlice := []int{}
    i := 0
    for k, v := range users {
        keySlice[i] = k
        i++
        valueSlice = append(valueSlice, v)
    }
    for k,_ := range users{
        fmt.Println(k)
    }
    for _,v := range users{
        fmt.Println(v)
    }
    for v :=range users{
        fmt.Println(v)
    }
    for v:= range valueSlice{
        fmt.Println(v)
    }

}

我有一个梦想，每个字符出现的次数 run=>int ,出现多少次数的字符数

package main
import "fmt"
func main() {
    dream := "I have a dream\n \nFive score years ago, a great American, in whose symbolic shadow we stand today, signed the Emancipation Proclamation. This momentous decree came as a great beacon light of hope to millions of Negro slaves who had been seared in the."

    dreamMap := map[rune]int{}
    for _, v := range dream {
        dreamMap[v]++
    }
    countStats := map[int][]rune{}
    for ch, count := range dreamMap {
        countStats[count] = append(countStats[count], ch)
    }
    fmt.Println(countStats)
}

package main

import (
    "fmt"
    "sort"
)

func main() {

    nums := []int{1, 2, 3, 4, 5, 6, 8,  10, 11}
    sort.Ints(nums)
    fmt.Println(nums)
    // 二分查找,在有序的数组中查找元素
    index := sort.SearchInts(nums, 5)
    fmt.Println(index) // 4
    // 先查找这个值，是不是等于num，如果不存在，则找到这个如果插入时的索引
    fmt.Println(sort.SearchInts(nums, 1000))
    
    if  nums[sort.SearchInts(nums, 9)] == 9 {       //如果不存在，直接打印不存在
        fmt.Println("存在 ")
    }else{
        fmt.Println("不存在 ")
    }
}

https://github.com/quyixiao/go_learn.git