本篇博客涉及到go 的基础数据类型、 go 语言中的运算符、转义字符、格式化输出、字符串操作
go 语言中的运算符
在 go 语言中,基本数据类型主要包括以下几类:整数类型、浮点数类型、复数类型、布尔类型、字符串类型、字节类型(byte)、符文类型(rune)。
1.整数类型
- int: 有符号整数,其大小在不同平台上可能有所不同(通常是32位或64位)。
- int8、int16、int32、int64:有符号整数类型、分别占用8位、16位、32位和64位。
- uint: 无符号整数、其大小在不同平台上可能有所不同(通常是32或64位)。
- uint8、uint16、uint32、uint64:无符号整数类型、分别占用8位、16位、32位和64位。
- uintptr:无符号整数类型、用于存放指针。
package main
import "fmt"
func main() {
var a int = 34
var b int8 = 98
var c uint 16 = 65535
var d uintptr = 0x12345678
fmt.Println("int", a)
fmt.Println("int8", b)
fmt.Println("uint16", c)
fmt.Println("uintptr", d)
}
【注】有符号类型和无符号类型的区别
- 有符号整数:
有符号整数可以表示正数、负数和零、最高位(最左边一位)用作符号位:0 表示正数, 1 表示负数。 - 无符号整数
无符号整数只能表示非负数(正数和零)。所有位都用于表示值,没有符号位。
2.浮点数类型
- float32:32位浮点数类型。
- float64:64位浮点数类型。
package main
import "fmt"
func main() {
var e float32 = 3.14
var f float64 = 2.5346546
fmt.Println("float32: ", e)
fmt.Println("float64: ", f)
}
3.复数类型
- complex64: 由两个float32组成的复数类型
- complex128: 由两个float64组成的复数类型
package main
import "fmt"
func main() {
var g complex64 = i + 2i
var g complex64 = 3.5 + 2.5i
fmt.Println("complex64:", g)
fmt.Println("complex128:", h)
}
4.布尔类型
- bool: 布尔类型只能取 'true’或 ‘false’.
package main
import "fmt"
func main() {
var i bool = true
var j bool = false
fmt.Println("bool true:", i)
fmt.Println("bool false:", j)
}
5.字符串类型
- string: 字符串类型,表示一串UTF-8编码的字符。
package main
import "fmt"
func main() {
var i bool = true
var j bool = false
fmt.Println("bool true:", i)
fmt.Println("bool false:", j)
}
6.字节类型
- byte: ‘uint8’ 的别名,通常表示一个字节的数据
package main
import "fmt"
func main() {
var l byte = 'A'
fmt.Println("byte:", l)
}
7.符文类型
- rune: ‘int32’ 的别名,通常用于表示一个Unicode码点。
package main
import "fmt"
func main() {
var m rune = '你'
fmt.Println("rune:", m)
}
go 语言中的运算符
在 go 语言中,运算符用于执行各种操作,如算术运算、比较、逻辑运算和位运算。
1.算数运算符
- +:加法
- -:减法
- *:乘法
- /:除法
- %:取余
package main
import "fmt"
func main() {
a := 10
b := 3
fmt.Println("加法:", a + b) // 13
fmt.Println("减法:", a - b) // 7
fmt.Println("乘法:", a * b) // 30
fmt.Println("除法:", a / b) // 3
fmt.Println("取余:", a % b) // 1
}
2.关系运算符
- ==:等于
- !=:不等于
- <:小于
-
:大于
- <=:小于等于
-
=:大于等于
package main
import "fmt"
func main() {
a := 10
b := 20
fmt.Println("等于:", a == b) // false
fmt.Println("不等于:", a != b) // true
fmt.Println("小于:", a < b) // true
fmt.Println("大于:", a > b) // false
fmt.Println("小于等于:", a <= b) // true
fmt.Println("大于等于:", a >= b) // false
}
3.逻辑运算符
- &&:逻辑与(AND)
- ||:逻辑或(OR)
- !:逻辑非(NOT)
package main
import "fmt"
func main() {
a := true
b := false
fmt.Println("逻辑与:", a && b) // false
fmt.Println("逻辑或:", a || b) // true
fmt.Println("逻辑非:", !a) // false
}
4.位运算符
- &:按位与(AND)
- |:按位或(OR)
- ^:按位异或(XOR)
- &^:按位清零(AND NOT)
- <<:左移
- >>: 右移
package main
import "fmt"
func main() {
a := 10 // 1010
b := 3 // 0011
fmt.Println("按位与:", a & b) // 0010 -> 2
fmt.Println("按位或:", a | b) // 1011 -> 11
fmt.Println("按位异或:", a ^ b) // 1001 -> 9
fmt.Println("按位清零:", a &^ b) // 0100 -> 8
c := 1 // 0001
fmt.Println("左移:", c << 2) // 0100 -> 4
fmt.Println("右移:", a >> 2) // 0010 -> 2
}
5.赋值运算符
- =:赋值
- +=:加后赋值
- -=:减后赋值
- *=:乘后赋值
- /=:除后赋值
- %=:取余后赋值
- &=:按位与后赋值
- |=:按位或后赋值
- ^=:按位异或后赋值
- <<=:左移后赋值
- />>=:右移后赋值
package main
import "fmt"
func main() {
a := 5
a += 3
fmt.Println("加后赋值:", a) // 8
a -= 2
fmt.Println("减后赋值:", a) // 6
a *= 2
fmt.Println("乘后赋值:", a) // 12
a /= 3
fmt.Println("除后赋值:", a) // 4
a %= 3
fmt.Println("取余后赋值:", a) // 1
}
6.其它运算符
- ++:自增
- –:自减
package main
import "fmt"
func main() {
a := 5
a++
fmt.Println("自增:", a) // 6
a--
fmt.Println("自减:", a) // 5
}
转义字符
go 语言中,常见的转义字符包括换行符、制表符、引号和反斜杠等。
1.常见转义字符
- \a:响铃(警报)
- \b:退格
- \f:换页
- \n:换行
- \r:回车
- \t:水平制表符
- \v:垂直制表符
- \:反斜杠
- ":双引号
- ':单引号
package main
import "fmt"
func main() {
// 响铃(警报)
fmt.Println("响铃(警报):\a")
// 退格
fmt.Println("退格:Hello\bWorld") // 输出 "HellWorld"
// 换页
fmt.Println("换页:Hello\fWorld") // 换页符常见于打印机控制
// 换行
fmt.Println("换行:Hello\nWorld")
// 回车
fmt.Println("回车:Hello\rWorld") // 输出 "World"
// 水平制表符
fmt.Println("水平制表符:Hello\tWorld")
// 垂直制表符
fmt.Println("垂直制表符:Hello\vWorld")
// 反斜杠
fmt.Println("反斜杠:Hello\\World")
// 双引号
fmt.Println("双引号:Hello\"World\"")
// 单引号
fmt.Println("单引号:Hello\'World\'")
}
2.字符串字面值中的转义字符
在字符串字面值中,转义字符用于表示那些在正常情况下无法直接输入的字符。例如:
package main
import "fmt"
func main() {
var str string = "这是一个包含换行符的字符串:\n你好,世界!"
fmt.Println(str)
}
3.使用反引号
在 go 语言中,可以使用反引号(···)创建原始字符串字面值,这种字符串字面值不支持转义字符,所有的字符都按原样处理。这对包含大量特殊字符或多行文本的字符串非常有用。例如:
package main
import "fmt"
func main() {
var rawString string = `这是一个原始字符串字面值,
它可以包含多行文本,
以及各种特殊字符,例如 \n、\t 等,都会被按原样处理。`
fmt.Println(rawString)
}
格式化输出
go 语言中提供了一些强大的内置函数,用于格式化输出。这些函数主要包括 fmt.Print
、fmt.Println
、fmt.Printf
和fmt.Sprintf
。
1.fmt.Print
和fmt.Println
fmt.Print
: 直接输出,不添加任何额外的字符。fmt.Println
: 输出内容后会自动添加一个换行符。
package main
import "fmt"
func main() {
fmt.Print("Hello, ")
fmt.Print("Go!")
// 输出: Hello, Go!
fmt.Println("Hello,")
fmt.Println("Go!")
// 输出:
// Hello,
// Go!
}
2. fmt.Printf
fmt.Printg
函数是 go 语言中常用的格式化输出方式。
package main
import "fmt"
func main() {
name := "Alice"
age := 30
// 使用占位符 %s 和 %d 分别输出字符串和整数
fmt.Printf("Name: %s, Age: %d\n", name, age)
// 使用占位符 %v 输出变量的默认格式
fmt.Printf("Name: %v, Age: %v\n", name, age)
// 使用占位符 %+v 输出带字段名的变量的默认格式
fmt.Printf("Name: %+v, Age: %+v\n", name, age)
// 使用占位符 %T 输出变量的类型
fmt.Printf("Type of name: %T, Type of age: %T\n", name, age)
// 使用占位符 %q 输出带双引号的字符串
fmt.Printf("Quoted name: %q\n", name)
// 使用占位符 %b 输出整数的二进制表示
fmt.Printf("Binary age: %b\n", age)
// 使用占位符 %x 和 %X 分别输出整数的十六进制表示(小写字母和大写字母)
fmt.Printf("Hexadecimal age (lowercase): %x\n", age)
fmt.Printf("Hexadecimal age (uppercase): %X\n", age)
// 使用占位符 %f 输出浮点数的小数表示
height := 1.75
fmt.Printf("Height: %f\n", height)
// 使用占位符 %.2f 指定浮点数的小数位数
fmt.Printf("Height (2 decimal places): %.2f\n", height)
}
3. fmt.Sprintf
- `fmt.Sprintf``函数用于将格式化的字符串保存到变量中,而不是直接输出到标准输出流。
package main
import "fmt"
func main() {
name := "Bob"
age := 25
// 使用 fmt.Sprintf 格式化字符串并保存到变量中
formattedString := fmt.Sprintf("Name: %s, Age: %d", name, age)
// 输出格式化的字符串
fmt.Println(formattedString)
}
字符串操作
在 go 语言中,字符串的操作主要包括字符串连接、获取字符串长度、字符串切片、字符串查找、字符串替换等。
1.字符串连接
使用 +
运算符来连接字符串
package main
import "fmt"
func main() {
str1 := "Hello"
str2 := "World"
result := str1 + " " + str2
fmt.Println(result) // Output: Hello World
}
2.获取字符串长度
使用len()
函数获取字符串的长度
package main
import "fmt"
func main() {
str := "Hello, World!"
length := len(str)
fmt.Println("Length of string:", length) // Output: 13
}
3.字符串切片
使用切片操作来获取字符串的子串
package main
import "fmt"
func main() {
str := "Hello, World!"
substring := str[7:12]
fmt.Println("Substring:", substring) // Output: World
}
4.字符串查找
使用strings
包提供的函数来查找字串在字符串中的位置
package main
import (
"fmt"
"strings"
)
func main() {
str := "Hello, World!"
index := strings.Index(str, "World")
fmt.Println("Index of 'World':", index) // Output: 7
}
5.字符串替换
使用strings
包提供的函数来替换字符串中的字串
package main
import (
"fmt"
"strings"
)
func main() {
str := "Hello, World!"
newStr := strings.Replace(str, "World", "Gopher", -1)
fmt.Println("New string:", newStr) // Output: Hello, Gopher!
}
6.字符串拼接
三种方式对字符串进行拼接,其中两种为高性能模式,在涉及到性能要求时需注意。
package main
func main() {
// 格式化输出
username := "bobby"
age := 18
address := "北京"
mobile := "15687954621"
fmt.Println("用户名: "+username, ", 年龄: "+strconv.Itoa(age)+", 地址:"+address, ", 电话: "+mobile) // 极其难维护
fmt.Printf("用户名:%s, 年龄: %d, 地址: %s, 电话: %s\n", username, age, address, mobile) // 非常常用,但是性能没有上面的好
userMsg := fmt.Sprintf("用户名:%s, 年龄: %d, 地址: %s, 电话: %s\r\n", username, age, address, mobile)
fmt.Println(userMsg)
// 通过srting的builder进行字符串拼接, 高性能
var builder strings.Builder
builder.WriteString("用户名")
builder.WriteString(username)
builder.WriteString("年龄")
builder.WriteString(strconv.Itoa(age))
builder.WriteString("地址")
builder.WriteString(address)
builder.WriteString("电话")
builder.WriteString(mobile)
re := builder.String()
fmt.Println(re)
}