SRE文档

深浅模式

https://www.cainiaojc.com/golang/go-scope-of-variables.html

1.golang字符串 ​

一个Go语言字符串是一个任意字节的常量序列。[]byte

1.1go语言字符串字面量 ​

Golang 支持两种类型的字符串字面量：

  • 解释型字符串
  • 非解释型字符串

所谓的解释型字符串就是用双引号括起来的字符串("")，其中的转义字符会被替换掉，这些转义字符包括：

\a    // 响铃     
\b    // 退格
\f    // 换页
\n    // 换行
\r    // 回车
\t    // 制表符
\u    // Unicode 字符
\v    // 垂直制表符
\"    // 双引号
\\    // 反斜杠
\a    // 响铃     
\b    // 退格
\f    // 换页
\n    // 换行
\r    // 回车
\t    // 制表符
\u    // Unicode 字符
\v    // 垂直制表符
\"    // 双引号
\\    // 反斜杠

在Go语言中，字符串字面量使用双引号""或者反引号``来创建。

双引号用来可解释的字符串，支持转义，但不能用来引用多行；

反引号用来创建原生的字符串字面量，可能由多行组成，但不支持转义，并且可以包含除了反引号其他所有字符。

双引号创建可解析的字符串应用最广泛，反引号用来创建原生的字符串则多用于书写多行消息，html以及正则表达式。

go
package main

import "fmt"

func main() {
	var s string = "hello world"
    var s1 = "hello word"
    s3 := "hello world"
    
    fmt.Printf("s: %v\n", s)
    fmt.Printf("s1: %v\n", s1)
    fmt.Printf("s3: %v\n", s3)
    
    s4 := `
    	line1 
    	line2 
    	line3
    `
     fmt.Printf("s4: %v\n", s4)
}
package main

import "fmt"

func main() {
	var s string = "hello world"
    var s1 = "hello word"
    s3 := "hello world"
    
    fmt.Printf("s: %v\n", s)
    fmt.Printf("s1: %v\n", s1)
    fmt.Printf("s3: %v\n", s3)
    
    s4 := `
    	line1 
    	line2 
    	line3
    `
     fmt.Printf("s4: %v\n", s4)
}

1.2go语言字符串连接 ​

  • 使用加号

虽然Go语言中的字符串是不可变的，但是字符串支持+级联操作和+=追加操作

go
package main

import "fmt"

func main() {
    name := "tom"
    age := "20"
    msg := name + " " + age
    
    fmt.Printf("msg: %v\n", msg)
    fmt.Printf("------------------")
    
    msg = ""
    msg += name
     msg = ""
    msg += age
    fmt.Printf("msg: %v\n", msg)
}
package main

import "fmt"

func main() {
    name := "tom"
    age := "20"
    msg := name + " " + age
    
    fmt.Printf("msg: %v\n", msg)
    fmt.Printf("------------------")
    
    msg = ""
    msg += name
     msg = ""
    msg += age
    fmt.Printf("msg: %v\n", msg)
}

fmt.Sprintf()函数 ​

go
package main

import "fmt"

func main() {
	name := "tom"
	age := "20"
	
	msg := fmt.Sprintf("%s, %s", name ,age)
	fmt.Printf("msg: %v\n",msg)
}
package main

import "fmt"

func main() {
	name := "tom"
	age := "20"
	
	msg := fmt.Sprintf("%s, %s", name ,age)
	fmt.Printf("msg: %v\n",msg)
}

内部使用[]byte实现，不像直接运算符这种会产生很多临时的字符串，但是内部的逻辑比较复杂，有很多额外的判断，还用到了interface,所以性能也不是很好

string.Join() ​

go
package main

import (
	"fmt"
    "strings"
)

func main() {
    name := "tom"
    age := "20"
    msg := strings.Join([]string{name, age},",")
    fmt.Printf("msg: %v\n", msg)
}
package main

import (
	"fmt"
    "strings"
)

func main() {
    name := "tom"
    age := "20"
    msg := strings.Join([]string{name, age},",")
    fmt.Printf("msg: %v\n", msg)
}

join会先根据字符串数组的内容，计算出一个拼接之后的长度，然后申请对应大小的内存，一个一个字符串填入，在已有一个数组的情况下，这种效率会很高，但是本来没有，去构造这个数据的代价也不小

buffer.WriteString()

go
package main

import (
	"fmt"
    "bytes"
)

func main(){
    var buffer bytes.Buffer
    buffer.WriteString("tom")
    buffer.WriteString(",")
    buffer.WriteString("20")
    
    fmt.Printf("buffer.String(): %v\n", buffer.String())
}
package main

import (
	"fmt"
    "bytes"
)

func main(){
    var buffer bytes.Buffer
    buffer.WriteString("tom")
    buffer.WriteString(",")
    buffer.WriteString("20")
    
    fmt.Printf("buffer.String(): %v\n", buffer.String())
}

这个比较理想，可以当成可变字符串使用，对内存的增长也有优化，如果能预估字符串长度，还可以用buffer.Grow()接口来设置capacity

1.3go语言字符串转义字符 ​

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

转义说明
\r回车符（返回行首）
\n换行符（直接跳到下一行的同列位置）
\t制表符
'单引号
"双引号
\\反斜杠
  • 实例
go
package main

import(
	"fmt"
)

func main(){
    fmt.Print("hello \t world")
}
package main

import(
	"fmt"
)

func main(){
    fmt.Print("hello \t world")
}

1.4go语言字符串切片操作 ​

go
package main

import (
	"fmt"
)

func main(){
    str := "hello world"
    n := 3
    m := 5
    fmt.Printf(str[n])    //获取字符串索引位置为n的原始字节
    fmt.Printf(str[n:m])  //截取的字符串索引位置 n 到 m-1的字符串
    fmt.Printf(str[n:])   // 截取字符串索引位置为n 到 len(s)-1的字符串
    fmt.Printf(str[:m])   // 截取的字符串索引位置0 到m-1的字符串
}
package main

import (
	"fmt"
)

func main(){
    str := "hello world"
    n := 3
    m := 5
    fmt.Printf(str[n])    //获取字符串索引位置为n的原始字节
    fmt.Printf(str[n:m])  //截取的字符串索引位置 n 到 m-1的字符串
    fmt.Printf(str[n:])   // 截取字符串索引位置为n 到 len(s)-1的字符串
    fmt.Printf(str[:m])   // 截取的字符串索引位置0 到m-1的字符串
}

1.5go语言字符串常用方法 ​

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

import (
	"fmt"
    "strings"
)
func main(){
    s := "hello world"
    
    fmt.Printf("len(s): %v\n", len(s))
    fmt.Printf("strings.Split(s, \"\"): %v\n", strings.Split(s, " "))
    fmt.Printf("strings.Contains(s, \"hello\"): %v\n", strings.Contains(s, "hello"))
    fmt.Printf("strings.HasPrefix(s, \"hello\"): %v\n", strings.HasPrefix(s, "hello"))
    fmt.Printf("strings.HasSuffix(s,\"word! \"): %v\n", strings.HasSuffix(s, "world! "))
    fmt.Printf("strings.Index(s,\"1\"): %v\n",strings.Index(s, "1"))
    fmt.Printf("strings.LastIndex(s,\"1\"): %v\n",strings.LastIndex(s,"1"))
}
package main

import (
	"fmt"
    "strings"
)
func main(){
    s := "hello world"
    
    fmt.Printf("len(s): %v\n", len(s))
    fmt.Printf("strings.Split(s, \"\"): %v\n", strings.Split(s, " "))
    fmt.Printf("strings.Contains(s, \"hello\"): %v\n", strings.Contains(s, "hello"))
    fmt.Printf("strings.HasPrefix(s, \"hello\"): %v\n", strings.HasPrefix(s, "hello"))
    fmt.Printf("strings.HasSuffix(s,\"word! \"): %v\n", strings.HasSuffix(s, "world! "))
    fmt.Printf("strings.Index(s,\"1\"): %v\n",strings.Index(s, "1"))
    fmt.Printf("strings.LastIndex(s,\"1\"): %v\n",strings.LastIndex(s,"1"))
}