banner
Pi3

Pi3

记录学习、生活和成长
github
telegram
x
zhihu
email

Go語言入門4:常量

Go 語言入門基礎學習筆記之 Go 語言的常量

golang

常量#

常量定義#

常量是一個簡單值的標識符,在程序運行時,不會被修改的量。

常量中的數據類型只可以是布爾型數字型(整數型、浮點型和複數)和字符串型

常量的定義格式:

const identifier [type] = value

同樣,在這裡可以省略類型說明符 type,因為編譯器會根據常量值來自動推斷類型。這樣就分為了顯式類型定義隱式類型定義

多個相同類型的聲明可以簡寫為:

const c_name1, c_name2 = value1, value2

常量還可以用作定義枚舉類型:

const (
    Unknown = 0
    Female = 1
    Male = 2
)

由於如果枚舉類型很多,一個個賦值十分麻煩,於是 Go 語言提供了一個關鍵字 iota

常量可以用 len(), cap(), unsafe.Sizeof() 函數計算表達式的值。常量表達式中,函數必須是內置函數,否則編譯不通過。

package main

import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main(){
    println(a, b, c)
}

// 輸出結果
abc 3 16

補充

unsafe.Sizeof(a) 返回 a 類型在內存中佔用的字節數。對於字符串類型,unsafe.Sizeof() 返回的是指向字符串的內部結構的大小,而不是字符串內容的大小。

在 Go 中,字符串是一個包含兩個字段的構造體:

  1. 指針:指向字符串內容的內存地址。
  2. 長度:表示字符串內容的長度(以字節為單位)。

對於一個字符串類型,該構造體通常佔用 16 字節(在 64 位系統上)。具體來說:

  • 指針:8 字節(在 64 位系統上)
  • 長度:8 字節(在 64 位系統上)

因此,字符串的總大小為 8 + 8 = 16 字節。

iota#

iota 是一個特殊常量,可以認為是一個可以被編譯器修改的常量,只能出現在 const 中。可以在常量聲明中用於生成一系列相關的常量值。

iota 在 const 關鍵字出現時將被重置為 0 (const 內部的第一行之前),const 中每新增一行常量聲明將使 iota 計數一次 (iota 可理解為 const 語句塊中的行索引),即 iota=行數-1

iota 可以被用作枚舉值:

const (
    a = iota  // 0
    b = iota  // 1
    c = iota  // 2
)

第一個 iota 等於 0,每當 iota 在新的一行被使用時,它的值都會自動加 1;所以 a=0, b=1, c=2 可以簡寫為如下形式:

const (
    a = iota
    b
    c
)

注意iota 是按遞增的,因此只要是同一行的,iota 就相同。並且接下來的 iota 公式都應該與上方最近的公式一致。比如:

const (
    a, b = iota + 1, iota + 2  // iota=0  a=1  b=2
    c, d  // iota=1  c=iota+1  d=iota+2
    e, f = iota * 2, iota * 3  // iota=2  e=4  f=6
    g, h  // iota=3  g=iota*2  f=iota*3
)

iota 用法

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //獨立值,iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢復計數
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

// 輸出結果
0 1 2 ha ha 100 100 7 8

在 Go 中,常量聲明中連續的未顯式賦值常量會取前一個常量的值。e 沒有顯式賦值,因此它會繼承前一個常量 d 的值(即 "ha")。同理,g 沒有顯式賦值,因此它會繼承前一個常量 f 的值(即 100)。

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

// 輸出結果
i= 1
j= 6
k= 12
l= 24

在上面這個實例中,iota 表示從 0 開始自動加 1,所以 i=1<<0j=3<<1<< 表示左移的意思,即 <<n==*(2^n)),因此 i=1j=6k=12l=24

  • i=1:左移 0 位,不變仍為 1。
  • j=3:左移 1 位,變為二進制 110,即 6。
  • k=3:左移 2 位,變為二進制 1100,即 12。
  • l=3:左移 3 位,變為二進制 11000,即 24。

參考課程:

  1. 8 小時轉職 Golang 工程師
  2. Go 語言教程 | 菜鳥教程
載入中......
此文章數據所有權由區塊鏈加密技術和智能合約保障僅歸創作者所有。