Golang基础-系统函数三(九)

系统函数

1.字符串相关函数

1.1 详解01

【1】统计字符串的长度,按字节进行统计：
len(str)
使用内置函数也不用导包的，直接用就行

package main
import "fmt"

func main(){
	//统计字符串的长度，按字节进行统计:
	str := "golang你好" //在golang中，汉字是utf-8字符集，一个汉字三个字符
	fmt.Println(len(str)) //12字节
}

【2】字符串遍历：
(1)利用方式1：for-range键值循环：

package main
import "fmt"

func main(){

	//对字符串进行遍历
	//方式1：利用键值循环：for-range
	for i , value := range str {
		fmt.Printf("索引为：%d,具体的值为：%c \n",i,value)
	}
}

（2）r:=[]rune(str)

package main
import "fmt"

func main(){
	//统计字符串的长度，按字节进行统计:
	str := "golang你好" //在golang中，汉字是utf-8字符集，一个汉字三个字符
	fmt.Println(len(str)) //12字节

	//对字符串进行遍历
	//方式1：利用键值循环：for-range
	for i , value := range str {
		fmt.Printf("索引为：%d,具体的值为：%c \n",i,value)
	}

	//方式2：利用r:=[]rune(str)
	r := []rune(str)
	for i := 0; i < len(r); i++ {
		fmt.Printf("%c \n",r[i])
	}
}

【3】字符串转整数：
n, err := strconv.Atoi(“66”)

【4】整数转字符串：
str = strconv.Itoa(6887)

**【5】查找子串是否在指定的字符串中: **
strings.Contains(“javaandgolang”, “go”)

package main
import (
	"fmt"
	"strconv"
)

func main(){
	//字符串转整数：
	num1,_ := strconv.Atoi("666")
	fmt.Println(num1)

	//整数转字符串：
	str1 := strconv.Itoa(88)
	fmt.Println(str1)
}

【6】统计一个字符串有几个指定的子串:
strings.Count(“javaandgolang”,“a”)

package main
import (
	"fmt"
	"strconv"
	"strings"
)
func main(){
	//统计字符串的长度，按字节进行统计:
	str := "golang你好" //在golang中，汉字是utf-8字符集，一个汉字三个字符
	fmt.Println(len(str)) //12字节

	//统计一个字符串有几个指定的子串：
	count := strings.Count("golangandjavaga","ga")//入前面字符串"golangandjavaga"里面有两个ga，结果就是2，如果只有一个，结果就是1
	fmt.Println(count)
}

【7】不区分大小写的字符串比较:
strings.EqualFold(“hello” , “HELLO”)

package main
import (
	"fmt"
	"strconv"
	"strings"
)

func main(){
	//统计字符串的长度，按字节进行统计:
	str := "golang你好" //在golang中，汉字是utf-8字符集，一个汉字三个字符
	fmt.Println(len(str)) //12字节

	//不区分大小写的字符串比较
	flag := strings.EqualFold("hello","HELLO")
    fmt.Println(flag) //true

	//区分大小写的字符串比较
    fmt.Println("hello"=="Hello") //false
}

【8】返回子串在字符串第一次出现的索引值，如果没有返回-1 :
strings.lndex(“javaandgolang” , “a”)

package main
import (
	"fmt"
	"strings"
)

func main(){
	//返回子串在字符串第一次出现的索引值，如果没有返回-1 :
	fmt.Println(strings.Index("golangandjavaga","ga0")) //-1
	//返回子串在字符串第一次出现的索引值，如果有返回对应的位数(从0开始) 
	fmt.Println(strings.Index("golangandjavaga","go")) //0
}

1.2 详解02

【9】字符串的替换：
strings.Replace(“goandjavagogo”, “go”, “golang”, n)
n可以指定你希望替换几个,如果n=-1表示全部替换，替换两个n就是2

package main
import (
	"fmt"
	"strings"
)

func main(){
    //字符串的替换：
	str1 := strings.Replace("goandjavagogo", "go", "golang", -1) 
	str2 := strings.Replace("goandjavagogo", "go", "golang", 2) 
	fmt.Println(str1)
	fmt.Println(str2)
}

【10】按照指定的某个字符，为分割标识，将一个学符串拆分成字符串数组:
strings.Split(“go-python-java”, “-”)

package main
import (
	"fmt"
	"strings"
)

func main(){
	//按照指定的某个字符，为分割标识，将一个学符串拆分成字符串数组:**
     arr := strings.Split("go-python-java", "-")
	 fmt.Println(arr)
}

【11】将字符串的字母进行大小写的转换:
strings.ToLower(“Go”)// go
strings.ToUpper"go")//Go

package main
import (
	"fmt"
	"strings"
)

func main(){
	//将字符串的字母进行大小写的转换:
    fmt.Println(strings.ToLower("Go"))// go 
    fmt.Println(strings.ToUpper("go"))//Go
}

【12】将字符串左右两边的空格去掉:
strings.TrimSpace(" go and java ")

package main
import (
	"fmt"
	"strings"
)

func main(){
	//将字符串左右两边的空格去掉:
    fmt.Println(strings.TrimSpace("     go and java    "))
}

【13】将字符串左右两边指定的字符去掉:
strings.Trim("_golang “, " ~”)

package main
import (
	"fmt"
	"strings"
)

func main(){
	//将字符串左右两边指定的字符去掉:
    fmt.Println(strings.Trim("~golang~", "~"))
}

【14】将字符串左边指定的字符去掉:
strings.TrimLeft(“_golang”, “~”)

【15】将字符串右边指定的字符去掉:
strings.TrimRight(“_golang”, “~”)

**【16】判断字符串是否以指定的字符串开头: **
strings.HasPrefix(“http://java.sun.com/jsp/jstl/fmt”, “http”)

//判断字符串是否以指定的字符串开头: 
fmt.Println(strings.HasPrefix("http://java.sun.com/jsp/jstl/fmt", "http"))

**【17】判断字符串是否以指定的字符串结束: **
strings.HasSuffix(“demo.png”, “.png”)

//判断字符串是否以指定的字符串结束: 
fmt.Println(strings.HasSuffix("demo.png", ".png"))
//判断字符串是否以指定的字符串结束: 
fmt.Println(strings.HasSuffix("demo.png", ".jpg"))

2.日期和时间相关函数

1.1 详解

【1】时间和日期的函数，需要到入time包，所以你获取当前时间，就要调用函数Now函数：

package main
import (
	"fmt"
	"time"
)

func main(){
     //时间和日期的函数，需要导入time包，所以你获取当前的时间，就要调用函数Now函数：
	 now := time.Now()
	 //Now()返回值是一个结构体，类型是：time.Time
	 fmt.Printf("%v \n 对应的类型为：%T \n",now,now)
	 //2021-10-11 19:45:13.0577355 +0800 CST m=+0.008870701
     //对应的类型为：time.Time
	 fmt.Println(now)//2021-10-11 19:41:03.9336665 +0800 CST m=+0.007760301
     //调用结构体中的方法：
	 fmt.Printf("年：%v \n",now.Year())
	 fmt.Printf("月：%v \n",now.Month())//October
	 fmt.Printf("月：%v \n",int(now.Month()))//10
	 fmt.Printf("日：%v \n",now.Day())
	 fmt.Printf("时：%v \n",now.Hour())
	 fmt.Printf("分：%v \n",now.Minute())
	 fmt.Printf("秒：%v \n",now.Second())
}

【2】日期的格式化：
（1）将日期以年月日时分秒按照格式输出为字符串：

package main
import (
	"fmt"
	"time"
)

func main(){
	 //Printf将字符串直接输出
	 fmt.Printf("当前年月日：%d-%d-%d 时分秒：%d:%d:%d \n",now.Year(),now.Month(),
	 now.Day(),now.Hour(),now.Minute(),now.Second())
     //Sprintf可以得到字符串，以便后续使用
	 datestr := fmt.Sprintf("当前年月日：%d-%d-%d 时分秒：%d:%d:%d \n",now.Year(),now.Month(),
	 now.Day(),now.Hour(),now.Minute(),now.Second())
	 fmt.Println(datestr)
}

（2）按照指定格式：

package main
import (
	"fmt"
	"time"
)

func main(){

	 fmt.Println("------------------------------------")
	 //这个参数字符串的各个数字必须是固定的，必须这样写
	 datestr2 := now.Format("2006/01/02 15/04/05")
     fmt.Println(datestr2)
     //选择任意的组合都是可以的，根据需求自己选择就可以（自己任意组合）
	 datestr3 := now.Format("2006 15：04")
     fmt.Println(datestr3)
}

1.2 内置函数

【1】什么是内置函数/内建函数：
Golang设计者为了编程方便，提供了一些函数，这些函数不用导包可以直接使用，我们称为Go的内置函数/内建函数。

【2】内置函数存放位置：
在builtin包下，使用内置函数也的，直接用就行

【3】常用函数：
（1）len函数：
统计字符串的长度,按字节进行统计

package main
import "fmt"

func main(){
    //定义一个字符串：
	str := "golang"
	fmt.Println(len(str))
}

（2）new函数：
分配内存，主要用来分配值类型（int系列, float系列, bool, string、数组和结构体struct）

package main
import "fmt"

func main(){
    //new分配内存，new函数的实参是一个类型而不是具体数值，new函数返回值是对应类型的指针 num: *int
	num := new(int)
	fmt.Printf("num的类型：%T ,\n num的值是：%v ,\n num的地址：%v ,\n num指针指向的值是：%v \n",
    num,num,&num,*num)
}

（3）make函数：
分配内存，主要用来分配引用类型（指针、slice切片、map、管道chan、interface 等）