Part5

示例：

package main

import (
	"fmt"
)

func main() {
	// 重點1的示例。
	var srcInt = int16(-255)
	// 請注意，之所以要執行uint16(srcInt)，是因爲只有這樣才能得到全二進制的表示。
	// 例如，fmt.Printf("%b", srcInt)將打印出"-11111111"，後者是負數符號再加上srcInt的絕對值的補碼。
	// 而fmt.Printf("%b", uint16(srcInt))纔會打印出srcInt原值的補碼"1111111100000001"。
	fmt.Printf("The complement of srcInt: %b (%b)\n",
		uint16(srcInt), srcInt)
	dstInt := int8(srcInt)
	fmt.Printf("The complement of dstInt: %b (%b)\n",
		uint8(dstInt), dstInt)
	fmt.Printf("The value of dstInt: %d\n", dstInt)
	fmt.Println()

	// 重點2的示例。
	fmt.Printf("The Replacement Character: %s\n", string(-1))
	fmt.Printf("The Unicode codepoint of Replacement Character: %U\n", '�')
	fmt.Println()

	// 重點3的示例。
	srcStr := "你好"
	fmt.Printf("The string: %q\n", srcStr)
	fmt.Printf("The hex of %q: %x\n", srcStr, srcStr)
	fmt.Printf("The byte slice of %q: % x\n", srcStr, []byte(srcStr))
	fmt.Printf("The string: %q\n", string([]byte{'\xe4', '\xbd', '\xa0', '\xe5', '\xa5', '\xbd'}))
	fmt.Printf("The rune slice of %q: %U\n", srcStr, []rune(srcStr))
	fmt.Printf("The string: %q\n", string([]rune{'\u4F60', '\u597D'}))
}

package main

import "fmt"

func main() {
	// 示例1。
	{
		type MyString = string
		str := "BCD"
		myStr1 := MyString(str)
		myStr2 := MyString("A" + str)
		fmt.Printf("%T(%q) == %T(%q): %v\n",
			str, str, myStr1, myStr1, str == myStr1)
		fmt.Printf("%T(%q) > %T(%q): %v\n",
			str, str, myStr2, myStr2, str > myStr2)
		fmt.Printf("Type %T is the same as type %T.\n", myStr1, str)

		strs := []string{"E", "F", "G"}
		myStrs := []MyString(strs)
		fmt.Printf("A value of type []MyString: %T(%q)\n",
			myStrs, myStrs)
		fmt.Printf("Type %T is the same as type %T.\n", myStrs, strs)
		fmt.Println()
	}
	// 示例2。
	{
		type MyString string
		str := "BCD"
		myStr1 := MyString(str)
		myStr2 := MyString("A" + str)
		_ = myStr2
		//fmt.Printf("%T(%q) == %T(%q): %v\n",
		//	str, str, myStr1, myStr1, str == myStr1) // 這裏的判等不合法，會引發編譯錯誤。
		//fmt.Printf("%T(%q) > %T(%q): %v\n",
		//	str, str, myStr2, myStr2, str > myStr2) // 這裏的比較不合法，會引發編譯錯誤。
		fmt.Printf("Type %T is different from type %T.\n", myStr1, str)

		strs := []string{"E", "F", "G"}
		var myStrs []MyString
		//myStrs := []MyString(strs) // 這裏的類型轉換不合法，會引發編譯錯誤。
		//fmt.Printf("A value of type []MyString: %T(%q)\n",
		//	myStrs, myStrs)
		fmt.Printf("Type %T is different from type %T.\n", myStrs, strs)
		fmt.Println()
	}
	// 示例3。
	{
		type MyString1 = string
		type MyString2 string
		str := "BCD"
		myStr1 := MyString1(str)
		myStr2 := MyString2(str)
		myStr1 = MyString1(myStr2)
		myStr2 = MyString2(myStr1)

		myStr1 = str
		//myStr2 = str // 這裏的賦值不合法，會引發編譯錯誤。
		//myStr1 = myStr2 // 這裏的賦值不合法，會引發編譯錯誤。
		//myStr2 = myStr1 // 這裏的賦值不合法，會引發編譯錯誤。
	}
}

go語言的模塊的嵌套和查找規則

1.在自己的代碼塊內查找
2.從包含自己代碼塊的父代碼塊中查找
3.一直到當前的代碼包代表的代碼塊中

Note：如果import . package    用這種引用方式，那麼就相當於把package下面的函數視爲當前的包下面的代碼，也需要查找。

思考題

如果我們在go語言查找標識符範圍的時候，用了import . XXXX這種導入方式，如果xxxx和我們的代碼包中有變量重複，那麼GO會把它當作可重名變量還是衝突？

如果導入的包裏面的變量是私有的，也就是小寫開頭的，那麼就不存在重複，但如果是public的，而且是全局的變量那麼就會有衝突。但如果是在子模塊內，那就不會衝突了。

package main

import . "fmt"

var container = []string{"ZERO", "ONE", "TWO"}

func main() {
    container := map[int]string{0: "zero", 1: "one", 2: "two"}
    Println(container[0], container[1], container[2])
}