Go(2)

统计

1出现的频率
string.Count(str,x)
//str:是待查找的字符串
//x:可以是一个字符串也可以是一个变量，反应的是变量的值
2字符数量
len([]rune(str))
或
import
	"unicode/utf-8"
utf8.RuneCountInString(str)

大小写转换

strings.ToLower(str) 转为小写
strings.ToUpper(str) 转为大写

修剪

strings.Trim(str,x) 修剪str左右两边开头的字符串
strings.TrimLeft(str,x)   仅修剪左边开头的
strings.TrimRight(str,x)  仅修剪右边开头的

分割

strings.Split(str,x)   分割了函数返回的是切片类型

 

 

插入字符

strings.Join(str,string) ///aaa bbb ccc ->aaa;bbb;ccc

//string.Field()
package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "hello world hello world"
	index := strings.Fields(s)
	fmt.Println(index)
	fmt.Println(len(index)) //4
}

strconv包

用于字符串和其他类型的转换

strconv.Itoa(x)   十进制转字符串
strconv.FormatFloat(x)    64位浮点数转字符串
strconv.Atoi(x)   字符串转int
strconv.ParseFloat(x) 字符串转float64

字符串的格式化

 

 

基本数据类型的扩展

强制类型转换

type_name(exp)
//float64(x)

自定义类型

就是结构体

type stu stuct{
	Name string //首字母大写就是public
    age int  //小写就是private
    //都支持用set&get的方法使用
}

类型别名

byte是int8的别名；rune是int32的别名

 

 

指针

用&a  访问a的地址

nil指针

一个地址为0的指针

条件语句

if condition {
    
}else if condition {

}else{
    
}

选择语句

switch语句

package main

import (
	"fmt"
)

func main() {
	grade := "B"
	mark := 90
	switch mark {
	case 90:
		grade = "A"
	case 80:
		grade = "B"
	case 60, 70:
		grade = "C"
	default:
		grade = "D"
	}
	fmt.Printf("你的成绩为%s", grade)
}
//不同的地方就是他是执行了一个case不需要breack下面的case也不会执行
fallthrough会将控制跳到下个case

select语句

用于多个channel的并发读写操作，和switch不同他是随机一个case进行判断

package main

import (
	"fmt"
)

func main() {
	a := make(chan int, 1024)
	b := make(chan int, 1024)
	for i := 1; i <= 10; i++ {
		fmt.Printf("第%d次,", i)
		a <- 1
		b <- 1
		select {
		case <-a:
			fmt.Println("from a")
		case <-b:
			fmt.Println("from b")
		}
	}
}

循环语句

range子语句

 

 

 

 

 

延迟语句

defer是用延迟调用指定函数，只能出现在函数内部

 

 

所以defer一般用于回收资源、清理收尾等工作

defer的两个特点：

• 只有当defer语句全部执行完，defer所在的函数才算执行结束
• 全部defer语句执行完，才可以return

   

//返回
5
5
5
5
5

//栈 先入后出

标签

 

 

break
continue
goto

package main

func main() {
	var i int
	for {
		println(i)
		i++
		if i > 2 {
			goto BREAK //goto会跳转至BREAK标签
		}
	}
BREAK:
	println("break")v
}

函数

函数的声明

func 用于声明函数

函数名 用小写开头 只作用于所声明的包中 不能被其他包调用

用大写开头 可以被其他包调用

注意：go语言函数不支持嵌套、重载、默认参数

声明一个在外部定义的函数只需给出函数名和函数签名

func hello (str,num int)//外部实现

函数同样可以通过声明的方式作为一个函数类型被使用

type addNum func(int,int) int

函数可以被赋值给变量

add :=addNum

函数之间可以相互比较

引用相同的函数或返回值都是nil，则可以认为它们是相同的函数

函数不能在其他函数里面声明，就是不能嵌套

函数的参数

多个参数之间用","分割开，如果有多个相邻参数的类型相同可以合并

func Add(a,b int)(ret int,err error){
    
}

如果返回值列表中多个返回值的类型相同，也可以合并

func Add(a,b int) int{
     
}

函数的返回值

可以多返回值

多返回值说明返回值有不需要的可能，要用空标识符

函数作为类型

package main

import (
	"fmt"
)

func isOdd(v int) bool {//判断是否为单数
	if v%2 == 0 {
		return false
	}
	return true
}
func isEven(v int) bool {//判断是否为双数
	if v%2 == 0 {
		return true
	}
	return false
}

type boolFunc func(int) bool //便利性

func filter(slice []int, f boolFunc) []int {  //把函数当做参数
	var result []int
	for _, value := range slice { //遍历slice切片
		if f(value) {
			result = append(result, value)//append函数()在result后面在value元素
		}
	}
	return result
}
func main() {
	slice := []int{3, 1, 4, 5, 9, 2}
	fmt.Println("slice=", slice)
	odd := filter(slice, isOdd)
	fmt.Println("odd:", odd)
	even := filter(slice, isEven)
	fmt.Println("even:", even)
}

/*
slice= [3 1 4 5 9 2]
odd: [3 1 5 9]
even: [4 2]
*/

可变参数

func myfunc(arg ...int){
    
}

他们的类型都是一样的，可以用for来遍历

package main

import (
	"fmt"
)

func main() {
	//手动填写参数
	age := minormax("min", 1, 3, 2, 0)
	fmt.Printf("min:%d\n", age)
	//数组作为参数
	ageArr := []int{7, 9, 3, 5, 1}
	age = minormax("max", ageArr...)//注意数组后面要加...
	fmt.Printf("max:%d", age)
}
func minormax(m string, a ...int) int {
	if len(a) == 0 {
		return 0
	}
	if m == "max" {
		max := a[0]
		for _, v := range a {
			if v > max {
				max = v
			}
		}
		return max
	} else if m == "min" {
		min := a[0]
		for _, v := range a {
			if v < min {
				min = v
			}
		}
		return min
	} else {
		e := -1
		return e
	}

}