统计
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
}
}
标签：func,函数,int,fmt,str,Go,main
From： https://www.cnblogs.com/Map1eaf/p/17219755.html