golang 字符串 04

最新推荐文章于 2024-07-02 15:38:44 发布

RunMonster

最新推荐文章于 2024-07-02 15:38:44 发布

阅读量192

点赞数

CC 4.0 BY-SA版权

分类专栏： golang基础文章标签： go

本文链接：https://blog.csdn.net/qq_35418518/article/details/108677477

golang基础专栏收录该内容

27 篇文章

订阅专栏

本文介绍了Go语言中字符串的简单使用，包括类型转换，详细讲解了如何将其他类型转化为字符串以及从字符串转回其他类型。此外，还探讨了JSON操作，特别是提到的Go语言中实现JSON编码的高效方法。

package base

import "fmt"

/*
字符(两种类型)
byte	uint8	ascii的一个字符
rune	unicode	int32	utf-8
*/
func RunByte() {
	var charBaue1 byte = 'a'
	charBaue2 := '侯'
	fmt.Printf("charBaue1 = %d ~ 类型 = %T, charBaue2 = %d 类型 = %T", charBaue1, charBaue1, charBaue2, charBaue2)
}

/*
字符串
就是字符的数组
*/
func RunString() {
	stringValue := "hello" + "拼少少！"
	//len可获取数组或map的长度
	for index := 0; index < len(stringValue); index++ {
		//这里byte，中文会显示乱码
		fmt.Printf("stringValue 的编码值 = %d, 值 = %c, 类型 = %T \n", stringValue[index], stringValue[index], stringValue[index])
	}

	for _, value := range stringValue {
		//这里rune，中文会正常显示
		fmt.Printf("stringValue 的编码值 = %d, 值 = %c, 类型 = %T \n", value, value, value)
	}
}

1.简单使用

package base016

import (
	"fmt"
	"strconv"
	"strings"
)

func ChangeType(){
	a := 5.0
	// 转换为int类型
	b := int(a)
	//int 转换成string
	str := strconv.Itoa(b) + "666"
	//bool 转换成string
	str1 := strconv.FormatBool(false)
	//字符串转换成 int
	ints, _ := strconv.Atoi("666")

	fmt.Println(b,str,str1,ints)
}

func BaseInfo()  {
	fmt.Println("BaseInfo")

	var str = "  hello nIO null exception "
	var str2 = "sda sda--das dsa//aqq qq//www--ee--111"

	//判断以指定字符开头
	top := strings.HasPrefix(str, "hello")
	//判断以字符结尾
	end := strings.HasSuffix(str, "hello")
	//字符首次出现位置(没有返回-1)
	firstIndex := strings.Index(str, "n")
	//字符最后出现位置(没有返回-1)
	lastIndex := strings.LastIndex(str, "n")
	//字符串替换 -1代表多少位置后替换（全替换）
	newStr := strings.Replace(str,"n","--",-1)

	//转为小写
	lower := strings.ToLower(str)
	//转为大写
	upper := strings.ToUpper(str)

	//在字符串中出现多少次
	repeatCount := strings.Count(str, "n")
	//字符串 重复n次显示
	repeatStr := strings.Repeat(str, 2)

	//去除首尾空白
	space := strings.TrimSpace(str)
	//去除首尾指定字符
	trim1 := strings.Trim(str, "  hello")
	trim2 := strings.TrimLeft(str, "  hello")
	trim3 := strings.TrimRight(str, "  hello")

	//截取 转换成数组
	array1 := strings.Split(str2,"--")

	//连接字符串
	join := strings.Join(array1, "￥￥")

	fmt.Println(top,end,firstIndex,lastIndex)
	fmt.Println(newStr,lower,upper)
	fmt.Println(repeatCount,repeatStr)
	fmt.Println(space,trim1,trim2,trim3)
	fmt.Println(array1)
	fmt.Println(join)
}

2.类型转换

其他类型转换为字符串

/*
其他类型转换为字符串
AppendInt
AppendUint
AppendFloat
AppendBool
*/
func format()  {
	b := []byte("bool:")
	b = strconv.AppendBool(b, true)
	fmt.Println(string(b))

	b32 := []byte("float32:")
	b32 = strconv.AppendFloat(b32, 3.1415926535, 'E', -1, 32)
	fmt.Println(string(b32))

	b10 := []byte("int (base 10):")
	b10 = strconv.AppendInt(b10, -42, 10)
	fmt.Println(string(b10))

	b16 := []byte("uint (base 16):")
	b16 = strconv.AppendUint(b16, 42, 16)
	fmt.Println(string(b16))

	//bool转string
	strBool := strconv.FormatBool(false)
	/*
	浮点数转string
	func FormatFloat(f float64, fmt byte, prec, bitSize int) string
	f：要转换的浮点数
	fmt：格式标记（b、e、E、f、g、G）
	prec：精度（数字部分的长度，不包括指数部分）
	bitSize：指定浮点类型（32:float32、64:float64），结果会据此进行舍入。

	格式标记：
	‘b’ (-ddddp±ddd，二进制指数)
	‘e’ (-d.dddde±dd，十进制指数)
	‘E’ (-d.ddddE±dd，十进制指数)
	‘f’ (-ddd.dddd，没有指数)
	‘g’ (‘e’:大指数，’f’:其它情况)
	‘G’ (‘E’:大指数，’f’:其它情况)

	如果格式标记为 ‘e’，’E’和’f’，则 prec 表示小数点后的数字位数
	如果格式标记为 ‘g’，’G’，则 prec 表示总的数字位数（整数部分+小数部分
	*/
	strFloat := strconv.FormatFloat(3.1415926535,'f',3,32)

	//base 表示转换进制，取值在 2 到 36 之间
	strInt := strconv.FormatInt(66,2)
	strInt2 := strconv.FormatUint(66,16)

	fmt.Println(strBool,strFloat,strInt,strInt2)

	//FormatInt(i, 10) 的简写
	strInt3 := strconv.Itoa(66)
	//ParseInt(s, 10, 0) 的简写）
	toInt3 , _:= strconv.Atoi("66")
	fmt.Println(strInt3, toInt3)
}

字符串转换为其他类型

/*
字符串转换为其他类型
*/
func parse()  {
	/*
	布尔值
	它接受真值：1, t, T, TRUE, true, True
	它接受假值：0, f, F, FALSE, false, False
	*/
	toBool, err := strconv.ParseBool("false")
	toBool2, _ := strconv.ParseBool("F")
	fmt.Println(toBool, err, toBool2)

	//浮点数,分32和64两种 （会丢失精度）
	toFloat1, _ := strconv.ParseFloat("1234.56", 32)
	toFloat2, _ := strconv.ParseFloat("12345.67891", 64)
	fmt.Println(toFloat1, toFloat2)

	/*
	正数
	ParseInt 支持正负号，ParseUint 不支持正负号
	base 表示进位制（2 到 36）(base 为 0，则根据字符串前缀判断)
	bitSize 表示结果的位宽（包括符号位），0 表示最大位宽。
	*/
	toInt1, _ := strconv.ParseInt("123456", 10,0)
	toInt2, _ := strconv.ParseUint("123456", 10,0)
	fmt.Println(toInt1, toInt2)
}

3.json

func run(){
	person := Person { "tom", 12 }

	//json 序列化
	b, err := json.Marshal(person)
	if err != nil {
		fmt.Println("error:", err.Error())
	} else {
		data := string(b)
		fmt.Println("value:", data)
	}

	per := new(Person)
	errs := json.Unmarshal(b,&per) //反序列化
	if errs == nil {
		fmt.Println("value:", per)
	}


	//map 序列化
	mapa := map[int]string{1: "world"}
	b2, _ := json.Marshal(mapa)
	fmt.Println("mapa:", string(b2))

	per2 := map[int]string{}
	json.Unmarshal(b2,&per2) //反序列化
	fmt.Println("mapa:", per2)
}

4.据说go里最快的json化方式

package main

import (
	"fmt"
	"github.com/json-iterator/go"
)

func main() {
	type ColorGroup struct {
		ID     int
		Name   string
		Colors []string
	}
	group := ColorGroup{
		ID:     1,
		Name:   "Reds",
		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
	}

	//json序列化
	var json = jsoniter.ConfigCompatibleWithStandardLibrary
	b, err := json.Marshal(group)
	if err != nil {
		fmt.Println("error:", err)
	}

	fmt.Println("json序列化:", string(b))

	//json反序列化
	group2 := new(ColorGroup)
	json.Unmarshal(b, &group2)
	fmt.Println("json反序列化:", group2)
}