2.go语言初始（二）

本篇博客涉及到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)
}