go语言学习【五】

目录：
1.Go字符串函数
2.日期和时间相关函数
3.数组
4.数组应用案例
5.切片
6.二维数组

1.Go字符串函数

1）统计字符串的长度，按字节 len(str)
2) 字符串遍历，同时处理有中文的问题 r:=[]rune(str)
3) 字符串转整数： n,err := strconv.Atoi(“12”)
4) 整数转字符串：str = strconv.Itoa(12345)
5) 字符串转 []byte ：var bytes = []byte(“hello go”)
6) 10进制转2,8,16进制：str = strconv.FormatInt(123,2) // 2->8,16
更多语法可参照go语言手册

package main
import (
       "fmt"
       "strconv")
func main() {
    str := "hello北京"
	fmt.Println("str len=",len(str)) //字母和数字占1个字节，汉字占3个字节
    // str len= 11
	str2 := "hello你好"
	//字符串遍历，同时处理有中文的问题 r:=[]rune(str2)
	r:=[]rune(str2)
	for i:=0;i<len(r);i++ {
		fmt.Printf("字符=%c\n",r[i])
	}
	//字符串转整数
	n,err := strconv.Atoi("hell0")
	if err != nil { //nil等价于0 ，若转换成功，则err的值是nil
    fmt.Println("转换错误",err)
	} else {
		fmt.Println("转换结果是:",n)
	}
}

2.日期和时间相关函数

• 需要引用time包
• 时间的变量
  
  时间常量可以在程序中可用于获取指定时间单位的时间，比如想得到100毫秒：100*time.Millisecond

package main
import (
	"fmt"
	"time"
)
func main() {
    //获取当前时间
	now := time.Now()
	fmt.Printf("now time =%v \t type=%T\n",now,now)
	//通过now获取年月日，时分秒
	fmt.Printf("year=%v\t",now.Year())
	fmt.Printf("month=%v\t",now.Month())
	fmt.Printf("day=%v",now.Day())
	}

运行结果：

now time =2022-02-10 18:48:58.3497081 +0800 CST m=+0.007551901   type=time.Time
year=2022       month=February  day=128

• 休眠
  func Sleep(d Duration)
  案例：time.Sleep(100*time.Millisecond) //休眠100毫秒

//需求：每隔0.1秒中打印一个数字，打印到100时就退出
	i := 0
	for {
		i++
		fmt.Println(i)
		//休眠
		//time.Sleep(time.Second)
		time.Sleep(time.Millisecond*100) //休眠0.1秒
		if i==100 {
			break
		}

案例：编写一段代码来统计 函数test 执行的时间

package main
import (
	"fmt"
	"time"
	"strconv"
)
func test() {
	str := ""
	for i := 0;i<100000;i++ {
		str +="hello"+strconv.Itoa(i)
	}
}
func main() {
    //在执行test前，先获取到当前的unix时间戳
	start := time.Now().Unix()
	test()
	end := time.Now().Unix()
	fmt.Printf("执行test耗费时间为%v秒\n",end-start)
}

执行test耗费时间为10秒

3.数组

1. 数组可以存放多个同一类型数据，数据也是一种数据类型。在Go语言中，数组是值类型。

• 快速入门案例：

package main
import "fmt"
func main() {
    var a [100]int //定义整型数组
	sum := 0
  for i:=0;i<100;i++ {
	  a[i]=i //给数组赋值
	  sum+=a[i]
  }
  fmt.Println("100以内的数的总和:",sum)
  //fmt.Sprintf("%.2f",sum/5) 将sum/5四舍五入保留到小数点后两位并返回值
  average := fmt.Sprintf("%.2f",float64(sum/5))
  fmt.Println("average=",average)
}

100以内的数的总和: 4950
average= 990.00

2. 四种初始化数组的方式：

var n1 [3]int = [3]int{1,2,3}
var n2 = [3]int{1,2,3}
var n3 = […]int{1,2,3}
var n4 = […]int{1:6,0:9,2:0} //:前面的数字是数组下标

string类型推导：

package main
import "fmt"
func main() {
    str05 := [...]string{1:"tom",0:"jack",2:"mary"}
	fmt.Println("stro5=",str05)
	//输出结果：stro5= [jack tom mary]
}

3.数组注意事项

• 数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的,不能动态变化。
• var arr []int 这时 arr 就是一个slice切片。
• 数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用。
• 数组创建后，如果没有赋值，有默认值
  数值类型数组：默认值为 0
  字符串数组：默认值为 “”
  bool数组：默认值为 false
• 使用数组的步骤 1.声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组
• 数组的下标是从0开始的。
• 数组下标必须在指定范围内使用，否则报 panic：数组越界，比如
  var arr [5]int 则有效下标为 0-4
• Go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝。数组间不会相互影响
• 如想在其它函数中，去修改原来的数组，可以使用引用传递(指针方式)

4.数组应用案例

// 1.创建一个byte类型的26个元素的数组，分别放置'A'-'Z'并打印出来
package main
import "fmt"
func main() {
    var ch [26]byte
	for i:=0;i<26;i++ {
		ch[i]='A'+byte(i)
	}
	for i:=0;i<26;i++ {
		fmt.Printf("%c",ch[i])
	}
}
//输出结果：ABCDEFGHIJKLMNOPQRSTUVWXYZ

// 2.求出一个数组的最大值，并得到对应的下标
package main
import "fmt"
func main() {
    var a = [...]int{-1,8,24,8,47,14}
	max := a[0]
	maxindex := 0
	for i:=1;i<len(a);i++ {
		//从第二个元素开始比较，如果比前一个更大，则交换
		if max < a[i] {
			max=a[i]
			maxindex=i
		}
	}
	fmt.Printf("数组中元素的最大值是：%v，对应的下标是：%v",max,maxindex)
}
//输出结果：数组中元素的最大值是：47，对应的下标是：4

5.切片

• 切片的基本介绍
  1）切片的英文是slice
  2）切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。
  3）切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度len(slice)都一样。
  4）切片的长度是可以变化的，因此切片是一个可以动态变化数组。
  5）切片定义的基本语法:
  var 切片名 []类型
  比如：var a [] int

package main
import "fmt"
func main() {
    var a = [...]int{1,58,26,16,8,21}
	slice := a[1:3] // 声明/定义一个切片
	// a[1:3]表示引用a数组元素的起始下标为1，最后的下标为3(但是不包含3)
	fmt.Println("数组元素是",a)
	fmt.Printf("slice的元素是：%v\t元素个数是：%v",slice,len(slice))
}

输出结果：

数组元素是 [1 58 26 16 8 21]
slice的元素是：[58 26]  元素个数是：2

• 切片的使用有两种方式
  方式1：定义一个切片，然后让切片去引用一个已经创建好的数组。
  自
  方式2：通过make来创建切片.
  基本语法:var 切片名[]type = make([], len,[cap])
  【参数说明: type:就是数据类型 len:大小 cap：指定切片容量】

package main
import "fmt"
func main() {
    var slice []float64 = make([]float64,5,10)
	slice[1] = 10
	slice[3] = 20
	//对于切片，必须make使用
	fmt.Println(slice)
	fmt.Println("slice的大小：",len(slice))
	fmt.Println("slice的容量：",cap(slice))
}

[0 10 0 20 0]
slice的大小： 5
slice的容量： 10

切片注意事项和细节说明

• 切片初始化时 var slice = arr[startIndex:endIndex]
  说明：从arr数组下标为startIndex，取到下标为endIndex的元素(不含
  arr[endIndex])。
• 切片初始化时，仍然不能越界。范围在[O-len(arr)]之间，但是可以动态增长。

1. var slice = arr[0:end]可以简写 var slice = arr[:end]
2. var slice = arr[start:len(arr)]可以简写：var slice = arr[start:]
3. var slice = arr[0:len(arr)]可以简写: var slice = arr[:]

• cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
• 切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组,或者make一个空间供切片来使用
• 切片可以继续切片

切片练习题：

//使用切片打印斐波那契数列
package main
import "fmt"

func fn(n int)([]uint64) { //声明一个大小为n的切片
	fnslice := make([]uint64,n)
	//第一个和第二个斐波那契数为1
	fnslice[0]=1
	fnslice[1]=1
	for i:=2;i<n;i++ {
		fnslice[i]=fnslice[i-1]+fnslice[i-2]
	}
	return fnslice
}
func main() {
    var n int 
	fmt.Println("请输入n的值：")
	fmt.Scan(&n)
	fnslice := fn(n)
	fmt.Println("斐波那契数列为：",fnslice)
}

输出结果：

请输入n的值：
8
斐波那契数列为： [1 1 2 3 5 8 13 21]

6.二维数组

定义二维数组：var 数组名 [ ][ ]数据类型
例如：var arr [2][3]int

• 二维数组遍历方式有两种：
  1.双重for循环
  2.for-range

package main
import "fmt"
func main(){
//演示二维数组的遍历
var arr =[2][3]int{{1,2,3},{4,5,6}}
//for循环遍历
for i := 0; i< len(arr); i++{
for j := 0; j <len(arr[i]);j++{
fmt.Printf("%v\t", arr[i][j])
}
fmt.Println()
}
//for-range遍历
for i,v:= range arr {
for j, v2 := range v {
    fmt.Printf("arr[%d][%d]=%d \t",i, j, v2)
}
    fmt.Println()
}
}

输出结果：

1       2       3
4       5       6
arr[0][0]=1     arr[0][1]=2     arr[0][2]=3
arr[1][0]=4     arr[1][1]=5     arr[1][2]=6