系统函数

2022-02-22 大约 5 分钟

内置函数是GO语言可以直接使用的一些函数，不需要导包就可以使用。

# 字符串相关函数

# `len`

统计字符串的长度，按字节进行统计

func main() {
	str := "golang你好"
	// 在golang中，汉字是utf-8字符集，一个汉字3个字节
	fmt.Println(len(str)) // 12字节
}

1
2
3
4
5

# `[]rune()`

字符串遍历

func main() {
	str := "golang你好"

	// 方式一：利用键值循环：for-range
	for i, value := range str {
		fmt.Printf("%d, %c \n", i, value)
	}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# `strconv.Atoi()`

字符串转整数

import "strconv"

func main() {
	num1, _ := strconv.Atoi("666")
	fmt.Println(num1) // 666
}

1
2
3
4
5
6

# `strconv.Itoa()`

整数转字符串

import "strconv"

func main() {
	str := strconv.Itoa(666)
	fmt.Println(str) // 666
}

1
2
3
4
5
6

# `string.Contains()`

查找子串是否在指定的字符串中

# `string.Count()`

统计一个字符串有几个指定的字串

import "strings"

func main() {
	// 统计一个字符串有几个指定的字串
	count := strings.Count("golangandjavaga", "ga")
	fmt.Println(count) // 2
}

1
2
3
4
5
6
7

# `string.EqualFold()`

不区分大小写的字符串比较

import "strings"

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

1
2
3
4
5
6
7
8
9
10

# `string.Index()`

返回字串在字符串第一次出现的索引值，如果没有返回 -1

import "strings"

func main() {
	fmt.Println(strings.Index("golangandjavaga", "ga0")) // -1
}

1
2
3
4
5

# `strings.Replace`

n可以指定你希望替换几个，如果n=-1表示全部替换，替换两个n就是2

package main

import (
	"fmt"
	"strings"
)

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

	fmt.Println(str1) // golandandjavagolandgoland
	fmt.Println(str2) // golandandjavagolandgoland
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# `strings.Split`

按照指定的某个字符为分隔符，将一个字符串拆分成字符串数组

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 字符串的替换
	str1 := strings.Split("grand-java-gogo", "-")

	fmt.Println(str1) // [grand java gogo]
}

1
2
3
4
5
6
7
8
9
10
11
12
13

# `strings.ToLower`

将字符串的字母进行大小写的转换

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToLower("GO")) // go
	fmt.Println(strings.ToUpper("go")) // GO
}

1
2
3
4
5
6
7
8
9
10
11

# `strings.TrimSpace`

将字符串左右两边的空格去掉

package main

import (
	"fmt"
	"strings"
)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# `strings.HasPrefix`

判断字符串是否以指定的字符串开头

package main

import (
	"fmt"
	"strings"
)

func main() {
    // 判断字符串是否以指定的字符串结束
	fmt.Println(strings.HasSuffix("demo.png", ".jpg"))             // false
    // 判断字符串是否以指定的字符串开头
	fmt.Println(strings.HasPrefix("https://java.sun.com", "http")) // true
}

1
2
3
4
5
6
7
8
9
10
11
12
13

# 日期和时间相关函数

日期和时间的函数，需要导入time包，所以你获取当前时间，就要调用函数Now函数。

package main

import (
	"fmt"
	"time"
)

func main() {
	// 时间和日期的函数，需要导入time包，所以你获取当前时间，就要调用Now函数。
	now := time.Now()
	//Now()返回值是一个结构体，类型是：time.Time
	fmt.Printf("%v -- 对应的类型为：%T \n", now, now) // 2022-02-23 23:49:06.5122042 +0800 CST m=+0.006686301 -- 对应的类型为：time.Time

	// 调用结构体中的方法
	fmt.Printf("年：%v \n", now.Year())       // 年：2022
	fmt.Printf("月 %v \n", now.Month())      // 月：February
	fmt.Printf("月 %v \n", int(now.Month())) // 月：2
	fmt.Printf("日 %v \n", now.Day())        // 日 23
	fmt.Printf("时 %v \n", now.Hour())       // 时 23
	fmt.Printf("分 %v \n", now.Minute())     // 分 49
	fmt.Printf("秒 %v \n", now.Second())     // 秒 6

	// Printf 将字符串直接输出  输出：当前年月日：2022-2-23 时分秒 23:57:30
	fmt.Printf("当前年月日：%d-%d-%d 时分秒 %d:%d:%d \n", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
	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) // 当前年月日：2022-2-23 时分秒 23:57:30

	// 格式化时间-固定格式，各个数字必须这样写
	dateStr2 := now.Format("2006/01/02 15:04:05")
	fmt.Println(dateStr2) // 2022/02/23 23:57:30
	
	// 自定义组合
	dateStr3 := now.Format("2006 15:04")
	fmt.Println(dateStr3) // 2022 23:57
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 内置函数

golang设计者为了编程方便，提供了一些函数，这些函数不用导包可以直接使用，我们称为Go的内置函数/内建函数。内建函数在builtin包下。

# 常用函数

# `len`函数

统计字符串的长度，按字节进行统计

语法：

func len(v Type) int

内建函数len返回 v 的长度，这取决于具体类型：

1、数组：v中元素的数量
2、数组指针：*v中元素的数量（v为nil时panic）
3、切片、映射：v中元素的数量；若v为nil，len(v)即为零
4、字符串：v中字节的数量
5、通道：通道缓存中队列（未读取）元素的数量；若v为 nil，len(v)即为零

1
2
3
4
5
6
7

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

1
2
3
4
5

# `new`函数

分配内存，主要用来分配值类型(int系列，float系列，bool，string，数组和结构体struct)

语法：

// 内建函数new分配内存。其第一个实参为类型，而非值。其返回值为指向该类型的新分配的零值的指针。
func new(Type) *Type

1
2

func main() {
	// 定义一个字符串
	num := new(int)
	// num的类型：*int, num的值是：0xc000016088，num的地址：0xc000006028，num指针指向的值是：0
	fmt.Printf("num的类型：%T, num的值是：%v，num的地址：%v，num指针指向的值是：%v\n", num, num, &num, *num) // 6
}

1
2
3
4
5
6

# `make`函数

分配内存，主要用来分配引用类型(指针、slice切片、map、管道chan、interface等)

语法：

func make(Type, size IntegerType) Type

内建函数make分配并初始化一个类型为切片、映射、或通道的对象。其第一个实参为类型，而非值。make的返回类型与其参数相同，而非指向它的指针。其具体结果取决于具体的类型：

切片：size指定了其长度。该切片的容量等于其长度。切片支持第二个整数实参可用来指定不同的容量；
     它必须不小于其长度，因此 make([]int, 0, 10) 会分配一个长度为0，容量为10的切片。
映射：初始分配的创建取决于size，但产生的映射长度为0。size可以省略，这种情况下就会分配一个
     小的起始大小。
通道：通道的缓存根据指定的缓存容量初始化。若 size为零或被省略，该信道即为无缓存的。

1
2
3
4
5

系统函数

# 字符串相关函数

# len

# []rune()

# strconv.Atoi()

# strconv.Itoa()

# string.Contains()

# string.Count()

# string.EqualFold()

# string.Index()

# strings.Replace

# strings.Split

# strings.ToLower

# strings.TrimSpace

# strings.HasPrefix

# 日期和时间相关函数

# 内置函数

# 常用函数

# len函数

# new函数

# make函数

详情

# `len`

# `[]rune()`

# `strconv.Atoi()`

# `strconv.Itoa()`

# `string.Contains()`

# `string.Count()`

# `string.EqualFold()`

# `string.Index()`

# `strings.Replace`

# `strings.Split`

# `strings.ToLower`

# `strings.TrimSpace`

# `strings.HasPrefix`

# `len`函数

# `new`函数

# `make`函数