Go学习笔记02-基本语法

目录

• 变量定义
  • 代码示例
  • 变量定义
• 内建变量类型
  • 复数回顾
  • 强制类型转换
• 常量
• 枚举类型

变量定义

代码示例

package main

import "fmt"

/* 此处定义的变量为包内变量，在包内有效
    等效于
    var aa = 3
    var ss = "kkk"
    var bb = true
*/
var (
    aa = 3
    bb = true
    ss = "hahaha"
)

func variableZeroValue(){
    /*
          用var关键字定义变量
          变量类型写在变量名后
    */
    var a int
    var s string
    fmt.Printf("%d %q\n", a, s)
}

func variableInitialValue(){
    //可以同时定义多个变量,同时赋初值
    var a, b int = 3, 4
    var s string = "abc"
    fmt.Println(a, b, s)
}

func variableTypeDeduction(){
    //可以省略变量类型，编译器会自动判别类型
    var a, b, c, s = 3, 4, true, "def"
    fmt.Println(a, b, c, s)
}

func variableShorter(){
    //省略var关键字，用 := 定义变量，首次定义变量推荐这种方式
    a, b, c, s := 3, 4, true, "def"
    b = 5
    fmt.Println(a, b, c, s)
}

func main(){
    fmt.Println("Hello World!!!")
    variableZeroValue()
    variableInitialValue()
    variableTypeDeduction()
    variableShorter()
    fmt.Println(aa, ss, bb)
}

变量定义

1. 使用 var 关键字定义
2. 变量类型写在变量名后，如：var a int
3. 可以同时定义多个变量，如： var s1, s2 string = "hello", "world"
4. 可以使用 var() 集中定义变量
5. 编译器可以自动识别变量类型
6. 函数内 可以使用 := 定义变量类型

内建变量类型

1. bool(布尔类型),string(字符串类型)
2. （无符号）整型：(u)int,(u)int8,(u)int16,(u)int32,(u)int64
3. 指针类型：uintptr
4. byte(字节类型),rune(字符类型，相当于char类型，占32位)
5. 浮点数：float32,float64（Go没有double类型）
6. 复数类型：complex64,complex128

复数回顾

定义：

\[i = \sqrt {-1} ,即 i^2 = -1\]
形如：\(c = a + bi\) 的数叫做复数，其中\(a\)称为实部，\(b\)称为虚部。

复数的模：

复数 \(c = a + bi\) 的模为

\[z = \left| a + bi \right| = \sqrt{a^2 + b^2}\]

\(i\) 的周期性：
\[i^2 = -1, i^3 = -i, i^4 = 1, i^5 = i\]

定义：
\[e^{i\varphi} = \cos \varphi + i \sin \varphi \\
\left| e^{i\varphi} \right| = \sqrt{\cos^2 \varphi + \sin^2 \varphi} = 1 \\
e^{i\pi} = -1, e^{\frac{3}{2}\pi i} = -i, e^{2 \pi i} = 1
\]

欧拉公式：
\[e^{i\pi} +1 = 0\]

代码验证：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func eular()  {
    c := 3 + 4i
    fmt.Println(cmplx.Exp(1i * math.Pi) + 1)
    fmt.Println(cmplx.Abs(c))
}

func main() {
    //fmt.Println("Hello World!!!")
    eular()
}
//输出为：(0+1.2246467991473515e-16i)

强制类型转换

Go语言只有强制类型转换

import (
    "fmt"
    "math"
)

func triangle(){
    var a, b int = 3, 4
    var c int

    //报错，go不会隐式转换类型
    //c = math.Sqrt(float64(a * a + b * b))
    //需要强制转换类型
    c = int(math.Sqrt(float64(a * a + b * b)))
    fmt.Println(c)
}

func main() {
    triangle()
}

常量

Go语言中用关键字 const 定义变量，如：

    const i = 12

可以一次定义多个常量，如：

    const(
        cpp = 0,
        java = 1,
        golang = 2,
        python = 3,
        javascript = 4
    )

注：Go语言中不建议常量名为大写

枚举类型

Go中没有像Java中用于定义枚举类的关键字 enum，而是用 const 定义一组常量作为枚举类。

可以用 iota 定义一组自增的常量，并且可以参与运算，如：

    /** 输出为0, 1, 2, 3, 4
    还可以简写为
    const (
        cpp = iota
        _
        golang
        python
        javascript
    )
    */
    const (
        cpp = iota
        java
        golang
        python
        javascript
    )

    //iota参与运算
    const(
        b = 1 << (10 * iota)
        kb
        mb
        gb
        tb
        pb
    )