Go - 開篇

Go語言是Robert Griesemer，Rob Pike和Ken Thompson于2007年在Google最初開發(fā)的一種編程語言卖子。它是一種靜態(tài)類型的語言已慢，具有與C相似的語法入挣。它提供了垃圾回收移宅，類型安全，動態(tài)鍵入功能以及許多高級內(nèi)置類型泡徙，例如可變長度數(shù)組和鍵值映射橱鹏。它還提供了豐富的標(biāo)準(zhǔn)庫。Go編程語言于2009年11月發(fā)布，并在Google的某些生產(chǎn)系統(tǒng)中使用莉兰。

適合人群

本教程是為需要從頭了解Go編程語言的軟件程序員設(shè)計的挑围。本教程將使您對Go編程語言有足夠的了解，從那里您可以進入更高的專業(yè)知識水平糖荒。

先決條件

在繼續(xù)本教程之前杉辙，您應(yīng)該對計算機編程術(shù)語有基本的了解。如果您對C有很好的命令寂嘉，那么您很容易理解Go編程的概念并在學(xué)習(xí)道路上快速前進奏瞬。

Go - 概述

Go是一種通用語言枫绅，設(shè)計時考慮了系統(tǒng)編程泉孩。它最初由Robert Griesemer，Rob Pike和Ken Thompson于2007年在Google開發(fā)并淋。它是強類型和靜態(tài)類型的寓搬，為垃圾回收提供內(nèi)置支持，并支持并發(fā)編程县耽。

程序是使用軟件包構(gòu)建的句喷，用于高效地管理依賴關(guān)系。Go編程實現(xiàn)使用傳統(tǒng)的編譯和鏈接模型來生成可執(zhí)行二進制文件兔毙。Go編程語言于2009年11月發(fā)布唾琼，已在Google的某些生產(chǎn)系統(tǒng)中使用。

Go編程的特點

下面列出了Go編程的最重要功能-

• 支持類似于動態(tài)語言的環(huán)境采用模式澎剥。例如锡溯，類型推斷（x：= 0是int類型的變量x的有效聲明）

• 編譯時間很快。

• 內(nèi)置的并發(fā)支持：輕量級進程（通過go例程）哑姚，通道祭饭，select語句。

• Go程序簡單叙量，簡潔倡蝙，安全。

• 支持接口和類型嵌入绞佩。

• 產(chǎn)生靜態(tài)鏈接的本機二進制文件寺鸥，而無需外部依賴。

有意排除的功能

為了使語言簡潔明了品山，Go中省略了其他類似語言中常見的以下功能-

• 支持類型繼承

• 支持方法或運算符重載

• 支持包之間的循環(huán)依賴

• 支持指針運算

• 支持斷言

• 支持通用編程

Go程序

Go程序的長度可以從3行到數(shù)百萬行不等眼坏，應(yīng)將其寫入一個或多個擴展名為“ .go”的文本文件中。例如，hello.go。

您可以使用“ vi”，“ vim”或任何其他文本編輯器將Go程序?qū)懭胛募?/p>

Go - 環(huán)境設(shè)置

本地環(huán)境設(shè)置

如果您仍然愿意為Go編程語言設(shè)置環(huán)境，則需要在計算機上使用以下兩個軟件-

• 文字編輯器
• 去編譯器

文本編輯器

您將需要文本編輯器來鍵入程序。文本編輯器的示例包括Windows記事本萌腿，OS Edit命令，Brief鼎俘，Epsilon怔揩，EMACS和vim或vi。

文本編輯器的名稱和版本在不同的操作系統(tǒng)上可能會有所不同。例如，在Windows上使用記事本闸溃，在Windows以及Linux或UNIX上使用vim或vi辉川。

使用文本編輯器創(chuàng)建的文件稱為源文件拴测。它們包含程序源代碼。Go程序的源文件通常以擴展名“ .go”命名寸齐。

在開始編程之前欲诺，請確保已安裝文本編輯器扰法，并且您有足夠的經(jīng)驗來編寫計算機程序祠锣，將其保存在文件中蓬推，進行編譯并最終執(zhí)行它。

Go編譯器

編寫在源文件中的源代碼是程序的可讀源澡腾。需要對其進行編譯并轉(zhuǎn)換為機器語言沸伏，以便您的CPU可以根據(jù)給出的指令實際執(zhí)行該程序。Go編程語言編譯器將源代碼編譯成最終的可執(zhí)行程序动分。

Go發(fā)行版是針對FreeBSD（版本8及更高版本）毅糟，Linux，Mac OS X（Snow Leopard及更高版本）以及具有32位（386）和64位（amd64）x86處理器體系結(jié)構(gòu)的Windows操作系統(tǒng)的二進制可安裝版本澜公。

以下部分說明了如何在各種OS上安裝Go二進制發(fā)行版姆另。

下載Go存檔

從Go Downloads下載最新版本的Go可安裝存檔文件。本教程使用以下版本：go1.4.windows-amd64.msi。

它被復(fù)制到C：> go文件夾中迹辐。

在UNIX / Linux / Mac OS X和FreeBSD上安裝

將下載檔案解壓縮到/ usr / local文件夾中苟蹈，在/ usr / local / go中創(chuàng)建Go樹。例如-

tar -C / usr / local -xzf go1.4.linux-amd64.tar.gz

將/ usr / local / go / bin添加到PATH環(huán)境變量中右核。

在Windows上安裝

使用MSI文件并按照提示安裝Go工具慧脱。默認情況下，安裝程序使用c：\?? Go中的Go發(fā)行版贺喝。安裝程序應(yīng)在Window的PATH環(huán)境變量中設(shè)置c：\ Go \ bin目錄菱鸥。重新啟動所有打開的命令提示符，以使更改生效躏鱼。

驗證安裝

在C：> Go_WorkSpace中創(chuàng)建一個名為test.go的go文件氮采。

文件：test.go

package main

import "fmt"

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

現(xiàn)在運行test.go以查看結(jié)果-

C:\Go_WorkSpace>go run test.go

Go - 程序結(jié)構(gòu)

在研究Go編程語言的基本構(gòu)建塊之前，讓我們首先討論Go程序的最基本的結(jié)構(gòu)染苛，以便在以后的章節(jié)中作為參考鹊漠。

你好世界的例子

Go程序基本上由以下部分組成-

• 包裝聲明
• 進口包裝
• 功能
• 變數(shù)
• 陳述與表達
• 注釋

讓我們看一個簡單的代碼，該代碼將顯示“ Hello World”字樣-

package main

import "fmt"

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

讓我們看一下上述程序的各個部分-

• 程序包main的第一行定義了該程序應(yīng)位于的包名稱茶行。這是強制性聲明躯概，因為Go程序在程序包中運行。主程序包是運行程序的起點畔师。每個軟件包都有與之關(guān)聯(lián)的路徑和名稱娶靡。

• 下一行導(dǎo)入“ fmt”是一個預(yù)處理程序命令，該命令告訴Go編譯器包括位于fmt包中的文件看锉。

• 下一行func main（）是程序執(zhí)行開始的主要功能姿锭。

• 下一行/.../被編譯器忽略，可以在程序中添加注釋伯铣。注釋也使用//表示呻此，類似于Java或C ++注釋。

• 下一行fmt.Println（...）是Go中可用的另一個函數(shù)腔寡，該函數(shù)導(dǎo)致消息“ Hello焚鲜，World！”蹬蚁。在屏幕上顯示恃泪。在這里，fmt包已導(dǎo)出了Println方法犀斋，該方法用于在屏幕上顯示消息贝乎。

• 注意Println方法的大寫字母P。在Go語言中叽粹，如果名稱以大寫字母開頭览效，則會將其導(dǎo)出却舀。導(dǎo)出意味著相應(yīng)包的導(dǎo)入者可以訪問該函數(shù)或變量/常量。

執(zhí)行圍棋程序

讓我們討論如何將源代碼保存在文件中锤灿，對其進行編譯并最終執(zhí)行該程序挽拔。請按照下面給出的步驟-

• 打開一個文本編輯器并添加上述代碼。

• 將文件另存為hello.go

• 打開命令提示符但校。

• 轉(zhuǎn)到保存文件的目錄螃诅。

• 輸入go run hello.go，然后按Enter鍵運行代碼状囱。

• 如果您的代碼沒有錯誤术裸，那么您將看到“ Hello World！”亭枷。打印在屏幕上袭艺。

$ go run hello.go
Hello, World!

確保Go編譯器在您的路徑中，并且正在包含源文件hello.go的目錄中運行它叨粘。

Go - 基本語法

在上一章中猾编，我們討論了Go程序的基本結(jié)構(gòu)。現(xiàn)在升敲，您將很容易理解Go編程語言的其他基本構(gòu)建塊答倡。

Go中的令牌

Go程序由各種令牌組成。令牌可以是關(guān)鍵字冻晤，標(biāo)識符苇羡，常量绸吸，字符串文字或符號鼻弧。例如，以下Go語句包含六個標(biāo)記-

fmt.Println("Hello, World!")

各個令牌是-

fmt
.
Println
(
   "Hello, World!"
)

分線器

在Go程序中锦茁，行分隔符鍵是語句終止符攘轩。也就是說，單個語句不需要像“;”這樣的特殊分隔符码俩。Go編譯器在內(nèi)部放置“;” 作為表示一個邏輯實體結(jié)束的語句終止符度帮。

例如，看看以下語句-

fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")

注釋

注釋就像幫助Go程序中的文本稿存，編譯器會忽略它們笨篷。它們以/ 開頭并以字符 /結(jié)束，如下所示-

/* my first program in Go */

您不能在注釋中包含注釋瓣履，并且它們也不會出現(xiàn)在字符串或字符文字中率翅。

身份標(biāo)識

Go標(biāo)識符是用于標(biāo)識變量，函數(shù)或任何其他用戶定義項的名稱袖迎。標(biāo)識符以字母A到Z或a到z或下劃線_開頭冕臭，后跟零個或多個字母腺晾，下劃線和數(shù)字（0到9）。

標(biāo)識符=字母{字母| unicode_digit}辜贵。

Go不允許在標(biāo)識符內(nèi)使用標(biāo)點符號悯蝉，例如@，$和％托慨。Go是區(qū)分大小寫的編程語言鼻由。因此，人力和人力是Go中兩個不同的標(biāo)識符厚棵。這是可接受的標(biāo)識符的一些示例-

mahesh      kumar   abc   move_name   a_123
myname50   _temp    j      a23b9      retVal

關(guān)鍵詞

以下列表顯示了Go中的保留字嗡靡。這些保留字不得用作常量或變量或任何其他標(biāo)識符名稱。

Go中的空白

空格是Go語言中用來描述空白窟感，制表符讨彼，換行符和注釋的術(shù)語。僅包含空格的行（可能帶有注釋）被稱為空白行柿祈，而Go編譯器完全忽略它哈误。

空格將語句的一個部分與另一個分開，并使編譯器能夠識別語句中一個元素（例如int）在何處結(jié)束以及下一個元素在何處開始躏嚎。因此蜜自，在以下語句中-

var age int;

int和age之間必須至少有一個空格字符（通常為空格），以便編譯器能夠區(qū)分它們卢佣。另一方面重荠，在以下語句中-

fruit = apples + oranges;   // get the total fruit

水果和=之間，或=和蘋果之間虚茶，不需要空格字符戈鲁，盡管出于可讀性考慮，您可以自由地添加一些字符嘹叫。

Go - 數(shù)據(jù)類型

在Go編程語言中筒溃，數(shù)據(jù)類型是指用于聲明不同類型的變量或函數(shù)的擴展系統(tǒng)刨肃。變量的類型決定了它在存儲中占據(jù)多少空間以及如何解釋所存儲的位模式。

Go中的類型可以分類如下-

數(shù)組類型和結(jié)構(gòu)類型統(tǒng)稱為集合類型帜消。函數(shù)的類型指定具有相同參數(shù)和結(jié)果類型的所有函數(shù)的集合。我們將在下一節(jié)中討論基本類型浓体，而其他類型將在接下來的章節(jié)中介紹泡挺。

整數(shù)類型

預(yù)定義的與體系結(jié)構(gòu)無關(guān)的整數(shù)類型是-

浮動類型

預(yù)定義的與體系結(jié)構(gòu)無關(guān)的浮點類型為-

n位整數(shù)的值是n位，并使用二進制的補碼算術(shù)運算表示命浴。

其他數(shù)值類型

還有一組具有特定于實現(xiàn)的大小的數(shù)字類型-

Go - 變量

變量不過是賦予程序可以操作的存儲區(qū)的名稱。Go中的每個變量都有一個特定的類型生闲，該類型確定變量的內(nèi)存大小和布局媳溺，可以存儲在該內(nèi)存中的值的范圍以及可以應(yīng)用于該變量的一組操作。

變量的名稱可以由字母碍讯，數(shù)字和下劃線字符組成悬蔽。它必須以字母或下劃線開頭。大寫和小寫字母是不同的捉兴，因為Go區(qū)分大小寫蝎困。基于上一章介紹的基本類型倍啥，將有以下基本變量類型-

Go編程語言還允許定義各種其他類型的變量，例如枚舉氮趋，指針伍派，數(shù)組，結(jié)構(gòu)和聯(lián)合凭峡，我們將在后續(xù)章節(jié)中進行討論拙已。在本章中，我們將僅關(guān)注基本變量類型摧冀。

Go中的變量定義

變量定義告訴編譯器在何處以及為變量創(chuàng)建多少存儲空間。變量定義指定一種數(shù)據(jù)類型系宫，并包含一個或多個該類型變量的列表索昂，如下所示：

var variable_list optional_data_type;

在這里，optional_data_type是有效的Go數(shù)據(jù)類型扩借，包括byte椒惨，int，float32潮罪，complex64康谆，boolean或任何用戶定義的對象等领斥，并且variable_list可以包含一個或多個用逗號分隔的標(biāo)識符名稱。一些有效的聲明顯示在這里-

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

語句**“ var i沃暗，j月洛，k;” **聲明并定義變量i，j和k孽锥；它指示編譯器創(chuàng)建名為int的i嚼黔，j和k變量。

變量可以在其聲明中進行初始化（分配初始值）惜辑。變量的類型由編譯器根據(jù)傳遞給它的值自動判斷唬涧。初始化程序由一個等號和一個常量表達式組成，如下所示：

variable_name = value;

例如盛撑，

d = 3, f = 5;    // declaration of d and f. Here d and f are int 

對于沒有初始化程序的定義：具有靜態(tài)存儲持續(xù)時間的變量使用nil隱式初始化（??所有字節(jié)的值均為0）碎节；所有其他變量的初始值為其數(shù)據(jù)類型的零值。

Go中的靜態(tài)類型聲明

靜態(tài)類型變量聲明為編譯器提供了一個保證抵卫，該變量具有給定的類型和名稱钓株，以便編譯器可以繼續(xù)進行進一步的編譯而無需變量的完整細節(jié)。變量聲明僅在編譯時具有其含義陌僵，編譯器在鏈接程序時需要實際的變量聲明轴合。

例

請嘗試以下示例，其中已使用類型聲明變量并在主函數(shù)內(nèi)部對其進行了初始化-

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

Go中的動態(tài)類型聲明/類型推斷

動態(tài)類型變量聲明要求編譯器根據(jù)傳遞給它的值來解釋變量的類型碗短。編譯器不需要變量就具有靜態(tài)類型的必要條件受葛。

例

請嘗試以下示例，其中變量已聲明為沒有任何類型偎谁。注意总滩，在類型推斷的情況下，我們使用：=運算符初始化變量y巡雨，而x使用=運算符初始化闰渔。

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)   
}

Go中的混合變量聲明

可以使用類型推斷一次性聲明不同類型的變量。

例

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
    
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

Go中的左值和右值

Go中有兩種表達式-

• lvalue-引用內(nèi)存位置的表達式稱為“ lvalue”表達式铐望。左值可能顯示為分配的左側(cè)或右側(cè)冈涧。

• rvalue-術(shù)語“右值”是指存儲在內(nèi)存中某個地址處的數(shù)據(jù)值。一個右值是一個不能為其賦值的表達式正蛙，這意味著一個右值可能出現(xiàn)在賦值的右側(cè)而不是左側(cè)督弓。

變量是左值，因此可能出現(xiàn)在賦值的左側(cè)乒验。數(shù)字文字是右值愚隧，因此可能無法賦值并且不能出現(xiàn)在左側(cè)。

以下語句有效-

x = 20.0

以下語句無效锻全。它將產(chǎn)生編譯時錯誤-

10 = 20

Go-常數(shù)

常數(shù)是指程序在執(zhí)行過程中不得更改的固定值狂塘。這些固定值也稱為文字录煤。

常量可以是任何基本數(shù)據(jù)類型，例如整數(shù)常量荞胡，浮點常量妈踊，字符常量或字符串文字。也有枚舉常量硝训。

常量與常規(guī)變量的處理方式相同响委，只不過其值在定義后無法修改。

整數(shù)字面量

整數(shù)文字可以是十進制窖梁，八進制或十六進制常量赘风。前綴指定基數(shù)或基數(shù)：十六進制為0x或0X，八進制為0纵刘，十進制為0邀窃。

整數(shù)文字也可以具有后綴，該后綴是U和L的組合假哎，分別表示無符號和長整數(shù)瞬捕。后綴可以是大寫或小寫，并且可以是任何順序舵抹。

這是整數(shù)文字的一些例子-

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */

以下是各種類型的Integer文字的其他示例-

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

浮點文字

浮點文字具有整數(shù)部分肪虎，小數(shù)點，小數(shù)部分和指數(shù)部分惧蛹。您可以用十進制或指數(shù)形式表示浮點文字扇救。

在使用小數(shù)形式表示時，必須包含小數(shù)點和/或指數(shù)香嗓，并且在使用指數(shù)形式表示時迅腔，必須包含整數(shù)和/或小數(shù)。有符號數(shù)由e或E引入靠娱。

這是浮點文字的一些示例-

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

轉(zhuǎn)義序列

當(dāng)某些字符前面帶有反斜杠時沧烈，它們在Go中將具有特殊含義。這些被稱為轉(zhuǎn)義序列代碼像云，用于表示換行符（\ n）锌雀，制表符（\ t），退格鍵等苫费。在這里汤锨，您可以找到其中一些轉(zhuǎn)義序列代碼的列表-

以下示例顯示如何在程序中使用\ t-

package main

import "fmt"

func main() {
   fmt.Printf("Hello\tWorld!")
}

Go中的字符串文字

字符串文字或常量用雙引號“”括起來。字符串包含與字符文字相似的字符：純字符牍汹，轉(zhuǎn)義序列和通用字符铐维。

您可以使用字符串文字將長行分成多行柬泽，并使用空格分隔它們。

這是字符串文字的一些示例嫁蛇。這三種形式都是相同的字符串锨并。

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

該常量關(guān)鍵字

您可以使用const前綴來聲明具有特定類型的常量，如下所示-

const variable type = value;

以下示例顯示如何使用const關(guān)鍵字-

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int

   area = LENGTH * WIDTH
   fmt.Printf("value of area : %d", area)   
}

請注意睬棚，在CAPITALS中定義常量是一種良好的編程習(xí)慣第煮。

Go - 操作符

運算符是一個符號，告訴編譯器執(zhí)行特定的數(shù)學(xué)或邏輯操作抑党。Go語言包含豐富的內(nèi)置運算符包警，并提供以下類型的運算符-

• 算術(shù)運算符
• 關(guān)系運算符
• 邏輯運算符
• 按位運算符
• 賦值運算符
• 雜項運算符

本教程逐一說明算術(shù)，關(guān)系底靠，邏輯害晦，按位，賦值和其他運算符暑中。

算術(shù)運算符

下表顯示了Go語言支持的所有算術(shù)運算符壹瘟。假設(shè)變量A持有10，變量B持有20鳄逾，則-

package main

import "fmt"

func main() {

   var a int = 21
   var b int = 10
   var c int

   c = a + b
   fmt.Printf("Line 1 - Value of c is %d\n", c )
   
   c = a - b
   fmt.Printf("Line 2 - Value of c is %d\n", c )
   
   c = a * b
   fmt.Printf("Line 3 - Value of c is %d\n", c )
   
   c = a / b
   fmt.Printf("Line 4 - Value of c is %d\n", c )
   
   c = a % b
   fmt.Printf("Line 5 - Value of c is %d\n", c )
   
   a++
   fmt.Printf("Line 6 - Value of a is %d\n", a )
   
   a--
   fmt.Printf("Line 7 - Value of a is %d\n", a )
}

關(guān)系運算符

下表列出了Go語言支持的所有關(guān)系運算符。假設(shè)變量A持有10俄精，變量B持有20询筏，則-

package main

import "fmt"

func main() {
   var a int = 21
   var b int = 10

   if( a == b ) {
      fmt.Printf("Line 1 - a is equal to b\n" )
   } else {
      fmt.Printf("Line 1 - a is not equal to b\n" )
   }
   if ( a < b ) {
      fmt.Printf("Line 2 - a is less than b\n" )
   } else {
      fmt.Printf("Line 2 - a is not less than b\n" )
   } 
   if ( a > b ) {
      fmt.Printf("Line 3 - a is greater than b\n" )
   } else {
      fmt.Printf("Line 3 - a is not greater than b\n" )
   }
   
   /* Lets change value of a and b */
   a = 5
   b = 20
   if ( a <= b ) {
      fmt.Printf("Line 4 - a is either less than or equal to  b\n" )
   }
   if ( b >= a ) {
      fmt.Printf("Line 5 - b is either greater than  or equal to b\n" )
   }
}

邏輯運算符

下表列出了Go語言支持的所有邏輯運算符。假設(shè)變量A保持1未蝌，變量B保持0驮吱，則-

package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false
   if ( a && b ) {
      fmt.Printf("Line 1 - Condition is true\n" )
   }
   if ( a || b ) {
      fmt.Printf("Line 2 - Condition is true\n" )
   }
   
   /* lets change the value of  a and b */
   a = false
   b = true
   if ( a && b ) {
      fmt.Printf("Line 3 - Condition is true\n" )
   } else {
      fmt.Printf("Line 3 - Condition is not true\n" )
   }
   if ( !(a && b) ) {
      fmt.Printf("Line 4 - Condition is true\n" )
   }
}

下表顯示了Go語言支持的所有邏輯運算符。假設(shè)變量A為真甥材，變量B為假盯另，則-

按位運算符

按位運算符對位進行運算并執(zhí)行逐位運算绵患。＆，|和^的真值表如下-

假設(shè)A = 60悟耘；和B =13落蝙。以二進制格式，它們將如下所示-

A = 0011 1100

B = 0000 1101

A＆B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

?A = 1100 0011

下表列出了C語言支持的按位運算符暂幼。假設(shè)變量A保持60筏勒，變量B保持13，則-

package main

import "fmt"

func main() {
   var a uint = 60  /* 60 = 0011 1100 */  
   var b uint = 13  /* 13 = 0000 1101 */
   var c uint = 0          

   c = a & b       /* 12 = 0000 1100 */ 
   fmt.Printf("Line 1 - Value of c is %d\n", c )

   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("Line 2 - Value of c is %d\n", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("Line 3 - Value of c is %d\n", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("Line 4 - Value of c is %d\n", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("Line 5 - Value of c is %d\n", c )
}

賦值運算符

下表列出了Go語言支持的所有賦值運算符-

package main

import "fmt"

func main() {
   var a int = 21
   var c int

   c =  a
   fmt.Printf("Line 1 - =  Operator Example, Value of c = %d\n", c )

   c +=  a
   fmt.Printf("Line 2 - += Operator Example, Value of c = %d\n", c )

   c -=  a
   fmt.Printf("Line 3 - -= Operator Example, Value of c = %d\n", c )

   c *=  a
   fmt.Printf("Line 4 - *= Operator Example, Value of c = %d\n", c )

   c /=  a
   fmt.Printf("Line 5 - /= Operator Example, Value of c = %d\n", c )

   c  = 200; 

   c <<=  2
   fmt.Printf("Line 6 - <<= Operator Example, Value of c = %d\n", c )

   c >>=  2
   fmt.Printf("Line 7 - >>= Operator Example, Value of c = %d\n", c )

   c &=  2
   fmt.Printf("Line 8 - &= Operator Example, Value of c = %d\n", c )

   c ^=  2
   fmt.Printf("Line 9 - ^= Operator Example, Value of c = %d\n", c )

   c |=  2
   fmt.Printf("Line 10 - |= Operator Example, Value of c = %d\n", c )
}

雜項運算符

Go語言還支持其他一些重要的運算符羡榴，包括sizeof和碧查？：。

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* example of type operator */
   fmt.Printf("Line 1 - Type of variable a = %T\n", a );
   fmt.Printf("Line 2 - Type of variable b = %T\n", b );
   fmt.Printf("Line 3 - Type of variable c= %T\n", c );

   /* example of & and * operators */
   ptr = &a /* 'ptr' now contains the address of 'a'*/
   fmt.Printf("value of a is  %d\n", a);
   fmt.Printf("*ptr is %d.\n", *ptr);
}

Go中的運算符優(yōu)先級

運算符優(yōu)先級確定表達式中術(shù)語的分組稻扬。這會影響表達式的求值方式。某些運算符具有更高的優(yōu)先級羊瘩；例如泰佳，乘法運算符的優(yōu)先級高于加法運算符。

例如x = 7 + 3 * 2; 在這里尘吗，x被賦值為13逝她，而不是20，因為運算符*的優(yōu)先級比+高摇予，因此它首先與3 * 2相乘汽绢，然后加到7。

在這里侧戴，優(yōu)先級最高的運算符出現(xiàn)在表格的頂部宁昭，而優(yōu)先級最低的運算符出現(xiàn)在表格的底部。在表達式中酗宋，優(yōu)先級更高的運算符將首先被評估积仗。

package main

import "fmt"

func main() {
   var a int = 20
   var b int = 10
   var c int = 15
   var d int = 5
   var e int;

   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   fmt.Printf("Value of (a + b) * c / d is : %d\n",  e );

   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   fmt.Printf("Value of ((a + b) * c) / d is  : %d\n" ,  e );

   e = (a + b) * (c / d);   // (30) * (15/5)
   fmt.Printf("Value of (a + b) * (c / d) is  : %d\n",  e );

   e = a + (b * c) / d;     //  20 + (150/5)
   fmt.Printf("Value of a + (b * c) / d is  : %d\n" ,  e );  
}