标签：特点 add 穿透 可变参数 field case语法 出错 count aaaaa
1、strings.HasPrefix(s string,prefix string) bool :判断字符串s是否以prefix开头
2、stings.HasSuffix(s string,suffix string) bool:判断字符串s是否以suffix结尾
3、strings.Index(s string,str string) int: 判断str在s中首次出现的位置，如果没有，返回-1
4、strings.LastIndex(s string,str string) int:判断str在s中最后出现的位置，如果没有，返回-1
5、strings.Replace(str string, old string, new string, n int)：字符串替换
6、strings.Count(str string, substr string)int：字符串计数
7、strings.Repeat(str string, count int)string：重复count次str
8、strings.ToLower(str string)string：转为小写
9、strings.ToUpper(str string)string：转为大写
package main
import (
"fmt"
"strings"
)
//判断字符串以xx开头
func judge_prefix(str string) string {
var str_change string
if strings.HasPrefix(str, "http://") == false {
str_change = "http://" + str
}
return str_change
}
//判断字符串以xx结尾
func judge_suffix(str string) string {
var str_change string
if strings.HasSuffix(str, "/") == false {
str_change = str + "/"
}
return str_change
}
//字符串中s首次出现的位置，没有返回-1
func str_index(str string, show_str string) int {
result := strings.Index(str, show_str)
return result
}
//字符串替换，n代表字符串出现第一次，-1表示全部替换
func replace(str string, old string, new string, n int) string {
result := strings.Replace(str, old, new, n)
return result
}
//字符串中出现某字符串的次数
func count(str string, substr string) int {
result := strings.Count(str, substr)
return result
}
func main() {
url := judge_prefix("baidu.com")
path := judge_suffix("go_dev")
index := str_index("llohehe", "he")
replace := replace("hellohehe", "he", "wo", -1)
count := count("hellohehe", "he")
fmt.Println("url", url)
fmt.Println("path", path)
fmt.Println("index", index)
fmt.Println("replace", replace)
fmt.Println("count", count)
}
strings.TrimSpace(str string)：去掉字符串首尾空白字符
strings.Trim(str string, cut string)：去掉字符串首尾cut字符
strings.TrimLeft(str string, cut string)：去掉字符串首cut字符
strings.TrimRight(str string, cut string)：去掉字符串首cut字符
strings.Field(str string)：返回str空格分隔的所有子串的slice
strings.Split(str string, split string)：返回str split分隔的所有子串的slice
strings.Join(s1 []string, sep string)：用sep把s1中的所有元素链接起来
strconv.Itoa(i int)：把一个整数i转成字符串
strconv.Atoi(str string)(int, error)：把一个字符串转成整数
package main
import (
"fmt"
"strings"
"strconv"
)
//去空格
func removeSpace(str string) string {
result := strings.TrimSpace(str)
return result
}
//字符串首尾remove某字符
func removeStr(str string, cut string) string {
result := strings.Trim(str, cut)
return result
}
func removeLeft(str string, cut string) string {
result := strings.TrimLeft(str, cut)
return result
}
func main() {
removeSpace := removeSpace(" xxx ")
removeStr := removeStr("abbaaaaaaacdab", "ab")
removeLeft := removeLeft("abbacdab", "ab")
strSplit("abc,def,ghi", ",")
fmt.Println(removeSpace)
fmt.Println(removeStr)
fmt.Println(removeLeft)
splitResult := strings.Split(str,"l")
str2 = strings.Join(splitResult,"l")
str2 = strconv.Itoa(1000)
number,err := strconv.Atoi(str2)
if err != nil{
fmt.Println("can not convert to int",err)
}
}
1、time包
2、time.Time类型，用来表示时间
3、获取当前时间，now :=time.Now()
4、time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year()
5、格式化，fmt.Printf(“%02d/%02d%02d %02d:%02d:%02d”, now.Year()…)
example：获取当前时间，并格式化成2018/04/07 16:09:00格式
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now.Format("2006/01/02 15:04:05"))
}
example：获取程序执行时间
package main
import (
"fmt"
"time"
)
func test() {
time.Sleep(time.Millisecond * 100)
}
func main() {
start := time.Now().UnixNano()
test()
end := time.Now().UnixNano()
fmt.Printf("cost:%d us\n", (end-start)/1000)
}
1、普通类型，变量存的就是值，也叫值类型
2、获取变量的地址，用&，比如： var a int, 获取a的地址：&a
3、指针类型，变量存的是一个地址，这个地址存的才是值
4、获取指针类型所指向的值，使用：*，比如：var *p int, 使用*p获取p指向的值
package main
import (
"fmt"
)
func main() {
var a int = 10
fmt.Println(&a)
var p *int //p是指针，存的是地址
p = &a // p=a的地址
*p = 100 //a的地址所指向的值赋值100
fmt.Println(a) //a输出100
}
1、if / else分支判断
package main
import (
"fmt"
)
func main() {
bool1 := true
if bool1 {
fmt.Printf("the value is true")
} else {
fmt.Printf("the value is false")
}
}
example：从终端读取输入，并转成整数，如果转成整数出错，则输出错误，否则输出该整数
package main
import (
"fmt"
"strconv"
)
func main() {
var str string
fmt.Scanf("%s", &str)
number, err := strconv.Atoi(str)
if err != nil {
fmt.Println("conver failed,err:", err)
return
}
fmt.Println(number)
}
2、switch case语法
switch var{
case var1：
case var2：
case var3：
default：
}
package main
import (
"fmt"
)
func main() {
var a int = 10
switch a {
case 0:
fmt.Println("a is equal 0")
case 10:
fmt.Println("a is equal 10")
default:
fmt.Println("a is equal default")
}
}
fallthrough穿透执行
example：猜数字，写一个程序，随机生成一个0到100的整数n，然后用户在终端输入数字，如果和n相等，则提示用户猜对了。如果不相等，则提示用户，大于或小于n
package main
import (
"fmt"
"math/rand"
)
func main() {
var n int
n = rand.Intn(100)
for {
var input int
fmt.Scanf("%d\n", &input)
flag := false
switch {
case input == n:
fmt.Println("you are right")
break
flag = true
case input > n:
fmt.Println("bigger")
case input < n:
fmt.Println("less")
}
if flag {
break
}
}
}
for
写法1 for 初始化语句；条件判断；变量修改
example：终端打印如下图形
package main
import (
"fmt"
)
func Print(n int) {
for i := 1; i < n+1; i++ {
for j := 0; j < i; j++ {
fmt.Printf("A")
}
fmt.Println()
}
}
func main() {
Print(10)
}
写法2：for 条件{
}
写法3：for range 语法
package main
import (
"fmt"
)
func main() {
str := "hello,world,中国"
for i, v := range str {
if i > 2 {
continue
}
if i > 3 {
break
}
fmt.Printf("index[%d] val[%c] len[%d]\n", i, v, len([]byte(string(v))))
}
}
goto和label语句
package main
import (
"fmt"
)
func main() {
LABEL1:
for i := 0; i <= 5; i++ {
for j := 0; j <= 5; j++ {
if j == 4 {
continue LABEL1
}
fmt.Printf("i is:%d,and j is:%d\n", i, j)
}
}
}
package main
import (
"fmt"
)
func main() {
i := 0
HERE:
fmt.Println(i)
i++
if i == 5 {
return
}
goto HERE
}
申明语法
func 函数名 （参数列表） 返回值 { }
golang函数特点：
不支持重载，一个包不能有两个名字一样的函数
函数是一等公民，函数也是一种类型，一个函数可以赋值给变量
匿名函数
多返回值
example1：
package main
import (
"fmt"
)
func add(a, b int) int {
return a + b
}
func main() {
c := add //函数赋值给变量
fmt.Println(c)
sum := c(10, 20)
fmt.Println(sum)
}
example2：定义函数类型
package main
import (
"fmt"
)
type add_func func(int, int) int
func sub(a, b int) int {
return a - b
}
func operator(op add_func, a, b int) int {
return op(a, b)
}
func main() {
c := sub
fmt.Println(c)
sum := operator(c, 100, 200)
fmt.Println(sum)
}
函数参数传递方式：
map、slice、chan、指针、interface默认引用方式传递
函数能对返回值命名
可变参数
example：支持一个或多个int相加或string拼接
func add(a int, arg ...int) int {
var sum int
sum += a
for i := 0; i < len(arg); i++ {
sum += arg[i]
}
return sum
}
func content(a string, arg ...string) string {
var result string = a
for i := 0; i < len(arg); i++ {
result += arg[i]
}
return result
}
func main() {
// result := add(10, 3, 4)
result := content("hello", " ", "world")
fmt.Println(result)
}
defer用途：
当函数返回时，执行defer语句，用来资源清理
多个defer，先进后出方式执行(栈)
example：关闭文件句柄
func read() {
file :=open(filename)
defer file.close()
}
标签：特点 add 穿透 可变参数 field case语法 出错 count aaaaa
原文地址：https://www.cnblogs.com/hongpeng0209/p/8733336.html
