Golang中操作字符串

golang中使用strings包完成对字符串的主要操作。

判断前缀/后缀

strings.HasPrefix(s, prefix string) bool	//判断字符串s是否以字符串prefix作为开头，返回值为bool
strings.HasSuffix(s, suffix string) bool	//判断字符串s是否以字符串suffix作为结尾，返回值为bool

//模拟实现
package MyStrings

//判断s字符串是否以prefix作为开头
func MyHasPrefix(s, prefix string) bool {
	if len(s) <= 0 || len(prefix) <= 0 {
		panic("str null")
	}

	if len(prefix) > len(s) {
		return false
	}

	for k, _ := range prefix {
		if s[k] != prefix[k] {
			return false
		}
	}
	return true
}

//模拟实现
package MyStrings


//go反转字符串
func reverse(s string)string {
	if len(s) <= 0 {
		panic("str null")
	}

	runes := []rune(s)
	for begin, end := 0, len(s) - 1; begin < end ;begin, end = begin + 1, end - 1 {
		runes[begin], runes[end] = runes[end], runes[begin]
	}
	return string(runes)
}

//同一个包中的public函数可以互相调用，不需要加上包名，也不需要import当前包
func MyHasSuffix(s, suffix string) bool {
	if len(s) <= 0 || len(suffix) <= 0 {
		panic("str null")
	}

	var restr string = reverse(s)
	var resuffix string = reverse(suffix)
	return MyHasPrefix(restr, resuffix)
}

判断子字符串

strings.Contains(s, substr string) bool	//判断substr是否为s的子字符串

//模拟实现
package MyStrings

//判断字符串的包含关系，判断substr
func MyContains(s, substr string)bool {
	if len(s) <= 0 || len(substr) <= 0 {
		panic("str null")
	}

	if i:= MyIndex(s, substr); i == -1 {
		return false
	}
	return true
}

判断子字符串或字符在父字符串中出现的位置

strings.Index(s, str string) int	//返回str在s中第一次出现的位置，若找到，返回值为开始位置的下标；若未找到，返回值为-1
strings.LastIndex(s, str string) int	//返回str在s中最后一次出现的位置
strings.IndexRune(s string, r rune) int	//TODO

//模拟实现
package MyStrings

//返回str中第一个匹配s的首字符的位置
func MyIndex(s, str string) int {
	//s&str都不能为空
	if len(s) <= 0 || len(str) <= 0 {
		panic("str null")
	}

	var startpos int	//在s字符串中起始的比较位置
	var compos int	//s字符串中，开始与str比较的位置
	var strpos int	//表示str对应位置
	for startpos = 0;startpos < len(s);startpos++ {
		if s[startpos] == str[0] {	//找到第一个匹配字符，保存该位置，开始向后比较
			compos = startpos
			strpos = 0

			//开始比较s&str
			for ;strpos < len(str); compos, strpos = compos + 1, strpos + 1 {
				if compos >= len(s) {	//判断compos是否越界，越界说明无匹配字符串
					return -1
				}
				if s[compos] != str[strpos] {
					break
				}
			}

			if strpos == len(str)  {	//匹配字符串完成
				return startpos
			}
		}
	}
	return -1
}

//模拟实现
package MyStrings

func MyLastIndex(s, str string)int {
	if len(s) <= 0 || len(str) <= 0 {
		panic("str null")
	}

	var res string = reverse(s)
	var restr string = reverse(str)
	var pos int = MyIndex(res, restr)
	return len(s) - pos - 1
}

字符串替换

strings.Replace(str, old, new string, n int) string	//将str中前n个字符中的old替换为new，并返回一个新的字符串，如果n = -1则替换所有字符串old为字符串new

//模拟实现
package MyStrings

func index(s, str string, n int) int {	//从s的n位置开始，匹配字符串，返回字符串位置
	runes := []rune(s)	//将字符串转换成rune类型的切片
	runes = runes[n:]	//将切片从n的位置进行切片
	return MyIndex(string(runes), str)
}

//将字符串中前n个字符中匹配old的字符串替换为new字符串，并返回一个新字符串
func MyReplace(str, old, new string, n int) string {
	if str == "" || old == "" {
		panic("str || old null")
	}

	if n == -1 {
		n = len(str)
	}

	var newstr string	//保存返回的字符串
	var nowpos int	//标记实时位置
	var modpos int	//标记修改位置
	var poscount int
	runes := []rune(str)	//将原来的字符串进行切片
	for nowpos = 0; nowpos < n; nowpos = modpos + len(old) {
		poscount = modpos
		modpos = index(str, old, nowpos)
		if modpos == -1 {	//未匹配到old字符串
			var tmpstr string = string(runes[nowpos:])
			newstr = newstr + tmpstr
			return newstr
		}

		modpos = modpos + nowpos

		var tmpstr string = string(runes[nowpos:modpos])
		newstr = newstr + tmpstr	//将修改位置的前一部分添加进newstr
		newstr = newstr + new	//将new添加进newstr
		poscount = modpos - poscount
	}
	return newstr
}

重复字符串

strings.Repeat(s string, count int) string	//重复count次字符串s并返回一个新字符串

package MyStrings

//将string字符串重复count次并组织成一个新的字符串返回
func MyRepeat(s string, count int) string {
	var newstr string
	for i := 0; i < count; i++ {
		newstr = newstr + s
	}

	return newstr
}

修改大小写

strings.ToLower(s) string	//将字符串s转换为小写
string.ToUpper(s) string	//将字符串s转换为大写

修剪字符串

分割字符串

strings.Fields(s)	//按空格将字符串分割，返回值为一个slice
strings.Split(s, sep)	//按sep将字符串分割，返回一个slice

拼接slice到字符串

strings.Join(s1 []string, sep string) string	//将元素类型为string的slice使用sep作为分隔符拼接成一个字符串

从字符串中读取内容

strings.NewReader(str)	//生成一个Reader并读取字符串内容，返回值为指向该Reader的指针

---

字符串相关类型转换

字符串与相关类型的转换都是通过strconv包实现的

strconv.IntSize() int	//获取程序运行平台下int所占的位数

数字转字符串

strconv.Itoa(i int) string	//返回数字i对应的字符串表示

字符串转数字

strconv.Atoi(s string) (i int, err error)	//将字符串转换为int类型

字符串转float64型数字

strconv.ParseFloat(s string, bitSize int) (f float64, err error)	//将字符串转换为float64型

float64型数字转字符串

strconv.FormatFloat(f float64, fmt byte, prec int, bitSize int) string
//fmt的取值为'b','e','f','g'
//prec表示精度
//bitSize使用32则表示float32,用64表示float64