入门篇😀

环境配置

安装Go和GoLand
jetBrains旗下所有产品均可通过教育邮箱(edu.cn)免费获取专业版。

常用快捷键记忆

规则学习

  Go语言变量多重赋值

• 方式一

var a int = 10
var b int = 20
b, a = a, b

• 方式二
  这种方式是使用异或实现的

在计算机刚发明时，内存非常“精贵”。这种变量交换往往是非常奢侈的。于是计算机“大牛”发明了一些算法来避免使用中间变量

var a int = 100
var b int = 200
a = a ^ b
b = b ^ a
a = a ^ b
fmt.Println(a, b)

  反引号书写多行字符串

双引号书写字符串被称为字符串字面量（string literal），这种字面量不能跨行；
多行字符串需要使用反引号`，多用于内嵌源码和内嵌数据；
在反引号中的所有代码不会被编译器识别，而只是作为字符串的一部分。

package main
import "fmt"
func main() {
    var temp string
    temp = `
        x := 10
        y := 20
        z := 30
        fmt.Println(x, "  ", y, "  ", z)
        x, y, z = y, z, x
        fmt.Println(x, "  ", y, "  ", z)
    `
    fmt.Println(temp)
}

  rune定义Unicode字符

使用 fmt.Printf 中的%T动词可以输出变量的实际类型

package main
import "fmt"
func main() {
    var a byte = 'a'
    fmt.Printf("%d %T\n", a, a)
    var b rune = '你'
    fmt.Printf("%d %T\n", b, b)
}

Go语言使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

Unicode 和 ASCII 都是一种字符集，字符集为每个字符分配一个唯一的 ID，我们使用到的所有字符在 Unicode 字符集中都有唯一的一个 ID 对应，例如上面例子中的 a 在 Unicode 与 ASCII 中的编码都是 97。“你”在 Unicode 中的编码为 20320，但是在不同国家的字符集中，“你”的 ID 会不同。而无论任何情况下，Unicode 中的字符的 ID 都是不会变化的。

UTF-8 是编码规则，将 Unicode 中字符的 ID 以某种方式进行编码。UTF-8 的是一种变长编码规则，从 1 到 4 个字节不等。编码规则如下：
0xxxxxx 表示文字符号 0～127，兼容 ASCII 字符集。
从 128 到 0x10ffff 表示其他字符。

根据这个规则，拉丁文语系的字符编码一般情况下，每个字符依然占用一个字节，而中文每个字符占用 3 个字节。

  fmt格式化输出

package main
import "fmt"
func main() {
	str := "steven"
	fmt.Printf("%T, %v \n", str, str)
	var a rune = '一'
	fmt.Printf("%T, %v \n", a, a)
	var b byte = 'b'
	fmt.Printf("%T, %v \n", b, b)
	var c int32 = 98
	fmt.Printf("%T, %v \n", c, c)
	var flag bool
	fmt.Printf("%T, %t \n", flag, flag)
	flag = true
	fmt.Printf("%T, %t \n", flag, flag)
	fmt.Printf("%T, %d \n", 123, 123)
	fmt.Printf("%T, %5d \n", 123, 123)
	fmt.Printf("%T, %05d \n", 123, 123)
	fmt.Printf("%T, %b \n", 123, 123)
	fmt.Printf("%T, %o \n", 123, 123)
	fmt.Printf("%T, %c \n", 97, 97)
	fmt.Printf("%T, %q \n", 97, 97)
	fmt.Printf("%T, %x \n", 123, 123)
	fmt.Printf("%T, %X \n", 123, 123)
	fmt.Printf("%T, %U \n", '一', '一')
	fmt.Printf("%b \n", 123.123456)
	fmt.Printf("%f \n", 123.1)
	fmt.Printf("%.2f \n", 123.125456)
	fmt.Printf("%e \n", 123.123456)
	fmt.Printf("%E \n", 123.123456)
	fmt.Printf("%.1e \n", 123.123456)
	fmt.Printf("%F \n", 123.123456)
	fmt.Printf("%g \n", 123.123456)
	fmt.Printf("%G \n", 123.123456)
	var value complex64 = 2.1 + 12i
	value2 := complex(2.1, 12)
	fmt.Println(real(value))
	fmt.Println(imag(value))
	fmt.Println(value2)
	arr := []byte{'x', 'y', 'z', 'z'}
	fmt.Printf("%s \n", "欢迎访问微学苑")
	fmt.Printf("%q \n", "欢迎访问微学苑")
	fmt.Printf("%x \n", "欢迎访问微学苑")
	fmt.Printf("%X \n", "欢迎访问微学苑")
	fmt.Printf("%T, %s \n", arr, arr)
	fmt.Printf("%T, %q \n", arr, arr)
	fmt.Printf("%T, %x \n", arr, arr)
	fmt.Printf("%T, %X \n", arr, arr)
}

  iota

iota 是特殊常量值，是一个系统定义的可以被编译器修改的常量值。iota 只能被用在常量的赋值中，在每一个 const 关键字出现时，被重置为 0，然后每出现一个常量，iota 所代表的数值会自动增加 1。iota 可以理解成常量组中常量的计数器，不论该常量的值是什么，只要有一个常量，那么 iota 就加 1。

package main
import "fmt"
const (
    a = iota
    b = iota
    c = iota
)
func main() {
    fmt.Println(a, b, c)
}

常量组中如果不指定类型和初始值，则与上一行非空常量的值相同。所以上述的枚举可以简写，如下所示：

package main
import "fmt"
const (
    a = iota
    b
    c
)
func main() {
    fmt.Println(a, b, c)
}

  运算符

    运算符优先级

  Go和C++相比所具有的区别

• 布尔类型不能接受其他类型的赋值，也不支持自动或强制的类型转换。
  Go语言是强类型语言，变量类型一旦确定，就不能将其他类型的值赋值给该变量。

var b bool
b = 1           // 编译错误
b = bool(1) // 编译错误
b = (1!=0)   // 编译正确

由于强类型的缘故，Go语言在进行布尔值真假判断时，对值的类型有严格限制，不同类型的值不能直接使用==或!=运算符进行比较，否则就会报错。同样，!运算符也不能作用于非布尔类型值。

b := (false == 0); // cannot convert 0 (type untyped number) to type bool invalid operation: false == 0 (mismatched types bool and int)

• 在Go语言中，不允许字符串转 int!!
  但是Go支持数据类型转换的有：
  • 浮点型与整型之间的转换
  • 整数类型转字符串类型
    这种类型的转换，其实相当于 byte 或 rune 转 string。int 数值是 ASCII 码的编号或 unicode 字符集的编号，转成 string 就是根据字符集，将对应编号的字符查找出来。当该数值超出 unicode 编号范围，则转成的字符串显示为乱码。例如，19968 转 string，就是“一”。
    备注：
    ASCII 字符集中数字的十进制范围是 48～57；
    ASCII 字符集中大写字母的十进制范围是 65～90；
    ASCII 字符集中小写字母的十进制范围是 97～122；
    unicode 字符集中汉字的范围是 4e00～9fa5，十进制范围是 19968～40869。
• switch
  • switch 语句执行的过程是自上而下的，直到找到 case 匹配项，匹配项中无须使用 break，因为Go语言中的 switch 默认给每个 case 自带 break。因此匹配成功后不会向下执行其他的 case 分支，而是跳出整个 switch。可以添加 fallthrough（中文含义是：贯穿），强制执行后面的 case 分支。fallthrough 必须放在 case 分支的最后一行。如果它出现在中间的某个地方，编译器就会报错。
  • switch 后的表达式可以省略，默认是 switch true。

参考

Go安装包下载
GoLand下载
安装并免费使用Pychram专业版（学生/教师）
Go安装与Goland破解永久版
Go语言（Golang）教程
Go Lang 异或符
ASCII
千峰教育 go语言视频教程