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以及正则表达式。

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语言中的字符串是不可变的，但是字符串支持+级联操作和+=追加操作

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()函数

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()

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()

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	制表符
'	单引号
"	双引号
\\	反斜杠

• 实例

package main

import(
	"fmt"
)

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

package main

import(
	"fmt"
)

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

1.4go语言字符串切片操作

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操作

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"))
}

1.6 字符和字符串的区别

package main

import "fmt"

func main() {
	var ch byte
	var str string

	//字符
	// 1，字符用单引号表示。
	// 2，字符，往往都只有一个字符，转义字符除外'\n'
	ch = 'a'
	fmt.Println("ch =", ch)

	// 字符串
	// 1，字符串用双引号表示。
	// 2，字符串有一个或多个字符组成
	// 3，字符串都隐藏了一个结束符，'\0'，表示空字符
	str = "a"
	fmt.Println("str =", str)

	//如果只想操作某个字符，可用如下方式，0表示第一个
	str = "hello go"
	fmt.Printf("str[0] = %c, str[1] = %c", str[0], str[1])
}

package main

import "fmt"

func main() {
	var ch byte
	var str string

	//字符
	// 1，字符用单引号表示。
	// 2，字符，往往都只有一个字符，转义字符除外'\n'
	ch = 'a'
	fmt.Println("ch =", ch)

	// 字符串
	// 1，字符串用双引号表示。
	// 2，字符串有一个或多个字符组成
	// 3，字符串都隐藏了一个结束符，'\0'，表示空字符
	str = "a"
	fmt.Println("str =", str)

	//如果只想操作某个字符，可用如下方式，0表示第一个
	str = "hello go"
	fmt.Printf("str[0] = %c, str[1] = %c", str[0], str[1])
}

2. 字符串常用

strings

2.1 trim

字符串修剪

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 反引号和
	// 字符串处理
	// 1.字符串修剪
	s1 := "  hello world ,"
	fmt.Println("去掉逗号:", strings.Trim(s1, ","))

	// 2.字符串分割
	s2 := "hello,world,go"
	fmt.Println("分割字符串:", strings.Split(s2, ","))

	// 3.字符串连接

	// 4.字符串替换
	s4 := "jenkins"
	fmt.Println("字符串替换:", strings.Replace(s4, "j", "J", 1))
	// 5.字符串查找
	s5 := "jenkins"
	fmt.Println("字符串查找:", strings.Contains(s5, "jen"))
	// 6.字符串统计
	s6 := "jenkins"
	fmt.Println("字符统计:", strings.Count(s6, "j"))
	// 7.字符串截取
	s7 := "jenkins"
	fmt.Println("字符串截取:", s7[2:4])
	// 8.字符串转换
	// 小写变大写
	s8 := "jenkins"
	fmt.Println("字符串转换:", strings.ToUpper(s8))
	// 大写变小写
	s99 := "JENKINS"
	fmt.Println("字符串转换:", strings.ToLower(s99))
	// 9.字符串比较
	s9 := "jenkins"
	s10 := "jenkins"
	fmt.Println("字符串比较:", s9 == s10)
	// 10.字符串格式化
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 反引号和
	// 字符串处理
	// 1.字符串修剪
	s1 := "  hello world ,"
	fmt.Println("去掉逗号:", strings.Trim(s1, ","))

	// 2.字符串分割
	s2 := "hello,world,go"
	fmt.Println("分割字符串:", strings.Split(s2, ","))

	// 3.字符串连接

	// 4.字符串替换
	s4 := "jenkins"
	fmt.Println("字符串替换:", strings.Replace(s4, "j", "J", 1))
	// 5.字符串查找
	s5 := "jenkins"
	fmt.Println("字符串查找:", strings.Contains(s5, "jen"))
	// 6.字符串统计
	s6 := "jenkins"
	fmt.Println("字符统计:", strings.Count(s6, "j"))
	// 7.字符串截取
	s7 := "jenkins"
	fmt.Println("字符串截取:", s7[2:4])
	// 8.字符串转换
	// 小写变大写
	s8 := "jenkins"
	fmt.Println("字符串转换:", strings.ToUpper(s8))
	// 大写变小写
	s99 := "JENKINS"
	fmt.Println("字符串转换:", strings.ToLower(s99))
	// 9.字符串比较
	s9 := "jenkins"
	s10 := "jenkins"
	fmt.Println("字符串比较:", s9 == s10)
	// 10.字符串格式化
}