Resumen de funciones de uso general
1. La longitud de las funciones estadísticas de cadena: len (str)
package main
import "fmt"
func main() {
// 统计字符串长度 len(str) hello啊 一共占8字节，汉字统一UTF-8占三字符
str := "hello"
fmt.Println(len(str1)) //5，
str1 := "hello啊"
fmt.Println(len(str1)) //8，可见len()是按照bytes返回的
}
2. traversal String, si se incluye chino, directamente r: = [] runa (str)
package main
import "fmt"
func main() {
// rune采用字符方式遍历，ascii和汉字都是一个字符，不可以用 str := []rune(str) 方式复制，必须用异名变量
str := "hello啊"
r := []rune(str)
for i := 0 ; i <= len(str); i++ {
fmt.Printf("%c\n",r[i])
}
}
3. cadena a entero, entero Cadena
cadena numérica a entero
package main
import (
"fmt"
"strconv"
)
func main() {
//数字字符串由string转为int，使用strconv.Atoi()，函数返回值为两个，结果和err，如果转换失败则用err接收失败结果
//可以使用 num , _ := strconv.Atoi("123") 来忽略结果
num , err := strconv.Atoi("123")
if err != nil { //err不为0，则为出现错误，利用这个特性对数据类型校验
fmt.Println("转换错误，原因是：" , err)
} else {
fmt.Println("转换成功，转换结果为：" , num)
}
}
String en número entero digitales
package main
import (
"fmt"
"strconv"
)
func main() {
// 整数一定可以转成字符串，所以不存在返回err
var num1 int = 123
r1 := strconv.Itoa(num1)
fmt.Printf("%T %v",r1,r1)
}
4. Las secciones de transferencia de cadena binaria transferir las secciones de cuerda binarios
Convertir secciones de cuerdas binarios
package main
import (
"fmt"
)
func main() {
//字符串转二进制切片 使用 []byte(str) 方法
var bytes = []byte("shit!")
fmt.Printf("bytes = %v\n",bytes)
//得到结果可以看到 打印出来的shit!全部是ascii编码的列表 bytes = [115 104 105 116 33]
}
rebanada binario para cuerdas
package main
import (
"fmt"
)
func main() {
str2 := string([]byte{97,98,99})
fmt.Printf(str2)
}
5, 8 función, 16 de transferencia decimal binario strconv.FormatInt ()
package main
import (
"fmt"
"strconv"
)
func main() {
// 10进制转换成2,8,16进制，使用的 str := strconv.FormatInt(num,2/8/16) ，返回值是个字符串
str3 := strconv.FormatInt(10,2) //
fmt.Println(str3)
str4 := strconv.FormatInt(10,16)
fmt.Println(str4)
}
6. Encuentra la subcadena completamente contenida en la cadena de letras
package main
import (
"fmt"
"strings"
)
func main() {
//子串是否在母串中，使用 string.Contains(母串，子串) ，返回是个布尔值，如果包含就是true
str5 := "bullshit!"
ret := strings.Contains(str5,"shit")
fmt.Println(ret)
}
7. partido codiciosos la salida de la consulta, tales como el número de palabras clave contenía un artículo
package main
import (
"fmt"
"strings"
)
func main() {
//子串是否在母串中，使用 string.Count(母串，子串) ，返回值是个int
str6 := "cesebeteure"
ret1 := strings.Count(str6,"e")
fmt.Println(ret1)
}
8. no entre mayúsculas y minúsculas comparación de cadenas usando strings.EqualFold (), si la comparación es == palabras, "ABC"! = "ABC"
package main
import (
"fmt"
"strings"
)
func main() {
//不区分大小写的比较，返回值是一个布尔值
ret2 := strings.EqualFold("abc","ABC")
fmt.Println(ret2)
}
9. subcadena aparece por primera vez en la cadena de letras índice utilizando strings.Index (), el valor de índice para la cadena de caracteres sujeto
package main
import (
"fmt"
"strings"
)
func main() {
//子串在母串中出现第一次的索引值，类似数组指针指向第一个值地址,如果子串不存在返回 -1
str6 := "akunamatata"
ret3 := strings.Index(str6,"tata")
fmt.Printf("ret3=%v\n",ret3) // ret3 = 7 , akunama(tata) t=7，也就是第8位
}
10. La cadena principal sustituido por otro subcadenas subcadenas utilizando strings.Replace (cadena de letras, subcadena, en sustitución de la subcadena, la cantidad de sustitución) 4 parámetros reemplazar todos los <número Alternativamente> = -1
package main
import (
"fmt"
"strings"
)
func main() {
//子串在母串中出现第一次的索引值，类似数组指针指向第一个值地址,如果子串不存在返回 -1
str7 := "no no no !!!"
ret4 := strings.Replace(str7,"no","yes",-1) // 用中文字符串替代也没有问题
fmt.Printf("ret4=%v\n",ret4) // "yes yes yes !!!"
ret4 = strings.Replace(str7,"no","要",-1)
fmt.Printf("ret4=%v\n",ret4)
}
11. dividido (similar a shell awk) de acuerdo con una fracción de cadena de caracteres especificada en una matriz de cadenas, utilizando strings.Split (cadena, delimitador)
package main
import (
"fmt"
"strings"
)
func main() {
//函数需要传递两个参数，一个是字符串，一个是分隔符
str8 := "i love you"
ret5 := strings.Split(str8," ")
fmt.Printf("%v",ret5)
//结果为 [i love you]
//扩展：统计一句话多少个单词
str9 := "i love you you love me oh yeah!"
ret6 := strings.Split(str9," ")
fmt.Println()
for i := 0 ; i < len(ret6) ; i++ {
fmt.Printf("%v = %v",i,ret6[i])
}
}
12. La conversión caso carácter
package main
import (
"fmt"
"strings"
)
func main() {
//全转小写 strings.ToLower(str)； 全转大写 strings.ToUpper(sstr)
str10 := "i loVe yOu You LOvE Me"
ret7 := strings.ToLower(str10) //转小写 i love you you love me
fmt.Printf(ret7)
ret8 := strings.ToUpper(str10) //转大写 I LOVE YOU YOU LOVE ME
fmt.Printf(ret8)
}
13. Un texto procesamiento de espacios en ambos lados, utilizando strings.TrimSpace (str)
package main
import (
"fmt"
"strings"
)
func main() {
//字符串左右两边空格去掉
str11 := " i loVe yOu You LOvE Me "
ret9 := strings.TrimSpace(str11)
fmt.Printf("%q\n",ret9) // "i loVe yOu You LOvE Me"
}
14. Procesamiento de texto especifica carácter en ambos lados, usando strings.Trim (String, <eliminar lo> (escritura continua)), pasando dos parámetros
package main
import (
"fmt"
"strings"
)
func main() {
//字符串左右两边空格去掉
str12 := " ! sh!it !"
ret10 := strings.Trim(str12," !")
fmt.Printf("%v\n",ret10) // shit
//字符串左右的叹号去掉，但是不能去掉中间，注意全角！和半角!是两个不一样的叹号
ret11 := strings.TrimLeft(str12," !") // 只处理左边
fmt.Printf("%v\n",ret11) // sh!it !
ret12 := strings.TrimRight(str12," !") // 只处理右边
fmt.Printf("%v\n",ret12) // ! sh!it
}
15. La cadena se determina si el inicio y final subcadenas utilizando strings.HasPrefix (cadena de letras, la subcadena) al principio, strings.HasSuffix (cadena de letras, la subcadena) en el extremo, devuelve un valor booleano
package main
import (
"fmt"
"strings"
)
func main() {
//是否以子串开头
str13 := "https://www.bilibili.com"
ret13 := strings.HasPrefix(str13,"https://")
fmt.Println(ret13) // true
//是否以子串结尾
str14 := "https://www.bilibili.com"
ret14 := strings.HasSuffix(str14,".com")
fmt.Println(ret14) // true
}
