一、引言

1、Go語言簡介

Go語言，又稱Golang，是由Google公司開發(fā)的一種現(xiàn)代編程語言。它起源于2007年，并在2009年正式對外發(fā)布。Go語言旨在提高軟件開發(fā)的效率、可靠性和可維護性，特別在處理并發(fā)性方面表現(xiàn)出色。

2、Go語言特點

• 并發(fā)性支持：Go語言內(nèi)置并發(fā)性支持，允許開發(fā)者構(gòu)建高度并發(fā)和可擴展的應用。它提供了goroutine（輕量級線程）和channel（通信管道）等功能，簡化了并發(fā)編程。
• 垃圾回收：Go語言擁有高效的垃圾回收機制，自動釋放不再使用的內(nèi)存。這減輕了開發(fā)者管理內(nèi)存的負擔，提高了程序的穩(wěn)定性和可靠性。
• 類型安全：Go語言是一種強類型語言，提供了嚴格的類型檢查機制。這有助于捕獲類型錯誤，確保代碼的可靠性。
• 跨平臺性：Go語言編譯成可執(zhí)行文件后，可以在不同的操作系統(tǒng)（如Linux、Windows、macOS）上運行，無需進行重新編譯。
• 高性能：Go語言編譯器生成高度優(yōu)化的機器代碼，使程序運行速度快且資源消耗低。它特別適合處理高并發(fā)和數(shù)據(jù)密集型應用。

二、算術(shù)符 

1、算術(shù)運算符

示例代碼

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)
}

輸出結(jié)果運行上述代碼后，輸出結(jié)果如下：

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

2、關(guān)系運算符 

在 Go 語言中，關(guān)系運算符用于比較兩個值，并返回一個布爾值（true 或 false），表示比較的結(jié)果。關(guān)系運算符主要包括以下幾種：

• 等于 (==)：檢查兩個操作數(shù)是否相等。
• 不等于 (!=)：檢查兩個操作數(shù)是否不相等。
• 大于 (>)：檢查左邊的操作數(shù)是否大于右邊的操作數(shù)。
• 小于 (<)：檢查左邊的操作數(shù)是否小于右邊的操作數(shù)。
• 大于等于 (>=)：檢查左邊的操作數(shù)是否大于或等于右邊的操作數(shù)。
• 小于等于 (<=)：檢查左邊的操作數(shù)是否小于或等于右邊的操作數(shù)。

示例代碼下面是一個簡單的示例，展示了如何使用這些關(guān)系運算符：

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)
}

輸出結(jié)果運行上述代碼后，輸出結(jié)果如下：

10 == 5: false
10 != 5: true
10 > 5: true
10 < 5: false
10 >= 5: true
10 <= 5: false

3、邏輯運算符 

在 Go 語言中，邏輯運算符用于組合條件表達式，并返回布爾值。邏輯運算符主要有三種：

• 邏輯與 (&&)：只有當兩邊的操作數(shù)都為 true 時，整個表達式才為 true。
• 邏輯或 (||)：只要任意一邊的操作數(shù)為 true，整個表達式就為 true。
• 邏輯非 (!)：反轉(zhuǎn)操作數(shù)的布爾值。

示例代碼下面是一個簡單的示例，展示了如何使用這些邏輯運算符：

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)
}

輸出結(jié)果運行上述代碼后，輸出結(jié)果如下：

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

4、位運算符 

在 Go 語言中，位運算符用于對整數(shù)類型的變量或常量進行按位操作。位運算符主要包含以下幾個：

• 按位與 (&)：對兩個操作數(shù)的每一位進行與操作，對應位都為 1 時結(jié)果為 1，否則為 0。
• 按位或 (|)：對兩個操作數(shù)的每一位進行或操作，對應位有一個為 1 時結(jié)果為 1，否則為 0。
• 按位異或 (^)：對兩個操作數(shù)的每一位進行異或操作，對應位相同為 0，不同為 1。
• 按位取反 (^)：對單個操作數(shù)的每一位進行取反操作，1 變?yōu)?0，0 變?yōu)?1。
• 左移 (<<)：將操作數(shù)的二進制表示向左移動指定位數(shù)，高位補零。
• 右移 (>>)：將操作數(shù)的二進制表示向右移動指定位數(shù)，低位補零或符號擴展（對于負數(shù)）。

示例代碼下面是一個簡單的示例，展示了如何使用這些位運算符：

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)
}

輸出結(jié)果運行上述代碼后，輸出結(jié)果如下：

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 （二進制表示為補碼，具體取決于整數(shù)類型大?。?/li>
• 對于 int 類型，取反的結(jié)果為 -11（在補碼表示下）

左移 (<<)：

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

右移 (>>)：

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

應用場景

• 位運算符在計算機科學中有廣泛的應用，例如在算法優(yōu)化、網(wǎng)絡(luò)編程、數(shù)據(jù)壓縮等領(lǐng)域。此外，位運算符還可以用來設(shè)置或清除標志位、位掩碼操作等。

5、賦值運算符 

在 Go 語言中，賦值運算符用于將一個值賦給一個變量或表達式。除了基本的賦值運算符 = 之外，Go 還支持一系列復合賦值運算符，這些運算符結(jié)合了算術(shù)運算符或其他運算符的功能與賦值操作。

基本賦值運算符 =基本的賦值運算符 = 用于將一個值賦給一個變量。

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)
}

輸出結(jié)果：

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

復合賦值運算符復合賦值運算符結(jié)合了算術(shù)運算符或其他運算符的功能與賦值操作。常見的復合賦值運算符包括：

• 加法賦值 (+=)：將變量的當前值與另一個值相加，并將結(jié)果賦給該變量。
• 減法賦值 (-=)：將變量的當前值與另一個值相減，并將結(jié)果賦給該變量。
• 乘法賦值 (*=)：將變量的當前值與另一個值相乘，并將結(jié)果賦給該變量。
• 除法賦值 (/=)：將變量的當前值與另一個值相除，并將結(jié)果賦給該變量。
• 取模賦值 (%=)：將變量的當前值與另一個值取模，并將結(jié)果賦給該變量。
• 按位與賦值 (&=)：對變量的當前值與另一個值按位與，并將結(jié)果賦給該變量。
• 按位或賦值 (|=)：對變量的當前值與另一個值按位或，并將結(jié)果賦給該變量。
• 按位異或賦值 (^=)：對變量的當前值與另一個值按位異或，并將結(jié)果賦給該變量。
• 左移賦值 (<<=)：將變量的當前值左移一定位數(shù)，并將結(jié)果賦給該變量。
• 右移賦值 (>>=)：將變量的當前值右移一定位數(shù)，并將結(jié)果賦給該變量。

示例代碼下面是一個簡單的示例，展示了如何使用這些復合賦值運算符：

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)
}

輸出結(jié)果運行上述代碼后，輸出結(jié)果如下：

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 語言中，除了算術(shù)運算符、關(guān)系運算符、邏輯運算符和位運算符外，還有一些特殊的運算符用于指針操作，以及其他用途的運算符。這里主要介紹指針相關(guān)的運算符 &（取地址）和 *（解引用），以及一些其他常用的運算符。

指針相關(guān)的運算符

• 取地址 (&)：
  • 用于獲取變量的內(nèi)存地址，返回的是指向該變量的指針。
• 解引用 (*)：
  • 用于訪問指針所指向的變量的值。

示例代碼下面是一個簡單的示例，展示了如何使用取地址和解引用運算符：

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)
}

輸出結(jié)果運行上述代碼后，輸出結(jié)果如下：

Address of value: 0xc000018048
Unreferenced value: 10
Modified value via pointer: 20

解釋

• 取地址 (&)：
  • addressOfValue := &value 獲取 value 變量的地址，并將其賦值給 addressOfValue。
• 解引用 (*)：
  • unreferencedValue := *addressOfValue 解引用 addressOfValue，訪問其指向的值，并賦值給 unreferencedValue。
• 修改指針指向的值：
  • *addressOfValue = 20 通過解引用 addressOfValue 來修改其指向的 value 變量的值。

其他運算符除了指針相關(guān)的運算符外，Go 語言還有其他一些常用的運算符，例如：

• 范圍運算符 (range)：
  • 用于迭代數(shù)組、切片、映射（maps）或通道（channels）中的元素。
• 轉(zhuǎn)換運算符 (T(expr))：
  • 用于將一個表達式轉(zhuǎn)換為另一種類型。
• 逗號運算符 (comma)：
  • 在 Go 語言中，逗號通常用于序列化多個表達式，如在聲明多個變量時使用。

示例代碼下面是一些其他運算符的示例：

范圍運算符 (range)

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)
    }
}

輸出結(jié)果

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

轉(zhuǎn)換運算符 (T(expr))

package main

import (
    "fmt"
)

func main() {
    var floatVal float64 = 3.14
    intVal := int(floatVal) // 將 float64 轉(zhuǎn)換為 int
    fmt.Printf("Converted integer value: %d\n", intVal)
}

輸出結(jié)果

Converted integer value: 3

逗號運算符 (comma)

在 Go 語言中，逗號主要用于聲明多個變量：

package main

import (
    "fmt"
)

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

輸出結(jié)果

a: 10, b: 20

總結(jié) 

到此這篇關(guān)于Go語言語法基礎(chǔ)之算術(shù)符的文章就介紹到這了,更多相關(guān)Go語言算術(shù)符內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論