GO的部分总结~

package main

import (
    "fmt"
    "math"
)

var f int = 1      /*全局变量容许 声明可是不使用*/
const AGE int = 25 //定义常量
const SEX = "man"  //定义常量
const ( //枚举类型
    Unknow = 0
    Female = 1
    Male   = 2
    CC     = "lalalla"
    D                //枚举特效 D的值会和CC同样 我本身理解为枚举的上下继承，
    L      = len(CC) //能够使用系统内置函数 不然编译不过
)

//定义结构体
type Circle struct {
    radius float64
}
type Books struct {
    title  string
    author string
    bookid int
    url    string
}

//iota //丝毫 极少 一般用于否认句 不是好词 iota标志枚举声明的数量 从0开始 很差理解的概念哦~
func main() {
    fmt.Println("hello world22");
    var a int = 1 /*var 声明变量 a是int*/
    a += 2
    c := 2                     /*以省略var的方式声明变量c 而且类型自动判断！这种不带声明格式的只能在函数体中出现*/
    var b string = "iloveyou!" /*声明字符串变量不能用单引号！*/
    var d bool                 /*局部变量变量声明不使用也会报错~~*/
    e, f := 5, 7               /*并行赋值*/
    f, e = e, f                //交换值
    fmt.Println(a, c, b, d, e, f)
    _, f = e, f //抛弃e
    println(f, e)
    println(AGE, SEX)
    if AGE > 10 {
        println("大于10", max(1, 3))

        g, h := swap("one", "two")
        println(g, h) //two one
        swap2(&g, &h) //函数是引用传递 用&传参
        println(g, h) //one two

    } else {

    }
    //这样声明方式不能在函数外声明
    getR := func(x float64) float64 {
        return math.Sqrt(x)
    }
    println(getR(9))
    // 声明结构体
    var i Circle
    i.radius = 10;
    println(i.getArea())

    var arr0 [10] int                        //声明长度为10的空数组 定义变量长度类型
    var arr = [4]int{1, 2, 3, 4}             //已知长度的数组声明
    var arr1 = [...]int{1, 2, 3, 4, 5, 5, 6} //不肯定长度数字声明 推荐
    println(arr[3])
    println(len(arr1))
    arr0[0] = 1
    var arr2 [3][4] int //多维
    arr2[0][0] = 1

    var arr3 = [3][4]int{ //这个语法不太熟悉
        {1, 2, 3, 4},
        {1, 2, 3, 4},
        {1, 2, 3, 4},
    }
    println(arr3[0][0])

    var ip *int  //int类型空指针 nil
    println(ip)  //空指针 nil
    ip = &a      //空指针的赋值
    println(ip)  //访问ip的地址
    println(*ip) //访问ip的值

    //行内赋值方法用处还挺多呢！
    ss := Books{title: "你的名字", author: "杨森", url: "http://www.baidu.com/", bookid: 12}
    //格式化打印go的结构体
    fmt.Printf("%+v", ss)
    struct1(ss)

    //定义切片 未指定长度的数组
    //初始化
    ii_s := make([]int, 3, 5) //第三个参数是容量
    p_s(ii_s)
    var numbers []int
    if (numbers == nil) {
        fmt.Println("numbers为空")
    }
    p_s(numbers)

    //for range能够遍历数字 map等~
    nums := []int{1, 2, 3, 4}
    for i, num := range nums {
        fmt.Println(i, num)
    }
    fmt.Printf("%d的阶乘是%d", 10, fac(10))
    //接口 多个方法的封装
}

//递归本身调用本身 阶乘~
func fac(n uint64) (result uint64) {
    if (n > 0) {
        result = n * fac(n-1)
        return result
    }
    return 1
}

func p_s(x []int) {
    fmt.Printf("len=%d, cap=%d,slice=%+v", len(x), cap(x), x)

}

func max(n1, n2 int) int {
    return n1 + n2
}

/**
返回多个值 接收的时候须要使用并行赋值
 */
func swap(s1, s2 string) (string, string) {
    return s2, s1
}

//引用传递不用使用返回值和并行赋值接收 方便一点
func swap2(s1 *string, s2 *string) {
    var tmp string //声明中间变量
    tmp = *s1
    *s1 = *s2
    *s2 = tmp
}

//定义方式暂时不动~~~
func (c Circle) getArea() float64 {
    return 3.14 * c.radius * c.radius
}

//结构体作参数
func struct1(book Books) {
    fmt.Printf("%+v", book)
}