Golang 百题(实战快速掌握语法)_1

整形转字符串类型

实验介绍

本实验将展示三种方法来实现整形类型转字符串类型。

知识点

• strconv
• fmt

Itoa 函数

代码实例

Go 语言中 strconv 包的 itoa 函数输入一个 int 类型，返回转换后的字符串。下面是一个例子。

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 输入一个整数，返回一个字符串
    a := strconv.Itoa(1234)
    fmt.Printf("%T %v\n",a, a)
    // Output:
    // "string 1234"
}

将代码保存为/home/project/itoa.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run itoa.go

FormatInt

代码实例

formatInt 函数将输入的 int64 类型整形转换为指定进制的字符串。格式如下所示：

FormatInt(i int64, base int)
// 以下函数将i转为二进制后返回它的字符串类型
FormatInt(i int64, 2)

我们来看一个例子：

package main

import (
    "strconv"
    "fmt"
)
func main() {
    // 输入int64类型的1234，设置为10进制
    b := strconv.FormatInt(int64(1234), 10)
    fmt.Printf("%T %v\n", b, b)
}

将代码保存为/home/project/formatInt.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run formatInt.go

Sprintf 函数

代码实例

Go 语言中 fmt 包下的 Sprintf 函数根据格式说明符进行格式化，并返回结果字符串。

package main

import (
    "fmt"
)

func main() {
    // sprintf函数返回转换后的字符类型
    c := fmt.Sprintf("%d", 1234)
    fmt.Printf("%T %v\n", c, c)
}

将代码保存为/home/project/sprintf.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run sprintf.go

实验总结

本实验我们学习了 itoa，formatInt 和 sprintf 函数的用法，它们都是 Go 语言中非常重要的知识，需要大家好好掌握。

整形转切片

实验介绍

本实验将展示如何通过strconv.Itoa和strings.Split来实现整数转切片。

知识点

• strconv
• strings

整形转数组

代码实例

Go 语言中 strconv 包的 itoa 函数输入一个 int 类型，返回转换后的字符串。而 strings 包下的 Split 函数输入一个字符串和分隔符，返回分割后的切片，下面是一个例子。

package main

import (
    "fmt"
    "strconv"
    "strings"
)

//  转换int整形为数组
func Digits(n int) []int {
    s := strconv.Itoa(n)
    d := make([]int, len(s))
    for i, l := range strings.Split(s, "") {
        d[i], _ = strconv.Atoi(l)
    }
    return d
}
func main() {
    r := Digits(123) // [1 2 3]
    fmt.Println(r)
}

该程序的功能：

• 使用strconv.Itoa来转换给定的数字为字符串。
• 使用strings.Split()来分割转换后的字符串，并返回一个字符串切片。

将代码保存为/home/project/digits.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run digits.go

实验总结

本实验学习了如何整形转为切片，下个实验我们将讲解如何连接集合的所有元素。

连接集合的所有元素

实验介绍

Go 原生支持字符串切片转字符串，但并不直接支持整形切片转字符 String，本实验我们将学习如何通过反射和fmt.Sprintf来实现整形切片转字符串。

知识点

• slice
• reflect
• fmt.Sprintf

连接集合中的所有元素

代码实例

我们可以遍历整形切片的每个元素，然后把每个整形转为字符后添加分隔符后加入到字符串中，下面是一个例子。

package main

import (
    "fmt"
    "reflect"
    "strings"
)

func Join(params ...interface{}) string {
    arr, sp := reflect.ValueOf(params[0]),
        reflect.ValueOf(params[1]).String()
    ars := make([]string, arr.Len())

    for i := 0; i < arr.Len(); i++ {
        ars[i] = fmt.Sprintf("%v", arr.Index(i))
    }

    return strings.Join(ars, sp)

}
func main() {
    w := Join([]int{1, 2, 3}, ".")
    fmt.Printf("%T %v", w, w)
}

该程序的功能：

• 使用relect.ValueOf()来获取数组或切片，还有字符串。

• make 用来创建一个合适长度的字符串切片。

• 使用 for 循环遍历每个元素，fmt.Sprintf()用来整形转字符类型。

• strings.Join()的功能是使用提供的分隔符来组合字符串

将代码保存为/home/project/join.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run join.go

实验总结

本实验我们学习了如何连接集合中的所有元素，下个实验我们将学习如何获得两个集合中的所有组合。

两个集合的所有组合

实验介绍

本实验将展示如何创建两个集合的所有集合，集合均为没有重复值。

知识点

• for

两个集合的所有组合

代码实例

为了获得两个集合的所有集合，我们可以先创建一个二维切片列表，然后 for 循环输出并且保存到二维切片列表中。

package main

import (
    "fmt"
    "reflect"
)

func XProduct(params ...interface{}) [][]interface{} {
    a, b := reflect.ValueOf(params[0]), reflect.ValueOf(params[1])
    l := a.Len() * b.Len()
    r := make([][]interface{}, l)

    for i := 0; i < l; i++ {
        r[i] = []interface{}{
            a.Index(i % a.Len()).Interface(),
            b.Index((i / a.Len()) % b.Len()).Interface(),
        }
    }
    return r

}
func main() {
    r := XProduct([]int{1, 2}, []string{"a", "b"}) // [[1 a] [2 a] [1 b] [2 b]]
    fmt.Println(r)
}

该程序的功能：

• 使用reflect.ValueOf()来获取切片或者数组。
• 使用 for 循环来填充生成的结果

将代码保存为/home/project/xProduct.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run xProduct.go

实验总结

本实验我们学习了如何通过反射和 for 循环获得两个集合的所有组合。下个实验我们将学习如何删除切片的重复元素。

删除切片重复元素

实验介绍

本实验将展示如何删除切片的重复元素。

知识点

• range
• append
• make

删除切片重复元素

代码实例

删除重复切片的一个方法是创建一个字典来存储字符是否已经出现过。下面是一个例子。

package main

import (
    "fmt"
)

func DedupeInts(arr []int) []int {
    m, uniq := make(map[int]bool), make([]int, 0)
    for _, v := range arr {
        if _, ok := m[v]; !ok {
            m[v], uniq = true, append(uniq, v)
        }
    }
    return uniq
}
func main() {
    date := []int{1, 2, 1, 2, 3, 3, 4}
    res := DedupeInts(date)
    fmt.Printf("date: %v\nres: %v",date, res)
}

该程序的功能：

• 使用 make 创建一个 map 来存储数据。
• for 循环遍历传入切片的每一个元素，并进行判断是否在 map 中重复，如果不重复则加入到 map 中。

将代码保存为/home/project/dedupeInts.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run dedupeInts.go

实验总结

本实验我们使用 map 类型来删除切片的重复元素。下个实验我们将学习如何得到集合频率的映射。

集合频率的映射

实验介绍

本实验将展示统计集合中数值出现的频率并返回。

知识点

• for

代码实例

为了获得集合中数值的频率，我们可以创建一个 map 函数来存储，下面是具体的实现。

package main

import "fmt"

func FrequenciesInt(arr []int) map[int]int {
    m := make(map[int]int)
    for _, v := range arr {
        if f, ok := m[v]; ok {
            m[v] = f + 1
        } else {
            m[v] = 1
        }
    }
    return m
}
func FrequenciesFloat64(arr []float64) map[float64]int {
    m := make(map[float64]int)
    for _, v := range arr {
        if f, ok := m[v]; ok {
            m[v] = f + 1
        } else {
            m[v] = 1
        }
    }
    return m
}
func FrequenciesBool(arr []bool) map[bool]int {
    m := make(map[bool]int)
    for _, v := range arr {
        if f, ok := m[v]; ok {
            m[v] = f + 1
        } else {
            m[v] = 1
        }
    }
    return m
}
func FrequenciesString(arr []string) map[string]int {
    m := make(map[string]int)
    for _, v := range arr {
        if f, ok := m[v]; ok {
            m[v] = f + 1
        } else {
            m[v] = 1
        }
    }
    return m
}
func main() {
    i := []int{1, 1, 3, 1, 4}
    s := []string{"a", "d", "a", "d", "c"}
    r1 := FrequenciesInt(i)
    r2 := FrequenciesString(s)
    fmt.Println(i, "\t", r1, "\n", s, "\t", r2)
}

该程序的功能：

• 使用make来创建一个字典。
• 使用 for 循环来遍历给定的切片，对每个元素进行判断，如果是没有出现过则赋值为 1，否则进行累加。

将代码保存为/home/project/frequencies.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run frequencies.go

实验总结

本实验我们学习了获得集合频率的映射，下个实验我们将要学习返回带有索引的切片。

返回带有索引的切片

实验介绍

本实验将通过创建 map 实现返回带有索引的切片。

知识点

• map
• reflect

代码实例

我们可以使用 for 循环来遍历输入的参数，然后把索引和相关的值保存到 map 中。下面是一个例子。

package main

import (
    "fmt"
    "reflect"
)

func WithIndex(params ...interface{}) map[int]interface{} {
    arr, m := reflect.ValueOf(params[0]),
        make(map[int]interface{})
    for i := 0; i < arr.Len(); i++ {
        m[i] = arr.Index(i).Interface()
    }
    return m
}
func main() {
    r := WithIndex([]int{4, 3, 2, 1}) // [0:4 1:3 2:2 3:1]
    fmt.Println(r)
}

该程序的功能：

• 使用reflect.ValueOf()来获取切片或者数组。
• 使用 for 循环来遍历数组，把每个元素添加到字典中。

将代码保存为/home/project/withIndex.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run withIndex.go

实验总结

本实验我们学习了如何返回带有索引的切片，下个实验我们将学习如何使用函数参数的用法。

复制指定条件的切片

实验介绍

本实验将展示对输入的切片进行判断，并且返回符合指定条件的切片。

知识点

• range
• 函数参数
• append

代码实例

Go 中可以把函数作为参数传入，所有我们可以对传入的参数进行遍历，每个元素通过传入的函数来进行判断，下面是一个例子。

package main

import "fmt"

func FilterInt(arr []int, f func(int) bool) []int {
    arf := make([]int, 0)
    for _, v := range arr {
        if f(v) {
            arf = append(arf, v)
        }
    }
    return arf
}
func FilterFloat64(arr []float64, f func(float64) bool) []float64 {
    arf := make([]float64, 0)
    for _, v := range arr {
        if f(v) {
            arf = append(arf, v)
        }
    }
    return arf
}
func FilterBool(arr []bool, f func(bool) bool) []bool {
    arf := make([]bool, 0)
    for _, v := range arr {
        if f(v) {
            arf = append(arf, v)
        }
    }
    return arf
}
func FilterString(arr []string, f func(string) bool) []string {
    arf := make([]string, 0)
    for _, v := range arr {
        if f(v) {
            arf = append(arf, v)
        }
    }
    return arf
}
func main() {
    intCheck := func(x int) bool { return x > 1 }
    fmt.Println(FilterInt([]int{0, 2}, intCheck)) // [2]
    float64Check := func(x float64) bool { return x > 0.5 }
    fmt.Println(FilterFloat64([]float64{0.0, 1.0}, float64Check)) // [1.0]
    boolCheck := func(x bool) bool { return x }
    fmt.Println(FilterBool([]bool{false, true}, boolCheck)) // [true]
    stringCheck := func(x string) bool { return len(x) > 1 }
    fmt.Println(FilterString([]string{"", "hi"}, stringCheck)) // ["hi"]
}

该程序的功能：

• 创建一个条件函数，来作为参数传入主功能函数中
• for 循环遍历每个元素，使用传入的函数进行判断

将代码保存为/home/project/filterInt.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run filterInt.go

实验总结

本实验我们学习了如何通过函数传递条件函数，会返回符合指定条件的切片，下个实验我们同样使用函数参数，来实现返回集合中满足指定条件的第一个元素。

返回集合中符合条件的第一个元素

实验介绍

本实验将展示如何返回给定集合中符合条件的第一个元素。

知识点

• for

代码实例

我们可以使用 for 循环来遍历输入的集合，然后通过传入的判断函数来进行判断，下面是一个具体例子。

package main

import "fmt"

func FindIndexInt(arr []int, f func(int) bool) int {
    for i, v := range arr {
        if f(v) {
            return i
        }
    }
    return -1
}
func main() {
    r1 := FindIndexInt([]int{1, 1, 2}, func(x int) bool { return x%2 == 0 }) // 2
    fmt.Println(r1)
}

该程序的功能：

• 使用 range 来正向遍历切片，用 f 函数来判断是否符合条件。

将代码保存为/home/project/findIndexInt.go文件。

运行程序

打开 WebIDE 的 Terminal 终端，输入以下命令查看输出：

go run findIndexInt.go

实验总结

本实验我们学习了 如何通过参数来获得条件函数，然后返回集合中符合条件的第一个元素，下一个我们将做一个简单的挑战。

课后习题：

打印当前版本

挑战介绍

打印当前环境中 Go 的版本信息

挑战内容

本次挑战中，你需要打印当前 WebIDE 中 Go 的版本信息。

输出参考格式为：

Go version: 1.xx

挑战要求

• 请自行在环境主目录/home/project下新建 print_version.go 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

示例代码

package main

import (
    "fmt"
    "runtime"
)
func main(){

}

小贴士

• 可以使用 runtime 包中的函数打印当前 Go 的版本。
• 为了保证能被系统准确检测，挑战中的每一句话都非常重要，请仔细阅读。跳跃式浏览易导致挑战无法按要求通过。

参考代码

以下内容仅供参考，为了能有更好的学习效果，请尽量按自己的想法来完成挑战。

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Printf("Go version: %s\n", runtime.Version())
}