Golang魅力探秘：运算符、数值类型和输入输出的精彩世界

本文将带您进入Golang编程语言的神奇世界，深入介绍运算符、基础数据类型以及输入输出的关键概念。通过生动有趣的段落和实用的代码示例，让您对Golang的强大功能有更全面的了解。

一、操作运算符

运算符是Golang中常用的工具，用于执行各种计算和操作。以下是一些常见的运算符及其使用示例：

1.1算术运算符

用于执行基本的数学运算，例如加法、减法、乘法、除法、取模、自增和自减。

// 声明变量
var a int = 10
// 同上
b := 5

// 加法
sum := a + b    
 // 减法
diff := a - b  
 // 乘法
product := a * b  

// 除法 如果运算的数都是整数，那么除以后去掉小数部分，保留整数部分
quotient := a / b 

// 取模 原理：a%b=a-a/b*b
modulo := a % b

// 在golang中，++和--只能独立使用
// module =  module++ 这样是错误的，不能赋值
module++
// Golang 的++ 和 -- 只能写在变量的后面，不能写在变量的前面，即：只有 a++ a-- 没有 ++a --a
module--

// 通过()增加优先级，先运算 (10 + 5) * -10 / 5 =  -30
joint := (a + b) * -a / b

1.2 比较（关系）运算符

• 介绍

1. 关系运算符的结果都是 bool 型，也就是要么是 true，要么是 false

2. 关系表达式 经常用在 if 结构的条件中或循环结构的条件中

• 特点

1. 关系运算符的结果都是 bool 型，也就是要么是 true，要么是 false。

2. 关系运算符组成的表达式，我们称为关系表达式： a > b

3. 比较运算符"=="不能误写成 “=” !!

a := 10
b := 5
greater := a > b       // 大于
less := a < b          // 小于
equal := a == b        // 等于
notEqual := a != b     // 不等于
lessEqual := a <= b    // 小于等于
greaterEqual := a >= b // 大于等于

1.3 逻辑运算符

于连接多个条件，最终的结果也是一个bool 。用于组合关系运算符和操作布尔值，进行逻辑运算。

// 操作布尔值
x := true
y := false
andResult := x && y    // 逻辑与
orResult := x || y     // 逻辑或
notResult := !x       // 逻辑非

// 组合关系运算
a := 10
b := 5

// andResult多次赋值不做声明，不适用 := 而是使用=
andResult = (a != b) && (a >= b)     // 逻辑与
orResult = (a == b) || (a >= b)     // 逻辑或
notResult = !(a >= b)               // 逻辑非

• 注意

1. &&也叫短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false

2. ||也叫短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true

1.4 位运算符

位运算符是一种对二进制数进行操作的运算符。它们可以用于对整数的二进制位进行操作 。

a := 5                     // 二进制为101
b := 3                     // 二进制为011
andResult := a & b         // 二进制为001，即1
orResult := a | b          // 二进制为111，即7
xorResult := a ^ b         // 二进制为110，即6
leftShiftResult := a << 2  // 二进制为10100，即20
rightShiftResult := a >> 2 // 二进制为001，即1

1.5 赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量

算术运算符赋值

a := 5
b := 3
var c int = a + b // 简单赋值 8
c += a            // 相加后赋值 13
c -= b            // 相减后赋值 10
c *= b            // 相乘后赋值 30
c /= a            // 相除后赋值 6
c %= b            // 求余后赋值 0

位运算符赋值

a := 5   // 101
a <<= 2  // 左移2位 10100 变成20
a >>= 1  // 右移1位 1010  变成 10
a &= 3   // 原值 1010 和 0111 按位与 0010 变成 2
a ^= 5   // 原值 0010 和 0101 异或后 0111 变成 7
a |= 8   // 原值 0111 和 1000 按位或 1111 变成 15

1.6 其它运算符

当我们声明一个变量或常量时，计算机系统会为这个变量或常量分配存储单元，变量的数据存储到被分配的存储单元内，对变量的赋值和取值操作都是针对存储单元的操作。

var (
    a  int  = 18 //声明实际变量
    ip *int      //声明指针变量
)
ip = &a //把a的地址赋给ip指针
fmt.Println("a变量的值是: ", a)     // 输出18
fmt.Println("a变量的地址是: ", &a)  // 内存地址 0xc00000a098
fmt.Println("指针ip的值为: ", ip)   // ip值  0xc00000a098
fmt.Println("指针ip的地址:", &ip)   // ip变量的内存地址  0xc000124018
fmt.Println("指针ip指向的值为: ", *ip) //指向值 18

指针变量ip名称前面带有“*”符号，表示这是一个指针变量，它存储的是其它变量或程序对象的内存地址。

由于指针变量存储了其它变量或程序对象的地址，因此通过指针变量可以访问或修改它们的内容。

*ip = 100 // 给指针变量ip赋值100

 // 指针变量指向内存0xc00000a098地址中的值变成100，所以修改了a的值
fmt.Println("a变量的值是: ", a)

1.7 运算符的优先级

二、数值类型

Golang提供了多种数值类型，每种类型都有其特定的范围和精度。以下是几种常见的数值类型及其使用示例：

2.1 整型（int）

表示整数值。可以是有符号或无符号，具体取决于所选择的类型大小（int8、int16、int32、int64 或 uint8、uint16、uint32、uint64）

var num int = 10
var unsignedNum uint32 = 20

2.2 浮点型（float）

表示带有小数部分的数字。可以是 float32 或 float64。

var pi float32 = 3.14
var precision float64 = 0.0001

2.3 布尔型（bool）

表示真或假的值。

var isTrue bool = true
var isFalse bool = false

2.4 字符串（string）

表示一系列字符的序列。

var message string = "Hello, World!"
var name string = "John Doe"
fmt.Println(message + name) // 可以字符相加运算符+连接

2.5 字符（rune，byte）

表示单个Unicode字符的整数值。

var ch byte = 65
var ch1 byte = 'a'
var ch2 byte = '\x64'
var char rune = 'A'
var emoji rune = '😄'

2.6 数组（array）

表示具有相同类型的固定长度的元素序列。后面专门讲解

var numbers [5]int = [5]int{1, 2, 3, 4, 5}
var names [3]string = [3]string{"Alice", "Bob", "Charlie"}

2.7 切片（slice）

表示动态大小的元素序列。

var numbers []int = []int{1, 2, 3, 4, 5}
var names []string = []string{"Alice", "Bob", "Charlie"}

2. 8 结构体（struct）

表示具有不同类型的字段的集合。

type Person struct {
    Name string
    Age int
}

var person1 Person = Person{Name: "John", Age: 25}
var person2 Person = Person{Name: "Alice", Age: 30}

2.9 指针（pointer）

表示变量内存地址的值。

var num int = 10
var ptr *int = &num

三、输入输出

Golang提供了丰富的输入输出函数，使得与用户交互和数据处理变得轻而易举。以下是几种常用的输入输出操作示例：

3.1 标准输出（fmt.Println）

将数据打印到标准输出。

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

3.2 标准输入（fmt.Scanln）

从标准输入读取用户的输入。

package main

import "fmt"

func main() {
    var name string
    fmt.Print("请输入您的姓名：")
    fmt.Scanln(&name)
    fmt.Println("欢迎，", name)
}

3.3 文件输入输出

通过文件进行数据的读写操作。

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Create("output.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    file.WriteString("这是一个文件输出示例")
    fmt.Println("文件已成功写入！")
}

结论：
通过本文的介绍，我们深入了解了Golang中的运算符、基础数据类型以及输入输出的重要概念。运算符是编程语言中必不可少的工具，而基础数据类型则为我们提供了处理数据的灵活性。输入输出操作使得与用户交互和数据处理变得轻松便捷。随着对这些基础知识的掌握，您将能够更加自信地在Golang中编写代码，并进一步探索该语言的更多功能。