Golang 系列教程：5 常量

demo04/demo04-08.go

@@ -5,8 +5,6 @@ import (
 )
 
 func main() {  
-    i := 55      //int
-    j := 67.8    //float64
-    sum := i + int(j) //j is converted to int
-    fmt.Println(sum)
+    var a = 5.9/8
+    fmt.Printf("a's type %T value %v",a, a)
 }

docs/golang_tutorial_01.md

@@ -1,4 +1,4 @@
-介绍和安装
+1 - 介绍和安装
 ========================
 
 简介：本课程非常重要。

docs/golang_tutorial_02.md

@@ -1,4 +1,4 @@
-Hello World
+2 - Hello World
 ========================
 
 这是本Golang系列教程的第二篇。你可以阅读 Golang 系列教程 第 1 部分：[介绍和安装](/docs/golang_tutoria_01.md) 来了解什么是Golang以及如何安装它。  

docs/golang_tutorial_03.md

@@ -1,4 +1,4 @@
-变量
+3 - 变量
 ========================
 
 这是本Golang系列教程的第三篇。你可以阅读 Golang 系列教程 第 2 部分：[Hello World](/docs/golang_tutoria_02.md) 。学习如何配置 Golang，并运行 Hello World 程序  
@@ -188,7 +188,7 @@ func main() {
 
 ```golang
 my name is naveen , age is 29 and height is 0
-```  
+```
 
 ## 简短声明  
 
@@ -206,13 +206,13 @@ func main() {
 
     fmt.Println("my name is", name, "age is", age)
 }
-```  
+```
 
 运行上面的程序，输出如下：  
 
 ```golang
 my name is naveen age is 29
-```  
+```
 
 简短声明要求 ` := ` 操作符左边的所有变量都有初始值。下面程序将会抛出错误 `cannot assign 1 values to 2 variables`，这是因为 age 没有被赋值。  
 
@@ -226,7 +226,7 @@ func main() {
 
     fmt.Println("my name is", name, "age is", age)
 }
-```  
+```
 
 简短声明的语法要求 `:= `操作符的左边至少有一个变量是尚未声明的。考虑下面的程序：  
 
@@ -245,7 +245,7 @@ func main() {
     b, c = 80, 90 // 给已经声明的变量b和c赋新值
     fmt.Println("changed b is", b, "c is", c)
 }
-```   
+```
 
 上面的程序中，在 `b, c := 40, 50 ` 这一行，虽然变量 b 在之前已经被声明了，但是 c 却是新声明的变量，**因此这是合法的**。该程序的输出为：    
 
@@ -253,7 +253,7 @@ func main() {
 a is 20 b is 30  
 b is 40 c is 50  
 changed b is 80 c is 90 
-```  
+```
 
 但是当我们运行下面的程序  
 
@@ -267,7 +267,7 @@ func main() {
     fmt.Println("a is", a, "b is", b)
     a, b := 40, 50 //error, no new variables
 }
-```  
+```
 
 将会报错：`no new variables on left side of :=` 。这是因为变量 a 和变量 b 都是已经声明过的变量，在` :=` 左侧并没有新的变量被声明。（重要）  
 
@@ -288,7 +288,7 @@ func main() {
     c := math.Min(a, b) // 运行时产生的值
     fmt.Println("minimum value is ", c)
 }
-```  
+```
 
 在上面的程序中， c 的值为 a 和 b 的最小值，该值是在运行时计算的。  
 

docs/golang_tutorial_04.md

@@ -1,4 +1,4 @@
-（四）类型
+4 - 类型
 ========================
 
 这是本Golang系列教程的第四篇。你可以阅读 Golang 系列教程 第 3 部分：[变量](/docs/golang_tutoria_03.md) 。来学习有关变量的知识。  
@@ -230,7 +230,7 @@ func main() {
 ```golang
 sum: (13+34i)
 mul : (-149+191i)
-```  
+```
 
 ##  其他数字类型  
 
@@ -256,7 +256,7 @@ func main() {
     name := first +" "+ last
     fmt.Println("My name is",name)
 }
-```  
+```
 
 上面程序中，first 赋值为字符串 "Naveen"，last 赋值为字符串 "Ramanathan"。+ 操作符可以用于拼接字符串。我们拼接了 first、空格和 last，并将其赋值给 name。  
 
@@ -264,7 +264,7 @@ func main() {
 
 ```golang
 My name is Wan ShaoBo
-```  
+```
 
 还有许多应用于字符串上面的操作，我们将会在一个单独的教程里看见它们。  
 
@@ -285,14 +285,14 @@ func main() {
     sum := i + j //不允许 int + float64
     fmt.Println(sum)
 }
-```  
+```
 
 上面的代码在 C 语言中是完全合法的，然而在 Go 中，却是行不通的。i 的类型是 int ，而 j 的类型是 float64 ，我们正试图把两个不同类型的数相加，Go 不允许这样的操作。如果运行程序，你会得到   
 
 ```golang
 # command-line-arguments
 demo04\demo04-07.go:10:14: invalid operation: i + j (mismatched types int and float64)
-```  
+```
 
 要修复这个错误，i 和 j 应该是相同的类型。在这里，我们把 j 转换为 int 类型。把 v 转换为 T 类型的语法是 T(v)。  
 
@@ -309,13 +309,13 @@ func main() {
     sum := i + int(j) //j is converted to int
     fmt.Println(sum)
 }
-```  
+```
 
 现在，当你运行上面的程序时，会看见输出
 
 ```golang
 122
-```  
+```
 
 赋值的情况也是如此。把一个变量赋值给另一个不同类型的变量，需要显式的类型转换。下面程序说明了这一点。  
 
@@ -331,7 +331,7 @@ func main() {
     var j float64 = float64(i) // 若没有显式转换，该语句会报错
     fmt.Println("j", j)
 }
-```  
+```
 
 在第 9 行，i 转换为 float64 类型，接下来赋值给 j。如果不进行类型转换，当你试图把 i 赋值给 j 时，编译器会抛出错误。  
 

docs/golang_tutorial_05.md

@@ -0,0 +1,237 @@
+5 - 常量
+========================
+
+这是本Golang系列教程的第五篇。  
+
+## 定义常量  
+
+常量（constant）表示固定的值，比如：`5，-89，"I love Go"，67.89` 等等。  
+
+考虑如下程序：  
+
+```golang
+var a int = 50  
+var b string = "I love Go"  
+```
+
+上面的程序中，` a `和` b` 分别被赋值为常量 `50` 和` "I love Go"`。关键字 const 用于指示常量，如 `50` 和 `"I love Go"`。在上面的代码中，尽管没有使用关键字 `const` 修饰 `50` 与` "I love Go"`，但它们在Go的内部表示为常量。   
+
+关键字 const 修饰的名字为常量，不能被重新赋予任何值。 因此下面的程序会报错：`cannot assign to a`。  
+
+```golang
+package main
+
+func main() {  
+    const a = 55 //allowed
+    a = 89 //reassignment not allowed
+}
+```
+
+常量的值必须在编译期间确定。因此不能将函数的返回值赋给常量，因为函数调用发生在运行期。  
+```golang
+package main
+
+import (  
+    "fmt"
+    "math"
+)
+
+func main() {  
+    fmt.Println("Hello, playground")
+    var a = math.Sqrt(4)//allowed
+    const b = math.Sqrt(4)//not allowed
+}
+```
+
+在上面的程序中，`a `是一个变量因此可以被赋值为函数` math.Sqrt(4)` 的调用结果。（我们将在单独的教程中更详细的讨论函数）。而 `b `是一个常量，它的值必须在编译期间确定，但是函数 `math.Sqrt(4) `的调用结果只能在运行时被计算出来，因此在编译 `const b = math.Sqrt(4) `时将会报错：  
+
+```golang
+error main.go:11: const initializer math.Sqrt(4) is not a constant.
+```
+
+## 字符串常量  
+
+字符串常量最简单的常量，通过了解字符串常量可以更好的理解常量的概念。  
+
+在Go中任何用双引号括起来的值都是字符串常量，比如 `"Hello World"，"Sam" `都是字符串常量。  
+
+字符串常量是什么类型呢？答案是 无类型**untyped**。  
+
+**像 "Hello World" 这样的字符串没有任何类型。**  
+
+```golang
+const hello = "Hello World"  
+```
+
+上面的代码将 "Hello World" 赋给一个名为 hello 的常量。那么现在常量** hello** 是不是就有了类型？答案是：No。hello 仍然没有类型。 
+
+Go是一种强类型语言。 所有变量都需要显式类型。 变量 `name` 被赋值为一个无类型的常量 `"Sam"`，它是如何工作的呢？  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    var name = "Sam"
+    fmt.Printf("type %T value %v", name, name)
+
+}
+```
+
+答案是无类型常量有一个默认的类型，当且仅当代码中需要无类型常量提供类型时，它才会提供该默认类型。在语句 `var name = "Sam" `中，`name`需要一个类型，因此它从常量 "Sam" 中获取其默认类型：`string`。  
+
+<u>（译者注：这里可以理解为常量是无类型的，但是在需要类型的场合，编译器会根据常量的值和上下文将常量转换为相应的类型。）</u>
+
+有没有办法创建一个有类型（typed）的常量？答案是：Yes。下面的代码创建了一个有类型常量。  
+```golang
+const typedhello string = "Hello World" 
+```
+
+上面的代码中， `typedhello` 是一个字符串类型的常量。  
+
+Go是强类型语言。在赋值时混合使用类型是不允许的。让我们通过以下代码说明这是什么意思。  
+
+```golang
+package main
+
+func main() {  
+    var defaultName = "Sam" //allowed
+    type myString string
+    var customName myString = "Sam" //allowed
+    customName = defaultName //not allowed
+}
+```
+
+在上面的代码中，我们首先创建了一个变量 `defaultName` 并且赋值为常量 `"Sam"`。常量 `"Sam"` 的默认类型为 `string`，因此赋值之后，`defaultName` 的类型亦为`string`。  
+
+下一行我们创建了一个新的类型 `myString`，它是 `string` 的别名。  
+
+<u>（译者注：可以通过 type NewType Type 的语法来创建一个新的类型。类似 C 语言的 typedef 。）</u>  
+
+接着我们创建了一个名为 `customName` 的 `myString` 类型的变量，并将常量 `"Sam"` 赋给它。因为常量 `"Sam"` 是无类型的所以可以将它赋值给任何字符串变量。因此这个赋值是合法的，`customName` 的类型是 `myString`。  
+
+现在我们有两个变量：string 类型的 `defaultName` 和 `myString` 类型的 `customName`。尽管我们知道 `myString` 是 string 的一个别名，但是Go的强类型机制不允许将一个类型的变量赋值给另一个类型的变量。<u>**因此，customName = defaultName 这个赋值是不允许的，编译器会报错：main.go:10: cannot use defaultName (type string) as type myString in assignment  **</u>   
+
+## 布尔常量  
+
+布尔常量与字符串常量（在概念上）没有区别。布尔常量只包含两个值：`true` 和 `false`。字符串常量的规则也同样适用于布尔常量，这里不再赘述。下面的代码解释了布尔常量：  
+
+```golang
+package main
+
+func main() {  
+    const trueConst = true
+    type myBool bool
+    var defaultBool = trueConst //allowed
+    var customBool myBool = trueConst //allowed
+    defaultBool = customBool //not allowed
+}
+```
+
+上面的程序很好理解，这里就不过多解释了。  
+
+## 数值常量  
+
+数值常量（Numeric constants）包括整数，浮点数以及复数常量。数值常量有一些微妙之处。  
+
+让我们看一些例子使事情变得明朗。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    fmt.Println("Hello, playground")
+    const a = 5
+    var intVar int = a
+    var int32Var int32 = a
+    var float64Var float64 = a
+    var complex64Var complex64 = a
+    fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
+}
+```
+
+上面的程序中，`const a `是无类型的，值为` 5`。你也许想知道` a` 的默认类型是什么？如果它有默认类型，那么它是怎么赋值给其他类型的变量的？ 答案在于使用 `a` 时的上下文。我们暂时放下这两个问题，先来看下面的程序：  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    fmt.Println("Hello, playground")
+    var i = 5
+    var f = 5.6
+    var c = 5 + 6i
+    fmt.Printf("i's type %T, f's type %T, c's type %T", i, f, c)
+}
+```
+
+在上面的程序中，所有变量的类型都是由数值常量决定的。在语法上看，`5` 在是一个整数，`5.6 `是一个浮点数，` 5 + 6i `是一个复数。运行上面的程序，输出为：`i's type int, f's type float64, c's type complex128`  
+
+<u>（译者注：编译器可以根据字面值常量的表现形式来确定它的默认类型，比如 5.6 表现为浮点数，因此它的默认类型为 float64 ，而 "Sam" 表现为字符串，因此它的默认类型为 stirng。）</u>  
+
+现在应该很清楚下面的程序是如何工作的了：  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    fmt.Println("Hello, playground")
+    const a = 5
+    var intVar int = a
+    var int32Var int32 = a
+    var float64Var float64 = a
+    var complex64Var complex64 = a
+    fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
+}
+```
+
+在这个程序中，`a` 的值是 `5` 并且 `a` 在语法上是泛化的（它既可以表示浮点数 `5.0`，也可以表示整数 `5`，甚至可以表示没有虚部的复数 `5 + 0i`），因此 `a` 可以赋值给任何与之类型兼容的变量。像 `a` 这种数值常量的默认类型可以想象成是通过上下文动态生成的。`var intVar int = a` 要求 `a` 是一个 `int`，那么 `a` 就变成一个` int` 常量。`var complex64Var complex64 = a` 要求 `a` 是一个 `complex64`，那么 `a` 就变成一个 `complex64` 常量。这很容易理解。   
+
+以上程序打印结果：
+
+```golang
+Hello, playground
+intVar 5
+int32Var 5
+float64Var 5
+complex64Var (5+0i)
+```
+
+## 数值表达式  
+
+数值常量可以在表达式中自由的混合和匹配，仅当将它们赋值给变量或者在代码中明确需要类型的时候，才需要他们的类型。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    var a = 5.9/8
+    fmt.Printf("a's type %T value %v",a, a)
+}
+```
+
+在上面的程序中，语法上 `5.9` 是一个浮点数，`8` 是一个整数。因为它们都是数值常量，因此 `5.9/8` 是合法的。相除的结果为 `0.7375`，是一个浮点数。因此变量 `a` 的类型为浮点型。  
+
+上面的程序输出为：     
+
+```golang
+a's type float64 value 0.7375
+```