go資料型別轉換和字串處理

• 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
 

使用 fmt.Sprintf(格式化字串型別,字串) 將任何資料轉換為string 型別

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(字串,關鍵字) 判斷字串是否以關鍵字為開頭。 返回值為 bool型別

strings.HasSuffix(字串,關鍵字)判斷字串是否以關鍵字為結尾。返回值為bool型別

判斷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, "http://")
	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(原始字串,原欄位,新欄位,替換次數) 替換次數小於0，如-1 ，則表示全文所有匹配都替換

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次)將字串連續複製n次

package main

import (
	"fmt"
	"strings"
)

//複製
func main() {
	var str string = "abc"
	//複製關鍵欄位3次，相連後，並返回完整字串
	result := strings.Repeat(str, 3)
	fmt.Println(result)
}


//輸出結果:
abcabcabc

大小寫

strings.ToLower(字串) 將字串字母大寫

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.Itoa數值轉化為字串,使用trconv.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

字串格式化