Go字符串类型

一、字符串

1、字符串
  • Go 语言里的字符串的内部实现使用 UTF-8 编码
  • 字符串带的值为双引号(")中的内容,可以在 Go 语言的源码中直接添加非ASCII 码字符
s1 := "hello"
s2 := "您好"
2、字符串转义符
  • Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等

Go字符串类型_第1张图片

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%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

你可能感兴趣的:(GoLang,golang,开发语言,后端)