【Go语言】语法基础之算术符详解

明明跟你说过2024-11-01 11:09

🐇明明跟你说过：个人主页

🏅个人专栏：《Go语言探索之旅》🏅

🔖行路有良友，便是天堂🔖

目录

一、引言

1、Go语言简介

2、Go语言特点

二、算术符

1、算术运算符

2、关系运算符

3、逻辑运算符

4、位运算符

5、赋值运算符

6、其他运算符（如&取地址、*解引用等）

一、引言

1、Go语言简介

Go语言，又称Golang，是由Google公司开发的一种现代编程语言。它起源于2007年，并在2009年正式对外发布。Go语言旨在提高软件开发的效率、可靠性和可维护性，特别在处理并发性方面表现出色。

2、Go语言特点

  1. **并发性支持：**Go语言内置并发性支持，允许开发者构建高度并发和可扩展的应用。它提供了goroutine（轻量级线程）和channel（通信管道）等功能，简化了并发编程。
  2. **垃圾回收：**Go语言拥有高效的垃圾回收机制，自动释放不再使用的内存。这减轻了开发者管理内存的负担，提高了程序的稳定性和可靠性。
  3. **类型安全：**Go语言是一种强类型语言，提供了严格的类型检查机制。这有助于捕获类型错误，确保代码的可靠性。
  4. **跨平台性：**Go语言编译成可执行文件后，可以在不同的操作系统（如Linux、Windows、macOS）上运行，无需进行重新编译。
  5. **高性能：**Go语言编译器生成高度优化的机器代码，使程序运行速度快且资源消耗低。它特别适合处理高并发和数据密集型应用。

二、算术符

1、算术运算符

示例代码

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    a := 10.5
    b := 5.25

    // 加法
    sum := a + b
    fmt.Printf("Sum: %.2f\n", sum)

    // 减法
    difference := a - b
    fmt.Printf("Difference: %.2f\n", difference)

    // 乘法
    product := a * b
    fmt.Printf("Product: %.2f\n", product)

    // 除法
    quotient := a / b
    fmt.Printf("Quotient: %.2f\n", quotient)
}

输出结果

运行上述代码后，输出结果如下：

Go 复制代码 
Sum: 15.75
Difference: 5.25
Product: 55.13
Quotient: 2.00

2、关系运算符

在 Go 语言中，关系运算符用于比较两个值，并返回一个布尔值（true 或 false），表示比较的结果。关系运算符主要包括以下几种：

  1. **等于 (==)：**检查两个操作数是否相等。
  2. **不等于 (!=)：**检查两个操作数是否不相等。
  3. **大于 (>)：**检查左边的操作数是否大于右边的操作数。
  4. **小于 (<)：**检查左边的操作数是否小于右边的操作数。
  5. **大于等于 (>=)：**检查左边的操作数是否大于或等于右边的操作数。
  6. **小于等于 (<=)：**检查左边的操作数是否小于或等于右边的操作数。

示例代码

下面是一个简单的示例，展示了如何使用这些关系运算符：

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    a := 10
    b := 5

    // 等于
    isEqual := a == b
    fmt.Printf("%d == %d: %v\n", a, b, isEqual)

    // 不等于
    isNotEqual := a != b
    fmt.Printf("%d != %d: %v\n", a, b, isNotEqual)

    // 大于
    isGreater := a > b
    fmt.Printf("%d > %d: %v\n", a, b, isGreater)

    // 小于
    isLess := a < b
    fmt.Printf("%d < %d: %v\n", a, b, isLess)

    // 大于等于
    isGreaterOrEqual := a >= b
    fmt.Printf("%d >= %d: %v\n", a, b, isGreaterOrEqual)

    // 小于等于
    isLessOrEqual := a <= b
    fmt.Printf("%d <= %d: %v\n", a, b, isLessOrEqual)
}

输出结果

运行上述代码后，输出结果如下：

Go 复制代码 
10 == 5: false
10 != 5: true
10 > 5: true
10 < 5: false
10 >= 5: true
10 <= 5: false

3、逻辑运算符

在 Go 语言中，逻辑运算符用于组合条件表达式，并返回布尔值。逻辑运算符主要有三种：

  1. **逻辑与 (&&)：**只有当两边的操作数都为 true 时，整个表达式才为 true。
  2. **逻辑或 (||)：**只要任意一边的操作数为 true，整个表达式就为 true。
  3. **逻辑非 (!)：**反转操作数的布尔值。

示例代码

下面是一个简单的示例，展示了如何使用这些逻辑运算符：

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    a := true
    b := false

    // 逻辑与 (&&)
    andResult := a && b
    fmt.Printf("%t && %t = %t\n", a, b, andResult)

    // 逻辑或 (||)
    orResult := a || b
    fmt.Printf("%t || %t = %t\n", a, b, orResult)

    // 逻辑非 (!)
    notA := !a
    fmt.Printf("!%t = %t\n", a, notA)
    notB := !b
    fmt.Printf("!%t = %t\n", b, notB)
}

输出结果

运行上述代码后，输出结果如下：

Go 复制代码 
true && false = false
true || false = true
!true = false
!false = true

4、位运算符

在 Go 语言中，位运算符用于对整数类型的变量或常量进行按位操作。位运算符主要包含以下几个：

  1. **按位与 (&)：**对两个操作数的每一位进行与操作，对应位都为 1 时结果为 1，否则为 0。
  2. **按位或 (|)：**对两个操作数的每一位进行或操作，对应位有一个为 1 时结果为 1，否则为 0。
  3. **按位异或 (^)：**对两个操作数的每一位进行异或操作，对应位相同为 0，不同为 1。
  4. **按位取反 (^)：**对单个操作数的每一位进行取反操作，1 变为 0，0 变为 1。
  5. **左移 (<<)：**将操作数的二进制表示向左移动指定位数，高位补零。
  6. **右移 (>>)：**将操作数的二进制表示向右移动指定位数，低位补零或符号扩展（对于负数）。

示例代码

下面是一个简单的示例，展示了如何使用这些位运算符：

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    a := 0b1010  // 二进制表示为 1010，即十进制的 10
    b := 0b1100  // 二进制表示为 1100，即十进制的 12

    // 按位与 (&)
    andResult := a & b
    fmt.Printf("a & b = %b (decimal: %d)\n", andResult, andResult)

    // 按位或 (|)
    orResult := a | b
    fmt.Printf("a | b = %b (decimal: %d)\n", orResult, orResult)

    // 按位异或 (^)
    xorResult := a ^ b
    fmt.Printf("a ^ b = %b (decimal: %d)\n", xorResult, xorResult)

    // 按位取反 (^)
    notResult := ^a
    fmt.Printf("^a = %b (decimal: %d)\n", notResult, notResult)

    // 左移 (<<)
    leftShiftResult := a << 2
    fmt.Printf("a << 2 = %b (decimal: %d)\n", leftShiftResult, leftShiftResult)

    // 右移 (>>)
    rightShiftResult := a >> 1
    fmt.Printf("a >> 1 = %b (decimal: %d)\n", rightShiftResult, rightShiftResult)
}

输出结果

运行上述代码后，输出结果如下：

Go 复制代码 
a & b = 1000 (decimal: 8)
a | b = 1110 (decimal: 14)
a ^ b = 0110 (decimal: 6)
^a = ...110101 (decimal: -11)  // 注意，按位取反在二进制补码表示下会有所不同
a << 2 = 101000 (decimal: 40)
a >> 1 = 101 (decimal: 5)

解释
按位与 (&)：

  • a & b = 1010 & 1100 = 1000 （十进制 8）

按位或 (|)：

  • a | b = 1010 | 1100 = 1110 （十进制 14）

按位异或 (^)：

  • a ^ b = 1010 ^ 1100 = 0110 （十进制 6）

按位取反 (^)：

  • ^a = ^1010 （二进制表示为补码，具体取决于整数类型大小）
  • 对于 int 类型，取反的结果为 -11（在补码表示下）

左移 (<<)：

  • a << 2 = 1010 << 2 = 101000 （十进制 40）

右移 (>>)：

  • a >> 1 = 1010 >> 1 = 101 （十进制 5）

应用场景

  • 位运算符在计算机科学中有广泛的应用，例如在算法优化、网络编程、数据压缩等领域。此外，位运算符还可以用来设置或清除标志位、位掩码操作等。

5、赋值运算符

在 Go 语言中，赋值运算符用于将一个值赋给一个变量或表达式。除了基本的赋值运算符 = 之外，Go 还支持一系列复合赋值运算符，这些运算符结合了算术运算符或其他运算符的功能与赋值操作。

基本赋值运算符 =

基本的赋值运算符 = 用于将一个值赋给一个变量。

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    a := 10
    fmt.Println("Initial value of a:", a)

    // 使用 = 赋值
    a = 20
    fmt.Println("Value of a after assignment:", a)
}

输出结果：

Go 复制代码 
Initial value of a: 10
Value of a after assignment: 20

复合赋值运算符

复合赋值运算符结合了算术运算符或其他运算符的功能与赋值操作。常见的复合赋值运算符包括：

  1. **加法赋值 (+=)：**将变量的当前值与另一个值相加，并将结果赋给该变量。
  2. **减法赋值 (-=)：**将变量的当前值与另一个值相减，并将结果赋给该变量。
  3. **乘法赋值 (*=)：**将变量的当前值与另一个值相乘，并将结果赋给该变量。
  4. **除法赋值 (/=)：**将变量的当前值与另一个值相除，并将结果赋给该变量。
  5. **取模赋值 (%=)：**将变量的当前值与另一个值取模，并将结果赋给该变量。
  6. **按位与赋值 (&=)：**对变量的当前值与另一个值按位与，并将结果赋给该变量。
  7. **按位或赋值 (|=)：**对变量的当前值与另一个值按位或，并将结果赋给该变量。
  8. **按位异或赋值 (^=)：**对变量的当前值与另一个值按位异或，并将结果赋给该变量。
  9. **左移赋值 (<<=)：**将变量的当前值左移一定位数，并将结果赋给该变量。
  10. **右移赋值 (>>=)：**将变量的当前值右移一定位数，并将结果赋给该变量。

示例代码

下面是一个简单的示例，展示了如何使用这些复合赋值运算符：

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    a := 10
    b := 5

    fmt.Println("Initial value of a:", a)
    fmt.Println("Initial value of b:", b)

    // 加法赋值
    a += b
    fmt.Println("Value of a after += b:", a)

    // 减法赋值
    a -= b
    fmt.Println("Value of a after -= b:", a)

    // 乘法赋值
    a *= b
    fmt.Println("Value of a after *= b:", a)

    // 除法赋值
    a /= b
    fmt.Println("Value of a after /= b:", a)

    // 取模赋值
    a %= b
    fmt.Println("Value of a after %= b:", a)

    // 按位与赋值
    a &= 0b1100
    fmt.Println("Value of a after &= 0b1100:", a)

    // 按位或赋值
    a |= 0b0011
    fmt.Println("Value of a after |= 0b0011:", a)

    // 按位异或赋值
    a ^= 0b0101
    fmt.Println("Value of a after ^= 0b0101:", a)

    // 左移赋值
    a <<= 2
    fmt.Println("Value of a after <<= 2:", a)

    // 右移赋值
    a >>= 1
    fmt.Println("Value of a after >>= 1:", a)
}

输出结果

运行上述代码后，输出结果如下：

Go 复制代码 
Initial value of a: 10
Initial value of b: 5
Value of a after += b: 15
Value of a after -= b: 10
Value of a after *= b: 50
Value of a after /= b: 10
Value of a after %= b: 0
Value of a after &= 0b1100: 4
Value of a after |= 0b0011: 7
Value of a after ^= 0b0101: 6
Value of a after <<= 2: 24
Value of a after >>= 1: 12

6、其他运算符（如&取地址、*解引用等）

在 Go 语言中，除了算术运算符、关系运算符、逻辑运算符和位运算符 外，还有一些特殊的运算符用于指针操作，以及其他用途的运算符。这里主要介绍指针相关的运算符 &（取地址） 和***（解引用）**，以及一些其他常用的运算符。

指针相关的运算符

  • 取地址 (&)：
    • 用于获取变量的内存地址，返回的是指向该变量的指针。
  • 解引用 (*)：
    • 用于访问指针所指向的变量的值。

示例代码

下面是一个简单的示例，展示了如何使用取地址和解引用运算符：

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    // 声明并初始化一个变量
    value := 10

    // 取得变量的地址
    addressOfValue := &value
    fmt.Printf("Address of value: %p\n", addressOfValue)

    // 解引用地址，获取值
    unreferencedValue := *addressOfValue
    fmt.Printf("Unreferenced value: %d\n", unreferencedValue)

    // 修改指针指向的值
    *addressOfValue = 20
    fmt.Printf("Modified value via pointer: %d\n", value)
}

输出结果

运行上述代码后，输出结果如下：

Go 复制代码 
Address of value: 0xc000018048
Unreferenced value: 10
Modified value via pointer: 20

解释

  • 取地址 (&)：
    • addressOfValue := &value 获取 value 变量的地址，并将其赋值给 addressOfValue。
  • 解引用 (*)：
    • unreferencedValue := *addressOfValue 解引用 addressOfValue，访问其指向的值，并赋值给 unreferencedValue。
  • 修改指针指向的值：
    • *addressOfValue = 20 通过解引用 addressOfValue 来修改其指向的 value 变量的值。

其他运算符

除了指针相关的运算符外，Go 语言还有其他一些常用的运算符，例如：

  • 范围运算符 (range)：
    • 用于迭代数组、切片、映射（maps）或通道（channels）中的元素。
  • 转换运算符 (T(expr))：
    • 用于将一个表达式转换为另一种类型。
  • 逗号运算符 (comma)：
    • 在 Go 语言中，逗号通常用于序列化多个表达式，如在声明多个变量时使用。

示例代码

下面是一些其他运算符的示例：

范围运算符 (range)

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    // 使用 range 迭代切片
    slice := []int{1, 2, 3, 4, 5}
    for index, value := range slice {
        fmt.Printf("Index: %d, Value: %d\n", index, value)
    }
}

输出结果

Go 复制代码 
Index: 0, Value: 1
Index: 1, Value: 2
Index: 2, Value: 3
Index: 3, Value: 4
Index: 4, Value: 5

转换运算符 (T(expr))

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    var floatVal float64 = 3.14
    intVal := int(floatVal) // 将 float64 转换为 int
    fmt.Printf("Converted integer value: %d\n", intVal)
}

输出结果

Go 复制代码 
Converted integer value: 3

逗号运算符 (comma)

在 Go 语言中，逗号主要用于声明多个变量：

Go 复制代码 
package main

import (
    "fmt"
)

func main() {
    a, b := 10, 20
    fmt.Printf("a: %d, b: %d\n", a, b)
}

输出结果

Go 复制代码 
a: 10, b: 20

💕💕💕每一次的分享都是一次成长的旅程，感谢您的陪伴和关注。希望这些关于Go语言的文章能陪伴您走过技术的一段旅程，共同见证成长和进步！😺😺😺

🧨🧨🧨让我们一起在技术的海洋中探索前行，共同书写美好的未来！！！

相关推荐
Oneforlove_twoforjob6 分钟前
【Java基础面试题033】Java泛型的作用是什么？
java·开发语言
engchina22 分钟前
如何在 Python 中忽略烦人的警告？
开发语言·人工智能·python
向宇it23 分钟前
【从零开始入门unity游戏开发之——C#篇24】C#面向对象继承——万物之父（object）、装箱和拆箱、sealed 密封类
java·开发语言·unity·c#·游戏引擎
诚丞成1 小时前
计算世界之安生：C++继承的文水和智慧（上）
开发语言·c++
Smile灬凉城6661 小时前
反序列化为啥可以利用加号绕过php正则匹配
开发语言·php
lsx2024061 小时前
SQL MID()
开发语言
Dream_Snowar1 小时前
速通Python 第四节——函数
开发语言·python·算法
西猫雷婶1 小时前
python学opencv|读取图像（十四）BGR图像和HSV图像通道拆分
开发语言·python·opencv
鸿蒙自习室1 小时前
鸿蒙UI开发——组件滤镜效果
开发语言·前端·javascript
言、雲1 小时前
从tryLock()源码来出发，解析Redisson的重试机制和看门狗机制
java·开发语言·数据库
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04机器人编程怎么入门？05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07SQL 主从数据库实时备份08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10VSCode插件 —— Cody AI （免费AI助手！）