基本数据类型
int
- 取值范围
- int8: -(28-1-1) ~ 28-1-1
- int16: -(215-1) ~ 215-1
- int32: -(231-1) ~ 231 -1
- int64: -(263-1) ~ 263 -1
- 示例
package main
import (
"fmt"
"unsafe"
)
func main() {
var a int8
var b int64
fmt.Println(unsafe.Sizeof(a))
fmt.Println(unsafe.Sizeof(b))
c10 := 16
c8 := 020
c16 := 0x10
fmt.Printf("%b, %[1]d, %[1]o, %[1]x\n", c10)
fmt.Printf("%b, %[1]d, %[1]o, %[1]x\n", c8)
fmt.Printf("%b, %[1]d, %[1]o, %[1]x\n", c16)
}
float
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
}
bool
- true 和 false, 默认为false
- 不允许强制转换
- 无法参与运算
- 无法与其他类型转换
string
常用方法
中文文档
描述 | 方法 |
---|
求字符串长度 | len(str) |
拼接字符串 | + 或 fmt.Sprintf("%s, %s", strA, strB) 或 strings.Join(Slice, sep) |
切片转字符串 | strings.Join(Slice, sep) |
切割字符串 | strings.Split(str, sep) |
判断是否包含 | strings.contains(str, sep) |
判断前后缀 | strings.HasPrefix(str, sep); strings.HasSuffix(str, sep) |
求子串出现位置 | strings.Index(str, sep); strings.LastIndex(str, sep) |
示例
package main
import (
"fmt"
"strings"
)
func main() {
s1 := `
a
`
fmt.Println(s1)
s2 := "abc"
fmt.Println(len(s2))
m := "a"
n := "b"
i := m + n
j := fmt.Sprintf("%s - %s", m, n)
fmt.Println(i, j)
s3 := "a b c d"
ret := strings.Split(s3, " ")
fmt.Println(ret)
s4 := "abc"
r1 := strings.Contains(s4, "b")
r2 := strings.HasPrefix(s4, "a")
r3 := strings.HasSuffix(s4, "a")
fmt.Println(r1, r2, r3)
s5 := "abac"
x := strings.Index(s5, "a")
y := strings.LastIndex(s5, "a")
fmt.Println(x, y)
}
byte和 rune 类型
package main
import (
"fmt"
)
func main() {
s1 := "golang"
c1 := 'g'
s2 := "中国"
c2 := '中'
fmt.Println(s1, c1)
fmt.Println(s2, c2)
s3 := "hello 中国"
for i := 0; i < len(s3); i++ {
fmt.Printf("%[1]v: %[2]v(%[2]c)\n", i, s3[i])
}
for k, v := range s3 {
fmt.Printf("%v: %c\n", k, v)
}
}
转换示例
str --> []byte/[]rune
package main
import (
"fmt"
)
func main() {
s := "hello world"
b := []byte(s)
fmt.Println(b)
b1 := []byte{104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100}
s1 := string(b1)
fmt.Println(s1)
}
str --> int
package main
import (
"fmt"
"strconv"
)
func main() {
s := "123"
n, _ := strconv.Atoi(s)
fmt.Println(n)
n1, _ := strconv.ParseInt(s, 10, 64)
fmt.Printf("%T, %[1]v", n1)
s1 := strconv.Itoa(n)
fmt.Println(s1)
var n2 int64
n2 = 299
s2 := strconv.FormatInt(n2, 10)
fmt.Println(s2)
}
str --> []string
package main
import (
"fmt"
"strings"
)
func main() {
sliceA := []string{"a", "b", "c"}
r := strings.Join(sliceA, "-")
fmt.Println(r)
sliceB := strings.Split(r, "-")
fmt.Println(sliceB)
}
取模及范围限定
if !(-(1<<31) <= r && r <= (1<<31)-1) {
return 0
}
r %= (1e9 + 7)
r %= 1000000007
练习
修改字符串
package main
import "fmt"
func changeAlph() {
s := "aaa"
b := []byte(s)
b[1] = 'b'
fmt.Println(string(b))
}
func changeChar() {
s := "beijing北京"
b := []rune(s)
b[7] = 21335
fmt.Println(string(b))
}
func main() {
changeAlph()
changeChar()
}
字符串反序
package main
import "fmt"
func main() {
s3 := "abcde"
r1 := ""
for i := len(s3) - 1; i >= 0; i-- {
r1 += string(s3[i])
}
fmt.Println(r1)
bArr := []byte(s3)
for i := 0; i < len(s3)/2; i++ {
bArr[i], bArr[len(s3)-1-i] = bArr[len(s3)-1-i], bArr[i]
}
r2 := string(bArr)
fmt.Println(r2)
}