go数据类型转换和字符串处理

go数据类型转换和字符串处理

数据类型转换和字节数组

数据类型(表达式)
  • string(abc) :将abc 转换为string类型
  • []byte(abc): 将abc 转换为 字节类型，组成字节数组
  • float32(1):将 1 转换为32位浮点型
package main

import "fmt"

func main() {
	var (
		str1 = "hello"
		str2 = "world"
	)
	result := str1 + " " + str2
	fmt.Printf("数据%s,长度:%d,数据类型:%T\n", result, len(result), result)
	//字符串转换成字节数组
	tmp := []byte(result)
	fmt.Printf("tmp数据%s,长度:%d,数据类型:%T\n", tmp, len(tmp), tmp)

	for i := 0; i < len(tmp); i++ {
		//字节 转字符
		fmt.Println(string(tmp[i]))
		// a := len(tmp) - 1 - i
		// fmt.Println(string(tmp[a]))
	}
	fmt.Println(string(tmp))

	fmt.Println("反转:", Revers(result))
}

//反转函数
func Revers(str string) string {
	var (
		result string
		leng   int = len(str)
	)
	for i := leng - 1; i >= 0; i-- {
		//sprintf转换数据类型为string，使用 + 进行拼接
		result = result + fmt.Sprintf("%c", str[i])
	}
	return result
}

//输出结果:
数据hello world,长度:11,数据类型:string
tmp数据hello world,长度:11,数据类型:[]uint8
h
e
l
l
o
 
w
o
r
l
d
hello world
反转: dlrow olleh

通过修改单个字符元素，将hello world 修改为Hello World

//通过修改单个字符元素，将hello world 修改为Hello World
package main

import (
	"fmt"
)

func main() {
	var str1 string = "hello world"
	//将字符串类型转换为字节数组，并赋值给tmp
	tmp := []byte(str1)

	//tmp值是一个由对应字符组成的ASCll码 数组。
	//将数组第一个值修改为 "H" 对应的ASCll码
	tmp[0] = 72
	fmt.Println("第一次修改后的数据是:", string(tmp))

	//遍历字节数组
	for i := 0; i < len(tmp); i++ {
		//使用string 将字节转为字符。当转变后的字符为小写w时，将其重新赋值为大写W
		if string(tmp[i]) == "w" {
			//注意，这里使用单引号，表示 rune类型
			tmp[i] = 'W'
		}
	}
	fmt.Println("第二次修改后的数据是:", string(tmp))
  
//输出结果:
 
修改后的数据是: Hello world
修改后的数据是: Hello World



fmt.Sprintf(格式化字符串类型,字符串) 
package main

import "fmt"

func main() {
	var num = 10
	fmt.Printf("num的类型是:%T \n", num)
	ref := fmt.Sprintf("%d", num)
	fmt.Printf("num的类型是:%T", ref)

}


//输出结果:
num的类型是:int 
num的类型是:string

注意，go 不支持隐式转换类型

package main

import "fmt"

func main() {
	var a int64 = 10
	var b int32 = 20
	//此时，有与ab的数值类型不同，直接交换会报错
	a = b
	fmt.Printf("b为%d", b)
}

此时执行则报错

cannot use a (type int64) as type int32 in assignment

修改后:

package main

import "fmt"

func main() {
	var a int64 = 10
	var b int32 = 20
  //需要将a转换为int32，再交换
	b = int32(a)
	fmt.Printf("b为%d", b)
}

//输出结果:
b为10

头尾处理

strings.HasPrefix(字符串,关键字)
strings.HasSuffix(字符串,关键字)

判断URL是否以 "http://" 开头。如果不是，则加上"http://"

判断路径是否以 "/" 结尾，如果不是，则加上 "/" 为结尾

package main

import (
	"fmt"
	"strings"
)

func main() {
	var (
		url  string
		path string
	)
	//输入两个值
	fmt.Scanf("%s%s", &url, &path)
	fmt.Println(urlProcess(url))
	fmt.Println(pathProcess(path))
}

//头部判断是否包含 http://  ，如果不包含，则加上http://
func urlProcess(url string) string {
	//返回的resutl 类型是 bool类型
	result := strings.HasPrefix(url, "http://")
	if !result {
		url = fmt.Sprintf("http://%s", url)
	}
	return url
}

//尾部：判断是否包含  /  ,如果不包含，则加上 /
func pathProcess(path string) string {
	//返回的resutl 类型是 bool类型
	result := strings.HasSuffix(path, "/")
	if !result {
		path = fmt.Sprintf("%s/", path)
	}
	return path
}



位置索引

strings.Index(字符串,关键字)
strings.LastIndex(字符串,关键字)
package main

import (
	"fmt"
	"strings"
)

//判断关键字段在字符串中出现的索引位置
func main() {
	var (
		s   string = "abbacddccd"
		str string = "cd"
	)
	start := strings.Index(s, str)
	fmt.Println("关键词首部出现的位置：", start)
	end := strings.LastIndex(s, str)
	fmt.Println("关键词尾部出现的位置：", end)
}

//输出结果:
关键词首部出现的位置： 4
关键词尾部出现的位置： 8


替换

strings.Replace(原始字符串,原字段,新字段,替换次数)
package main

import (
	"fmt"
	"strings"
)

//替换
func main() {
	var (
		s   string = "abbacddccdabcd"
		str string = "cd"
	)
	//替换Replace(原始字符串,原字段,新字段,替换次数),-1(小于0的整数)表示全文替换,0表示不替换
  //从左向右,替换1次
	result1 := strings.Replace(s, str, "CD", 1)
	fmt.Println("替换字符串：", result1)
  //从左向右,替换2次
	result2 := strings.Replace(s, str, "CD", 2)
	fmt.Println("替换字符串：", result2)
  //全文替换
	result3 := strings.Replace(s, str, "CD", -1)
	fmt.Println("替换字符串：", result3)

}


//输出结果:
替换字符串： abbaCDdccdabcd
替换字符串： abbaCDdcCDabcd
替换字符串： abbaCDdcCDabCD


统计次数

strings.Count(字符串,关键字)
package main

import (
	"fmt"
	"strings"
)


func main() {
	var (
		s   string = "abbacddccdabcd"
		str string = "cd"
	)
	//使用count 统计关键字出现的次数
	count := strings.Count(s, str)
	fmt.Println("cd出现的次数", count)
}

//输出结果:
cd出现的次数 3


复制

strings.Repeat(字符串,n次)
package main

import (
	"fmt"
	"strings"
)

//复制
func main() {
	var str string = "abc"
	//复制关键字段3次，相连后，并返回完整字符串
	result := strings.Repeat(str, 3)
	fmt.Println(result)
}


//输出结果:
abcabcabc


大小写

strings.ToUpper(字符串)
strings.ToLower(字符串)
package main

import (
	"fmt"
	"strings"
)

//字符串大小写
func main() {
	var str string = "abc"

	//字符串变大写
	result1 := strings.ToUpper(str)
	fmt.Println("大写:", result1)

	//字符串变小写
	result2 := strings.ToLower(result1)
	fmt.Println("小写:", result2)

}


//输出结果:
大写: ABC
小写: abc


去除字符

strings.Trimspace(字符串)
strings.Trim(字符串,匹配字)
strings.TrimLeft(字符串,关键字)
strings.TrimRight(字符串,关键字)
package main

import (
	"fmt"
	"strings"
)

//去除指定字符
func main() {
	var s string = "  abc "
	var s1 string = "web this is web abc web"
	var s2 string = "this is c abc this isc abc\tweb"
	fmt.Println("原长度", len(s))
	//去除首尾空格
	result1 := strings.TrimSpace(s)
	fmt.Printf("现长度:%d,内容:%s\n", len(result1), result1)

	//去除首尾匹配关键字
	result2 := strings.Trim(s1, "web")
	fmt.Println("Trim处理后的字符串:", result2)

	//TrimLeft()
	//从左匹配关键字符，进行删除，直到没有匹配上的字符为止。即使后面有匹配字符，也不会被删除
	//注意，空格也是字符
	fmt.Println("TrimLeft处理前:", s2)
	result3 := strings.TrimLeft(s2, " thisc")
	fmt.Println("TrimLeft处理后:", result3)

	//TrimRight()
	//从右匹配关键字符，进行删除，直到没有匹配上的字符为止。即使后面有匹配字符，也不会被删除
	//注意空格也是字符.制表符\t和空格不是
	result4 := strings.TrimRight(s2, "\tcweb")
	fmt.Println("TrimRitht处理结果:", result4)
}


//输出结果:
原长度 6
现长度:3,内容:abc
Trim处理后的字符串:  this is web abc 
TrimLeft处理前: this is c abc this isc abc	web
TrimLeft处理后: abc this isc abc	web
TrimRitht处理结果: this is c abc this isc a


切片处理

实例:字符串以空格分隔 转成切片

package main

import (
	"fmt"
	"strings"
)

//字符串切片处理
func main() {
	var str string = "abc def ghi"
	//Fieds函数识别的符号时空格
	result1 := strings.Fields(str)
	fmt.Printf("数据类型是%T,数据格式%v\n", result1, result1)
	for i := 0; i < len(result1); i++ {
		fmt.Println(result1[i])
	}
}


//输出结果:
数据类型是[]string,数据格式[abc def ghi]
abc
def
ghi

以其他字符为分隔符的

package main

import (
	"fmt"
	"strings"
)

func main() {
	//split识别其他特殊符号分隔
	var str string = "abc:def:ghi"
	result1 := strings.Split(str, ":")
	fmt.Printf("数据类型是%T,数据格式%v\n", result1, result1)
	for i := 0; i < len(result1); i++ {
		fmt.Println(result1[i])
	}
}


//输出结果:
数据类型是[]string,数据格式[abc def ghi]
abc
def
ghi


合并字符串。

替换字符串的分隔符

package main

import (
	"fmt"
	"strings"
)

func main() {
	//split识别其他特殊符号分隔
	var str string = "abc def ghi"
	result1 := strings.Split(str, " ")
	fmt.Printf("数据类型是%T,数据格式%v\n", result1, result1)

	//把切片按照指定分隔符，合并车字符串
	str2 := strings.Join(result1, ",")
	fmt.Printf("数据类型是%T,数据格式%v\n", str2, str2)
}


数值处理

strconv.Itoatrconv.Atoi
package main

import (
	"fmt"
	"strconv"
)

func main() {
	var num int = 123456
	var str string = "123"
	fmt.Printf("num的数据类型是:%T\n", num)
	fmt.Printf("str的数据类型是:%T\n", str)
	fmt.Println("-------")
	//数值转为字符
	result1 := strconv.Itoa(num)
	fmt.Printf("result1的数据类型是:%T\n", result1)

	fmt.Println("--------")

	//字符转为数值(字符需要是 1234这种数字类型的字符串)
	//atoi 转换后，会出现两个值，一个是转换后的值，一个是error，用于抛出错误信息。
	//如果转换成功，error 值为空。
	result2, err := strconv.Atoi(str)

	if err == nil {
		fmt.Printf("result2的数据类型是%T", result2)
	} else {
		fmt.Println("转换失败")
	}

}

//
num的数据类型是:int
str的数据类型是:string
-------
result1的数据类型是:string
--------
result2的数据类型是int


fmt.Sprintf(格式化字符串类型,字符串)

格式化字符串：

  • int 类型数据：%d
  • string类型数据： %s
  • float类型数据：%f
  • bool类型数据：%t
  • 指针：%p
package main

import "fmt"

func main() {
	var (
		num1 = 12345
		num2 = 3.1415
		b1   = true
	)
	fmt.Printf("num1是%T类型。\nnum2 是%T类型。\nb1 是%T类型\n", num1, num2, b1)
	fmt.Println("--------")

	result1 := fmt.Sprintf("%d", num1)
	result2 := fmt.Sprintf("%f", num2)
	result3 := fmt.Sprintf("%t", b1)

	fmt.Printf("result1的类型是%T\n result2的类型是%T\n result3的类型是%T", result1, result2, result3)

}


//输出结果:
num1是int类型。
num2 是float64类型。
b1 是bool类型
--------
result1的类型是string
 result2的类型是string
 result3的类型是string

字符串格式化

格 式 描 述
%v 按值的本来值输出
%+v 在 %v 基础上，对结构体字段名和值进行展开
%#v 输出 Go 语言语法格式的值
%t 输出布尔值
%T 输出 Go 语言语法格式的类型和值
%% 输出 % 本体
%s 输出字符串（string和[]byte）值
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以十六进制方式显示
%X 整型以十六进制、字母大写方式显示
%U Unicode 字符
%f 浮点数
%p 指针，十六进制方式显示
%q 格式化字符串，在字符串的两端加上双引号