当前位置:首页 » 《关注互联网》 » 正文

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

7 人参与  2024年11月04日 13:20  分类 : 《关注互联网》  评论

点击全文阅读


?明明跟你说过:个人主页

?个人专栏:《Go语言探索之旅》?

?行路有良友,便是天堂?

目录

一、引言

1、Go语言简介

2、Go语言特点

二、算术符 

1、算术运算符

2、关系运算符 

3、逻辑运算符 

4、位运算符 

5、赋值运算符 

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


一、引言

1、Go语言简介

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

2、Go语言特点

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

二、算术符 

1、算术运算符

示例代码

package mainimport (    "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)}


输出结果
运行上述代码后,输出结果如下:

Sum: 15.75Difference: 5.25Product: 55.13Quotient: 2.00

2、关系运算符 

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

等于 (==):检查两个操作数是否相等。不等于 (!=):检查两个操作数是否不相等。大于 (>):检查左边的操作数是否大于右边的操作数。小于 (<):检查左边的操作数是否小于右边的操作数。大于等于 (>=):检查左边的操作数是否大于或等于右边的操作数。小于等于 (<=):检查左边的操作数是否小于或等于右边的操作数。


示例代码
下面是一个简单的示例,展示了如何使用这些关系运算符:

package mainimport (    "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)}


输出结果
运行上述代码后,输出结果如下:

10 == 5: false10 != 5: true10 > 5: true10 < 5: false10 >= 5: true10 <= 5: false

3、逻辑运算符 

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

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

示例代码
下面是一个简单的示例,展示了如何使用这些逻辑运算符:

package mainimport (    "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)}


输出结果
运行上述代码后,输出结果如下:

true && false = falsetrue || false = true!true = false!false = true

4、位运算符 

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

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


示例代码
下面是一个简单的示例,展示了如何使用这些位运算符:

package mainimport (    "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)}


输出结果
运行上述代码后,输出结果如下:

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 还支持一系列复合赋值运算符,这些运算符结合了算术运算符或其他运算符的功能与赋值操作。

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

package mainimport (    "fmt")func main() {    a := 10    fmt.Println("Initial value of a:", a)    // 使用 = 赋值    a = 20    fmt.Println("Value of a after assignment:", a)}


输出结果:

Initial value of a: 10Value of a after assignment: 20


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

加法赋值 (+=):将变量的当前值与另一个值相加,并将结果赋给该变量。减法赋值 (-=):将变量的当前值与另一个值相减,并将结果赋给该变量。乘法赋值 (*=):将变量的当前值与另一个值相乘,并将结果赋给该变量。除法赋值 (/=):将变量的当前值与另一个值相除,并将结果赋给该变量。取模赋值 (%=):将变量的当前值与另一个值取模,并将结果赋给该变量。按位与赋值 (&=):对变量的当前值与另一个值按位与,并将结果赋给该变量。按位或赋值 (|=):对变量的当前值与另一个值按位或,并将结果赋给该变量。按位异或赋值 (^=):对变量的当前值与另一个值按位异或,并将结果赋给该变量。左移赋值 (<<=):将变量的当前值左移一定位数,并将结果赋给该变量。右移赋值 (>>=):将变量的当前值右移一定位数,并将结果赋给该变量。


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

package mainimport (    "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)}


输出结果
运行上述代码后,输出结果如下:

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

     

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

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

指针相关的运算符

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

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

package mainimport (    "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)}


输出结果
运行上述代码后,输出结果如下:

Address of value: 0xc000018048Unreferenced value: 10Modified 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)

package mainimport (    "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)    }}



输出结果

Index: 0, Value: 1Index: 1, Value: 2Index: 2, Value: 3Index: 3, Value: 4Index: 4, Value: 5


转换运算符 (T(expr))

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


输出结果

Converted integer value: 3


逗号运算符 (comma)
在 Go 语言中,逗号主要用于声明多个变量:

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


输出结果

a: 10, b: 20

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

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


点击全文阅读


本文链接:http://zhangshiyu.com/post/182252.html

<< 上一篇 下一篇 >>

  • 评论(0)
  • 赞助本站

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

关于我们 | 我要投稿 | 免责申明

Copyright © 2020-2022 ZhangShiYu.com Rights Reserved.豫ICP备2022013469号-1