v_name := value
// 例如
var a int = 10
var b = 10
c : = 10
執行個體如下：
package main
var a = "w3cschool菜鳥教程"
var b string = "w3cschool.cc"
var c bool
func main(){
println(a, b, c)
}
以上執行個體執行結果為：
w3cschool菜鳥教程 w3cschool.cc false
多變量聲明
//類型相同多個變量, 非全局變量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要顯示聲明類型，自動推斷
vname1, vname2, vname3 := v1, v2, v3 //出現在:=左側的變量不應該是已經被聲明過的，否則會導緻編譯錯誤
// 這種因式分解關鍵字的寫法一般用于聲明全局變量
var (
vname1 v_type1
vname2 v_type2
)
package main
var x, y int
var ( // 這種因式分解關鍵字的寫法一般用于聲明全局變量
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//這種不帶聲明格式的隻能在函數體中出現
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
}
func main() {
var a string = "abc"
fmt.Println("hello, world")
}
嘗試編譯這段代碼将得到錯誤 a declared and not used。
此外，單純地給 a 指派也是不夠的，這個值必須被使用，是以使用
fmt.Println("hello, world", a)
會移除錯誤。
但是全局變量是允許聲明但不使用。
>
同一類型的多個變量可以聲明在同一行，如：
var a, b, c int
多變量可以在同一行進行指派，如：
a, b, c = 5, 7, "abc"
上面這行假設了變量 a，b 和 c 都已經被聲明，否則的話應該這樣使用：
a, b, c := 5, 7, "abc"
右邊的這些值以相同的順序指派給左邊的變量，是以 a 的值是 5， b 的值是 7，c 的值是 "abc"。
這被稱為 并行 或 同時 指派。
如果你想要交換兩個變量的值，則可以簡單地使用 a, b = b, a。
空白辨別符 _ 也被用于抛棄值，如值 5 在：_, b = 5, 7 中被抛棄。
_ 實際上是一個隻寫變量，你不能得到它的值。這樣做是因為 Go 語言中你必須使用所有被聲明的變量，但有時你并不需要使用從一個函數得到的所有傳回值。
并行指派也被用于當一個函數傳回多個傳回值時，比如這裡的 val 和錯誤 err 是通過調用 Func1 函數同時得到：val, err = Func1(var1)。
Go 語言常量
常量是一個簡單值的辨別符，在程式運作時，不會被修改的量。
常量中的資料類型隻可以是布爾型、數字型（整數型、浮點型和複數）和字元串型。
常量的定義格式：
const identifier [type] = value
你可以省略類型說明符 [type]，因為編譯器可以根據變量的值來推斷其類型。
顯式類型定義：
const b string = "abc"
隐式類型定義：
const b = "abc"
多個相同類型的聲明可以簡寫為：
const c_name1, c_name2 = value1, value2
以下執行個體示範了常量的應用：
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str" //多重指派
area = LENGTH * WIDTH
fmt.Printf("面積為 : %d", area)
println()
println(a, b, c)
}
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
再看個有趣的的 iota 執行個體：
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)
}
package main
import "fmt"
func main() {
var a int = 21
var b int = 10
var c int
c = a + b
fmt.Printf("第一行 - c 的值為 %d\n", c )
c = a - b
fmt.Printf("第二行 - c 的值為 %d\n", c )
c = a * b
fmt.Printf("第三行 - c 的值為 %d\n", c )
c = a / b
fmt.Printf("第四行 - c 的值為 %d\n", c )
c = a % b
fmt.Printf("第五行 - c 的值為 %d\n", c )
a++
fmt.Printf("第六行 - c 的值為 %d\n", a )
a--
fmt.Printf("第七行 - c 的值為 %d\n", a )
}
以上執行個體運作結果：
第一行 - c 的值為 31
第二行 - c 的值為 11
第三行 - c 的值為 210
第四行 - c 的值為 2
第五行 - c 的值為 1
第六行 - c 的值為 22
第七行 - c 的值為 21
下表列出了所有Go語言的關系運算符。假定 A 值為 10，B 值為 20。
==
檢查兩個值是否相等，如果相等傳回 True 否則傳回 False。
(A == B) 為 False
!=
檢查兩個值是否不相等，如果不相等傳回 True 否則傳回 False。
(A != B) 為 True
檢查左邊值是否大于右邊值，如果是傳回 True 否則傳回 False。
(A > B) 為 False
<
檢查左邊值是否小于右邊值，如果是傳回 True 否則傳回 False。
(A < B) 為 True
>=
檢查左邊值是否大于等于右邊值，如果是傳回 True 否則傳回 False。
(A >= B) 為 False
<=
檢查左邊值是否小于等于右邊值，如果是傳回 True 否則傳回 False。
(A <= B) 為 True
以下執行個體示範了關系運算符的用法：
package main
import "fmt"
func main() {
var a int = 21
var b int = 10
if( a == b ) {
fmt.Printf("第一行 - a 等于 b\n" )
} else {
fmt.Printf("第一行 - a 不等于 b\n" )
}
if ( a < b ) {
fmt.Printf("第二行 - a 小于 b\n" )
} else {
fmt.Printf("第二行 - a 不小于 b\n" )
}
if ( a > b ) {
fmt.Printf("第三行 - a 大于 b\n" )
} else {
fmt.Printf("第三行 - a 不大于 b\n" )
}
/* Lets change value of a and b */
a = 5
b = 20
if ( a <= b ) {
fmt.Printf("第四行 - a 小于等于 b\n" )
}
if ( b >= a ) {
fmt.Printf("第五行 - b 大于等于 b\n" )
}
}
第一行 - a 不等于 b
第二行 - a 不小于 b
第三行 - a 大于 b
第四行 - a 小于等于 b
第五行 - b 大于等于 b
下表列出了所有Go語言的邏輯運算符。假定 A 值為 True，B 值為 False。
&&
邏輯 AND 運算符。 如果兩邊的操作數都是 True，則條件 True，否則為 False。
(A && B) 為 False
||
邏輯 OR 運算符。 如果兩邊的操作數有一個 True，則條件 True，否則為 False。
(A || B) 為 True
!
邏輯 NOT 運算符。 如果條件為 True，則邏輯 NOT 條件 False，否則為 True。
!(A && B) 為 True
以下執行個體示範了邏輯運算符的用法：
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
if ( a && b ) {
fmt.Printf("第一行 - 條件為 true\n" )
}
if ( a || b ) {
fmt.Printf("第二行 - 條件為 true\n" )
}
/* 修改 a 和 b 的值 */
a = false
b = true
if ( a && b ) {
fmt.Printf("第三行 - 條件為 true\n" )
} else {
fmt.Printf("第三行 - 條件為 false\n" )
}
if ( !(a && b) ) {
fmt.Printf("第四行 - 條件為 true\n" )
}
}
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("第一行 - c 的值為 %d\n", c )
c = a | b /* 61 = 0011 1101 */
fmt.Printf("第二行 - c 的值為 %d\n", c )
c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("第三行 - c 的值為 %d\n", c )
c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("第四行 - c 的值為 %d\n", c )
c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf("第五行 - c 的值為 %d\n", c )
}
第一行 - c 的值為 12
第二行 - c 的值為 61
第三行 - c 的值為 49
第四行 - c 的值為 240
第五行 - c 的值為 15
下表列出了所有Go語言的指派運算符。
=
簡單的指派運算符，将一個表達式的值賦給一個左值
C = A + B 将 A + B 表達式結果指派給 C
+=
相加後再指派
C += A 等于 C = C + A
-=
相減後再指派
C -= A 等于 C = C - A
*=
相乘後再指派
C *= A 等于 C = C * A
/=
相除後再指派
C /= A 等于 C = C / A
%=
求餘後再指派
C %= A 等于 C = C % A
<<=
左移指派
C <<= 2 等于 C = C << 2
>>=
右移指派
C >>= 2 等于 C = C >> 2
&=
位邏輯與指派
C &= 2 等于 C = C & 2
^=
位邏輯或指派
C ^= 2 等于 C = C ^ 2
|=
位邏輯異或指派
C |= 2 等于 C = C | 2
以下執行個體示範了指派運算符的用法：
package main
import "fmt"
func main() {
var a int = 21
var c int
c = a
fmt.Printf("第 1 行 - = 運算符執行個體，c 值為 = %d\n", c )
c += a
fmt.Printf("第 2 行 - += 運算符執行個體，c 值為 = %d\n", c )
c -= a
fmt.Printf("第 3 行 - -= 運算符執行個體，c 值為 = %d\n", c )
c *= a
fmt.Printf("第 4 行 - *= 運算符執行個體，c 值為 = %d\n", c )
c /= a
fmt.Printf("第 5 行 - /= 運算符執行個體，c 值為 = %d\n", c )
c = 200;
c <<= 2
fmt.Printf("第 6行 - <<= 運算符執行個體，c 值為 = %d\n", c )
c >>= 2
fmt.Printf("第 7 行 - >>= 運算符執行個體，c 值為 = %d\n", c )
c &= 2
fmt.Printf("第 8 行 - &= 運算符執行個體，c 值為 = %d\n", c )
c ^= 2
fmt.Printf("第 9 行 - ^= 運算符執行個體，c 值為 = %d\n", c )
c |= 2
fmt.Printf("第 10 行 - |= 運算符執行個體，c 值為 = %d\n", c )
}
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("(a + b) * c / d 的值為 : %d\n", e );
e = ((a + b) * c) / d; // (30 * 15 ) / 5
fmt.Printf("((a + b) * c) / d 的值為 : %d\n" , e );
e = (a + b) * (c / d); // (30) * (15/5)
fmt.Printf("(a + b) * (c / d) 的值為 : %d\n", e );
e = a + (b * c) / d; // 20 + (150/5)
fmt.Printf("a + (b * c) / d 的值為 : %d\n" , e );
}
(a + b) * c / d 的值為 : 90
((a + b) * c) / d 的值為 : 90
(a + b) * (c / d) 的值為 : 90
a + (b * c) / d 的值為 : 50
package main
import "fmt"
func main() {
/* 定義局部變量 */
var a int = 100
var b int = 200
/* 判斷條件 */
if a == 100 {
/* if 條件語句為 true 執行 */
if b == 200 {
/* if 條件語句為 true 執行 */
fmt.Printf("a 的值為 100 ， b 的值為 200\n" );
}
}
fmt.Printf("a 值為 : %d\n", a );
fmt.Printf("b 值為 : %d\n", b );
}
a 的值為 100 ， b 的值為 200
a 值為 : 100
b 值為 : 200
Go 語言 switch 語句
switch 語句用于基于不同條件執行不同動作，每一個 case 分支都是唯一的，從上直下逐一測試，直到比對為止。。
switch 語句執行的過程從上至下，直到找到比對項，比對項後面也不需要再加break
Go 程式設計語言中 switch 語句的文法如下：
switch var1 {
case val1:
...
case val2:
...
default:
...
}
switch x.(type){
case type:
statement(s);
case type:
statement(s);
/* 你可以定義任意個數的case */
default: /* 可選 */
statement(s);
}
package main
import "fmt"
func main() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" x 的類型 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Printf("未知型")
}
}
package main
import "fmt"
func main() {
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")
case c2 <- i2:
fmt.Printf("sent ", i2, " to c2\n")
case i3, ok := (<-c3): // same as: i3, ok := <-c3
if ok {
fmt.Printf("received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Printf("no communication\n")
}
}
