go学习笔记1

变量的定义

• 只定义，不赋值

// 会有初值
var a int
var s string

• 定义和赋值

var a int = 3
var s string = "abs"
#一次定义多个同类型的变量
var a, b int = 3, 4

• 系统判别类型

var a, b, c, s = 2, 3, 4, "def"

• 短格式

c := 5
a, b, s, d := 2, 3, "def", 5
d = 6 

• 在函数外部集中定义

// 在函数外部不能使用短格式定义
var (
    a = 3
    b = 4
    s = "hell"
)

内建变量的类型

• 分类

bool,string
(u)int,(u)int8|16|32|64,uintptr(指针)
byte,rune(字符)
float32|64,complex64|128（复数）

• 强类型

// 打印变量的类型
func main() {
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
    fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) // a 的类型和大小
    fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) // b 的类型和大小
}

• 数据类型的转换

func main() {
    i := 55      //int
    j := 67.8    //float64
    sum := i + int(j) // 不同类型的数据不允许进行运算 这里需要强制转换
    var c int
    c = int(j) // 赋值也是一样
    fmt.Println(sum, c)
}

常量

• 定义

func main() {
    const name = "mengyuan" // 不指定类型
    #const name string = "mengyuan" // 指定类型
    fmt.Printf("type %T value %v\n", name, name)
    const(
        a = 1
        s = "mengyuan"
    ) // 一次定义多个类型
}

• 注意

// 因为是强类型语言
// 赋值操作需要两边的类型一致 常量如果不指定类型的话就不需要注意
func main() {
    const trueConst = true // 类型不确定
    type myBool bool
    var defaultBool bool = trueConst // 允许 在赋值时确定类型
    var customBool myBool = trueConst // 允许
    //defaultBool = customBool // 不允许

    fmt.Println(defaultBool, customBool)
}

• 枚举

func main() {
    const(
        cpp = 0
        java = 1
        python = 2
        golang = 3
        js = 4
    )
    // 自增值枚举类型
    const(
        cpp = iota
        java
        python
        golang
        js
    )
}

if-else

• 格式

if condition {doing} else if condition {doing} else {doing}

• 注意点

// 判断奇偶
func main() {
    if num := 10; num % 2 == 0 { // 可以连写 但是变量 num 的作用范围仅仅在 if 语句中
        fmt.Println("the number is even") 
    } else {//} 和 else 必须是在一行 不能换行
        fmt.Println("the number is odd")
    }
}

switch

• 连写模式

//num := 5
switch num := 2; num { // num 的作用域在 switch
case 1:
    fmt.Println("php")
case 2:
    fmt.Println("python")
case 3:
    fmt.Println("java")
// case 3: case 不允许出现重复项
//    fmt.Println("js")
case 4:
    fmt.Println("cpp")
case 5:
    fmt.Println("golang")
default: // default 可以写在任何位置
    fmt.Println("default")
}

• 无表达式

nums := 2
switch {  // 相当于 switch true
case nums <= 2: 
    fmt.Println("E")
case nums <= 5:
    fmt.Println("D")
case nums <= 6:
    fmt.Println("C")
//case 3: case 不允许出现重复项
//    fmt.Println("js")
case nums <= 8:
    fmt.Println("B")
case nums <= 10:
    fmt.Println("A")
default:
    fmt.Println("default")
}

• 多表达式 (多种情况 一种处理方式)

// 包含多个表达式
numbers := 5
switch numbers {
case 2, 3, 4, 5:
    fmt.Println("the number <= 5")
case 6, 7, 8, 9, 10:
    fmt.Println("the number <= 5")
}

• fallthrough 语句

// 使用 fallthrough 语句可以在已经执行完成的 case 之后，把控制权转移到下一个 case 的执行代码中
number := 5
switch number {
case 2:
    fmt.Println("E")
    fallthrough
case 5:
    fmt.Println("D")
    fallthrough
case 6:
    fmt.Println("C")
    fallthrough
//case 3: case 不允许出现重复项
//    fmt.Println("js")
case 8:
    fmt.Println("B")
    fallthrough
case 10:
    fmt.Println("A")
}

循环

• 标准示例

// for 循环语句包括 初始条件 终止条件 post 语句 三部分
//num := 10
for i := 1; i <= 10; i++ {fmt.Println(i)
}

• continue 终止本次循环

//num := 10
for i := 1; i <= 10; i++ {
    if i%2 == 0 {continue}
    fmt.Println(i)
}

• break 跳出整个循环

//num := 10
for i := 1; i <= 10; i++ {
    if i > 7 {break}
    fmt.Println(i)
}

• 模仿 while

i := 1
for i <= 10 {fmt.Println(i)
    i++
}

• 死循环

for {fmt.Println("hello")
}

函数

• 定义

func calculateBill(num int, price int) int {
    ret := num * price
    return ret
}
// 同类型的参数可以简写 返回值类型可以不写
func calculateBill(num,price int) int {
    ret := num * price
    return ret
}

• 调用

func main() {
    price, num := 4, 5// 定义变量
    ret := calculateBillSimple(num, price)// 调用
    fmt.Println(ret)
    // 空白符
    var a, _ = rectPropsName(2, 4)
    fmt.Printf("the area is %.2f \n", a)
}

• 多返回值

// 多返回值
func rectProps(length, width float64) (float64, float64) {
    var area = length * width
    var perimeter = (length + width) * 2
    return area, perimeter
}

• 命名返回值

func rectPropsName(length, width float64) (area float64, perimeter float64) {
    area = length * width
    perimeter = (length + width) * 2
    return
}

指针

• 定义

// 指针的典型例子
var a int = 2
var pa *int = &a
*pa = 3
fmt.Println(a)

• 动态改变变量的值

func swap(a, b *int) {*a, *b = *b, *a}
func swapNew(a, b int) (int, int) {
    a, b = b, a
    return a, b
}

func main() {
    // 交换变量的值
    a, b := 3, 4
    //swap(&a, &b)
    a, b = swapNew(a, b)
    fmt.Println(a, b)
}

搭建一个 web 服务

• net/http 模块

// 当然不支持高并发
package main
import ("net/http")
func main() {http.Handle("/", http.FileServer(http.Dir(".")))
    http.ListenAndServe(":8080", nil)
}