Golang从零搭建分布式爬虫（慕课网课程链接）

• 学习路线
  • 基本路线
  • 实战路线
• 变量
  • 变量定义
  • 完整变量定义
    • 自动判断变量类型定义
    • 简写变量定义
    • 包内变量定义
  • 变量类型
    • 内建变量类型
      • 关于complex
      • 欧拉公式示例
    • 强制类型转换
• 常量与枚举
  • 常量的定义
  • 使用常量定义枚举类型
• 要点回顾

学习路线

基本路线

基本语法->面向接口->面向对象->函数式编程->Go语言工程化->并发编程

项目实战路线

单任务爬虫->并发式爬虫->分布式爬虫

变量

变量定义

1.完整定义

// a,b,c均为变量名称 3,4,"abc"均为初始值  xxx均为定义函数名
//注：这种定义类型只能同类型定义在同一行，反过来讲就是定义一个变量类型的同一行可以定义多个变量
func xxx(){
var a,b int 3,4
var c string "abc"
fmt.Println(a,b,c)
}
//输出：3 4 "abc"

2.自动判断类型定义

// a,b,c,s均为变量名称 3,4,true,"abc"均为初始值 xxx均为定义函数名
//注：这种定义类型在同一行可以定义多个类型，Go语言自动识别定义类型
func xxx(){
var a,b,c,s = 3,4,true,"abc"
fmt.Println(a,b,c,s)
}
//输出：3 4 true "abc"

3.简写定义

// a,b,c,s均为变量名称 3,4,true,"abc"均为初始值 xxx均为定义函数名
//注：这种定义类型在同一行可以定义多个类型，但只有在第一次定义变量才会使用 := 第二次对变量赋值直接使用 = 即可
func xxx(){
a,b,c,s := 3,4,true,"abc"
fmt.Println(a,b,c,s)
}
//输出：3 4 true "abc"

4.包内定义（其他语言会叫全局变量）

// a,b,c,s均为变量名称 3,4,true,"abc"均为初始值 
//注：这种定义可以与1,2相同（定义在函数体之外）也可以用以下方法    但因为关键字原因不能在函数外使用第3种方法（:=）定义变量

.
.
.

import "fmt"

var  aa=123
var  bb=456
var  cc=true
// 另一种方法
var (
aa = 123
bb = 456
cc = true
)

func xxx(){
fmt.Println(aa,bb,cc)
}
//输出：123 456 true

.
.
.

变量类型

内建变量类型

• bool,string 通用的，不过多描述
• (u)int,(u)int8,(u)int16,(u)int32,(u)int64,uintptr 括号内加u为无符号整数，后接数字为规定长度的整数，uintptr为指针（长度随操作系统改变）
• byte,rune byte不过多叙述Go中的rune就是char类型（为避免1字节的char造成的坑，长度为32位）
• float32,,float64,complex64,complex128 float不过多描述 complex为复数类型 complex64中实部和虚部是32位的 在complex128中实部和虚部是64位的

关于complex

欧拉公式示例

    func euler(){
    //只输入i会返回变量未定义输入1i就可以定义为虚数i了
        fmt.PrintIn(
                    cmplx.eXP(1i * math.Pi)+1)
    }

    //输出结果为：0+1.2246467991473515e-16i

    func euler(){
        fmt.Printf("%.3f\n",
                    cmplx.eXP(1i * math.Pi)+1)
    }

    //输出结果为：0.000+0.000i

强制类型转换（Go语言只有强制类型转换，没有隐式类型转换）

用求直角三角形的斜边例子说明类型转换，两直角边分别为3和4

func triangle() {
    var a,b int = 3,4
    var c int
    //Sqrt参数为float所以括号内的a*a+b*b改写成float64(a*a + b*b) 
    //如上改完还是出错,是因为返回类型为float但前面声明c为int所以要将c = math.Sqrt(float64(a*a + b*b))改成c = int(math.Sqrt(float64(a*a + b*b)))
    //因为float是不准的，所以有可能出现4.9999等结果最后强制转换结果为4，解决方法会在后面说明

    c = int(math.Sqrt(float64(a*a + b*b)))
    fmt.Println(c)
}
//输出结果为5

常量与枚举

常量的定义

func consts(){
//常量可以定义在函数外部包的内部
//常量数值没有规定类型可以作为各种类型使用
//常量可以在常量名后面规定类型，也可以省略,省略下的a,b就是个文本可以是int也可以是float
    const filename = "abc.txt"
    const a,b = 3,4
//上面写法也可以替换成 
// const (
//  filename="abc.txt"
//  a,b=3,4
//)
    var c int
    c = int(math.Sqrt(a*a + b*b))
    fmt.Println(filename, c)
}
//输出结果为abc.txt 5

使用常量定义枚举类型

func enums(){
//普通枚举类型
    const(
        cpp = 0
        java = 1
        python = 2
        golang = 3
    )
    //也可以将定义更改为（自增值枚举类型）
    //const(
    //  cpp = iota //iota为定义自增
    //  java
    //  python
    //  golang
    //)

    fmt.Println(cpp, java, python, golang)
}

//输出结果为 0,1,2,3

func enums(){
    const(
        cpp = iota //iota为定义自增
        _          //_为跳过
        python
        golang
        javascript
    )

    fmt.Println(cpp, javascript, python, golang)
}

//输出结果为 0,4,2,3

func enums(){
const (
        b = 1 << (10 * iota) // <<移位操作，速度比乘除法快  将1的二进制位左移0位，右补0
        kb  //将1的二进制位左移10位，右补0
        mb
        gb
        tb 
        pb
    )
fmt.Println(b, kb, mb, gb, tb, pb)
}

//输出结果为 1 1024 1048576 1073741824 1099511627776 1125899906842624

要点回顾

1. 变量类型写在变量名之后
2. 编译器可推测变量类型
3. 没有char只有rune（rune只有32位）
4. 原生支持复数类型