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 mainimport "fmt"func main() {var a int = 34var b int8 = 98var c uint 16 = 65535var d uintptr = 0x12345678fmt.Println("int", a)fmt.Println("int8", b)fmt.Println("uint16", c)fmt.Println("uintptr", d)
}

【注】有符号类型和无符号类型的区别

• 有符号整数：
  有符号整数可以表示正数、负数和零、最高位（最左边一位）用作符号位：0 表示正数， 1 表示负数。
• 无符号整数
  无符号整数只能表示非负数（正数和零）。所有位都用于表示值，没有符号位。

2.浮点数类型

• float32：32位浮点数类型。
• float64：64位浮点数类型。

package mainimport "fmt"func main() {var e float32 = 3.14var f float64 = 2.5346546fmt.Println("float32: ", e)fmt.Println("float64: ", f)
}

3.复数类型

• complex64: 由两个float32组成的复数类型
• complex128: 由两个float64组成的复数类型

package mainimport "fmt"func main() {var g complex64 = i + 2ivar g complex64 = 3.5 + 2.5ifmt.Println("complex64:", g)fmt.Println("complex128:", h)
}

4.布尔类型

• bool: 布尔类型只能取 'true’或 ‘false’.

package mainimport "fmt"func main() {var i bool = truevar j bool = falsefmt.Println("bool true:", i)fmt.Println("bool false:", j)
}

5.字符串类型

• string: 字符串类型，表示一串UTF-8编码的字符。

package mainimport "fmt"func main() {var i bool = truevar j bool = falsefmt.Println("bool true:", i)fmt.Println("bool false:", j)
}

6.字节类型

• byte: ‘uint8’ 的别名，通常表示一个字节的数据

package mainimport "fmt"func main() {var l byte = 'A'fmt.Println("byte:", l)
}

7.符文类型

• rune： ‘int32’ 的别名，通常用于表示一个Unicode码点。

package mainimport "fmt"func main() {var m rune = '你'fmt.Println("rune:", m)
}

go 语言中的运算符

在 go 语言中，运算符用于执行各种操作，如算术运算、比较、逻辑运算和位运算。

1.算数运算符

• +：加法
• -：减法
• *：乘法
• /：除法
• %：取余

package mainimport "fmt"func main() {a := 10b := 3fmt.Println("加法:", a + b)   // 13fmt.Println("减法:", a - b)   // 7fmt.Println("乘法:", a * b)   // 30fmt.Println("除法:", a / b)   // 3fmt.Println("取余:", a % b)   // 1
}

2.关系运算符

• ==：等于
• !=：不等于
• <：小于

• ：大于

• <=：小于等于

• =：大于等于

package mainimport "fmt"func main() {a := 10b := 20fmt.Println("等于:", a == b)        // falsefmt.Println("不等于:", a != b)      // truefmt.Println("小于:", a < b)         // truefmt.Println("大于:", a > b)         // falsefmt.Println("小于等于:", a <= b)    // truefmt.Println("大于等于:", a >= b)    // false
}

3.逻辑运算符

• &&：逻辑与（AND）
• ||：逻辑或（OR）
• !：逻辑非（NOT）

package mainimport "fmt"func main() {a := trueb := falsefmt.Println("逻辑与:", a && b)   // falsefmt.Println("逻辑或:", a || b)   // truefmt.Println("逻辑非:", !a)       // false
}

4.位运算符

• &：按位与（AND）
• |：按位或（OR）
• ^：按位异或（XOR）
• &^：按位清零（AND NOT）
• <<：左移
• >>: 右移

package mainimport "fmt"func main() {a := 10        // 1010b := 3         // 0011fmt.Println("按位与:", a & b)   // 0010 -> 2fmt.Println("按位或:", a | b)   // 1011 -> 11fmt.Println("按位异或:", a ^ b) // 1001 -> 9fmt.Println("按位清零:", a &^ b) // 0100 -> 8c := 1        // 0001fmt.Println("左移:", c << 2)    // 0100 -> 4fmt.Println("右移:", a >> 2)    // 0010 -> 2
}

5.赋值运算符

• =：赋值
• +=：加后赋值
• -=：减后赋值
• *=：乘后赋值
• /=：除后赋值
• %=：取余后赋值
• &=：按位与后赋值
• |=：按位或后赋值
• ^=：按位异或后赋值
• <<=：左移后赋值
• />>=：右移后赋值

package mainimport "fmt"func main() {a := 5a += 3fmt.Println("加后赋值:", a)   // 8a -= 2fmt.Println("减后赋值:", a)   // 6a *= 2fmt.Println("乘后赋值:", a)   // 12a /= 3fmt.Println("除后赋值:", a)   // 4a %= 3fmt.Println("取余后赋值:", a) // 1
}

6.其它运算符

• ++：自增
• –：自减

package mainimport "fmt"func main() {a := 5a++fmt.Println("自增:", a)   // 6a--fmt.Println("自减:", a)   // 5
}

转义字符

go 语言中，常见的转义字符包括换行符、制表符、引号和反斜杠等。

1.常见转义字符

• \a：响铃（警报）
• \b：退格
• \f：换页
• \n：换行
• \r：回车
• \t：水平制表符
• \v：垂直制表符
• \：反斜杠
• "：双引号
• '：单引号

package mainimport "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 mainimport "fmt"func main() {var str string = "这是一个包含换行符的字符串：\n你好，世界！"fmt.Println(str)
}

3.使用反引号

在 go 语言中，可以使用反引号（···）创建原始字符串字面值，这种字符串字面值不支持转义字符，所有的字符都按原样处理。这对包含大量特殊字符或多行文本的字符串非常有用。例如：

package mainimport "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 mainimport "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 mainimport "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.75fmt.Printf("Height: %f\n", height)// 使用占位符 %.2f 指定浮点数的小数位数fmt.Printf("Height (2 decimal places): %.2f\n", height)
}

3. fmt.Sprintf

• `fmt.Sprintf``函数用于将格式化的字符串保存到变量中，而不是直接输出到标准输出流。

package mainimport "fmt"func main() {name := "Bob"age := 25// 使用 fmt.Sprintf 格式化字符串并保存到变量中formattedString := fmt.Sprintf("Name: %s, Age: %d", name, age)// 输出格式化的字符串fmt.Println(formattedString)
}

字符串操作

在 go 语言中，字符串的操作主要包括字符串连接、获取字符串长度、字符串切片、字符串查找、字符串替换等。

1.字符串连接

使用 + 运算符来连接字符串

package mainimport "fmt"func main() {str1 := "Hello"str2 := "World"result := str1 + " " + str2fmt.Println(result) // Output: Hello World
}

2.获取字符串长度

使用len（）函数获取字符串的长度

package mainimport "fmt"func main() {str := "Hello, World!"length := len(str)fmt.Println("Length of string:", length) // Output: 13
}

3.字符串切片

使用切片操作来获取字符串的子串

package mainimport "fmt"func main() {str := "Hello, World!"substring := str[7:12]fmt.Println("Substring:", substring) // Output: World
}

4.字符串查找

使用strings包提供的函数来查找字串在字符串中的位置

package mainimport ("fmt""strings"
)func main() {str := "Hello, World!"index := strings.Index(str, "World")fmt.Println("Index of 'World':", index) // Output: 7
}

5.字符串替换

使用strings包提供的函数来替换字符串中的字串

package mainimport ("fmt""strings"
)func main() {str := "Hello, World!"newStr := strings.Replace(str, "World", "Gopher", -1)fmt.Println("New string:", newStr) // Output: Hello, Gopher!
}

6.字符串拼接

三种方式对字符串进行拼接，其中两种为高性能模式，在涉及到性能要求时需注意。

package mainfunc main() {// 格式化输出username := "bobby"age := 18address := "北京"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.Builderbuilder.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)
}