Go字符串类型

一、字符串

1、字符串

• Go 语言里的字符串的内部实现使用 UTF-8 编码
• 字符串带的值为双引号（"）中的内容，可以在 Go 语言的源码中直接添加非ASCII 码字符

s1 := "hello"
s2 := "您好"

2、字符串转义符

• Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等

package main

import (
    "fmt"
)

func main() {
    fmt.PrintIn("str := \"c:\\Code\\demo\\go.exe\"") // str := "c:\Code\demo\go.exe"
}

3、多行字符串

• 反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出

package main
import (
	"fmt"
)
func main() {
	s1 := `
	第一行
	第二行
	第三行`
	fmt.Println(s1)
}

4、byte 和 rune

• Go 语言的字符有以下两种

uint8 类型，或者叫 byte 型：代表了 ASCII 码的一个字符

rune 类型：代表一个 UTF-8 字符

• 字符串底层是一个 byte 数组，所以可以和[]byte 类型相互转换
• 字符串是不能修改的 字符串是由 byte 字节组成 所以字符串的长度是 byte 字节的长度
• rune 类型用来表示 utf8 字符，一个 rune 字符由一个或多个 byte 组成

package main

import "fmt"

func main(){
    //"比赛第一"
    s := "比赛第一"
    s_rune := []rune(s)
    fmt.PrintIn("友谊"+string(s_rune[2:]))    //友谊第一
}

二、字符串常用操作

方法	介绍
len(str)	求长度
+或 fmt.Sprintf	拼接字符串
strings.Split	分割
strings.Contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string,sep string)	join 操作

1、len（str）

package main

import "fmt"

func main(){
    var str = "this is str"
    fmt.PrintIn(len(str)) //11
}

2、+（拼接）

package main

import "fmt"

func main() {
    var str1 = "您好"
    var str2 = "golang"
    fmt.PrintIn(str1 + str2)    //你好golang
}

3、strings.Split()

package main

import (
    "fmt"
    "strings"
)

func main () {
    var s = "Running-Snail"
    var s1 = strings.Split(s,"-")
    fmt.PrintIn(s1) // [Running Snail]
}

4、strings.HasPrefix()

• 首字符尾字母包含指定字符

package main

import (
    "fmt"
    "strings"
)

func main() {
    //1.判断字符串 以 this 开头
    var str = "this is golang"
    var flag = strings.Hasprefix(str,"this")
    fmt.PrintIn(flag)    //true

    //2.判断字符串以 go 结尾
    var.flag2 = strings.HasSuffix(str,"go")
    fmt.PrintIn(flag2)    //false
}

5、strings.Index()

• 判断字符串出现的位置

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str = "this is golang"
    var index =strings.Index(str,"go")
    fmt.PrintIn(index)    // 8 (判断字符串 go 出现的位置)
}

6、strings.Join()

package main 

import (
    "fmt"
    "strings"
)

func main() {
    var str = "Running-Snail"
    var arr = strings.Split(str,"-")     // [Running Snail]
    var str2 =strings.Join(arr,"*")      // Running*Snail
    fmt.PrintIn(arr)
    fmt.PrintIn(str2)
}   

7、单引号

• 组成每个字符串的元素叫做“字符”，可以通过遍历字符串元素获得字符，字符用单引号(')
• uint8类型，或者叫 byte 类型，代表 ASCII 码的一个字符
• rune 类型，代表一个 UTF-8 字符

package main

import "fmt"

func main(){
    a := 'a'
    name := "snail"
    //当我们直接输出 byte（字符）的时候输出的是这个字符对应的码值
    fmt.PrintIn(a)    // 97 这里输出的是 a 字符串的 ASCII 值
    fmt.PrintIn(name)    // snail
    //如果我们要输出这个字符，需要格式化输出
    fmt.Printf("的值是%c",a)    //a的值是 a
}

三、字符串遍历

1、遍历字符串

package main

import "fmt"

func main(){
    s := "hello snail"
    for i := 0; i<len(s);i++ { //byte
        fmt.Printf("%v(%c)",s[I],s[I])
        // 104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 115(s) 110(n) 97(a) 105(i) 108(l) 
    }
    
    fmt.PrintIn()    //打印一个换行

    for _,r := range s { //rune
        fmt.Prinf("%v=>%c",r,r)
        //104=>h 101=>e 108=>l 108=>l 111=>o 32=>  115=>s 110=>n 97=>a 105=>i 108=>l
    }
}

2.修改字符串

• 要修改字符串，需要先将其转换成[]rune或 byte，完成后再转换为 string
• 无论那种转换，都会重新分配内存，并复制字节数组

package main

import "fmt"

func main(){
    s1 := "snail"
    //强制类型转换
    byteS := []byte(s1)
    byteS1[0] = 'p'
    fmt.PrintIn(string(byteS1))    //pnail 

    s2 := "白萝卜"
    runeS2 := []rune(s2)
    runeS2[0] = '红'
    fmt.PrintIn(string(runeS2))    //红萝卜
}

四、转 String

1、sprintf 转 string

• 注意：sprintf 使用中需要注意转换的格式
  • int 为%d
  • float 为%f
  • bool 为%t
  • byte 为%c

package main

import "fmt"

func main() {
    var i int = 20
    var f float64 = 12.456
    var t bool = true
    var b byte = 'a'
    var strs string
    
    strs=fmt.Sprintf("%d",i)    //把int 转换成 string
    fmt.Printf("类型： %T，值=%v\n",strs,strs)    //类型：string，值 =20

    strs= fmt.Sprintf("%f",f)    //把 float转换成 string
    fmt.Printf("类型： %T ,值=%v \n", strs, strs)  // 类型： string ,值=12.456000

	strs = fmt.Sprintf("%t", t)  // 把 bool 转换成 string
	fmt.Printf("类型： %T ,值=%v \n", strs, strs)  // 类型： string ,值=true

	strs = fmt.Sprintf("%c", b)  // 把 byte  转换成 string
	fmt.Printf("类型： %T ,值=%v \n", strs, strs)  // 类型： string ,值=a
}

2、strconv

package  main

import (
    "fmt"
    "strconv"
)

fun main () {
    //1、int转换成 string
    var num1 int = 20
    s1 := strong.Itoa(num1)
    fmt.Printf("类型：%T ，值=%v \n",s1,s1)    //类型：string，值=20

    //2、float 转 string
    var num2 float64 = 20.113123
    /*参数 1:要转换的值
    参数 2：格式化类型
    参数 3：保留的小数点 -1 （不对小数点格式化）
    参数 4：格式化的类型
    */

    s2 := strconv.FormatFloat(num2,'f',2,64)
    fmt.Printf("类型： %T ,值=%v \n", s2, s2)  // 类型： string ,值=20.11

	// 3、bool 转 string
	s3 := strconv.FormatBool(true)
	fmt.Printf("类型： %T ,值=%v \n", s3, s3)  // 类型： string ,值=20.11

	//4、int64 转 string
	var num3 int64 = 20
	s4 := strconv.FormatInt(num3, 10)  /* 第二个参数10为 进制 */
	fmt.Printf("类型 %T ,值=%v \n", s4, s4)  // 类型 string ,值=20
}

五、String 转其他

1、string 转 int

package main

import (
    "fmt"
    "strconv"
)

fun main() {
    var s = "1234"
    i64,_ := strconv.ParseInt(s,10,64)
    fmt.Printf("值：%v 类型：%T",i64,i64)    //值：1234 类型：int64
}

2、string 转 float

package main

import (
    "fmt"
    "strconv"
)    

func main() {
    str := "3.1415926535"
    v1,_ := strconv.ParseFloat(str,32)
    v2,_ := strconv.ParseFloat(str,64)
    fmt.Printf("值：%v 类型：%T\n",v1,v1)    // 值：3.1415927410125732 类型：float64
	fmt.Printf("值：%v 类型：%T", v2, v2)  // 值：3.1415926535 类型：float64
}

3、string 转 bool

package main
import (
	"fmt"
	"strconv"
)
func main() {
	b, _ := strconv.ParseBool("true")   // string 转 bool
	fmt.Printf("值：%v 类型：%T", b, b)  // 值：true 类型：bool
}

4、string 转字符

package main

import "fmt"

func main() {
    s := "hello snail"
    for _,r := range s{ //rune
        //104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 115(s) 110(n) 97(a) 105(i) 108(l) 
        fmt.Printf("%v(%c)",r,r)
    }
    fmt.PrintIn()
}

5、字符串反转

package main

func Reverse(s string) string{
    r := []rune(s)
    for I,j:=0,len(r)-1;i<j;i,j=i+1,j-1 {
        r[I],r[j]=r[j],r[i]
    }
    return string(r)
}

func main(){
    a := "Hello, Wrold"
	println(a)
	println(Reverse(a))  // dlorW ,olleH
}