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)
}