go基础学习

package main;

import "fmt";

func main() {
    fmt.Printf("hello,world");
}

package main;

import "fmt";

func main() {
    //定义一个类型为int的变量a
    var a int;

    //定义多个类型为int的变量
    var b, c, d int;

    //定义并初始化
    var e int = 0;

    //定义多个变量并初始化
    var f, g, h int = 1, 2, 3;

    //上面简化写法，根据值的类型初始化
    var i, j, k = 4, 5, 6;

    //更简洁的写法
    //但这种方式只能在函数内部使用
    //:=这种操作是先声明再初始化两步操作，你对一个变量两次:=操作会报错
    l := 7;

    //特殊的变量名_，任何赋予它的值都会被丢弃
    _, m := 8, 9;

    fmt.Printf("%d %d %d %d %d %d %d %d %d %d %d %d %d", a, b, c, d, e, f, g, h, i, j, k, l, m);
}

package main;

import "fmt";

func main() {
    //常量可定义为数值、布尔值或字符串
    const CNT = 1000;
    const PI = 3.14;
    const PRE = "db_";

    fmt.Printf("%d %f %s", CNT, PI, PRE);
}

package main;

import (
    "fmt"
    "errors"
)

func main() {
    //bool类型
    var isRun = false;
    //数值类型

    //有符号整型
    var a int8 = 1;
    var b int16 = 2;
    var c int32 = 3;
    //无符号整型
    var d uint8 = 4;
    var e uint16 = 5;
    var f uint32 = 6;
    //rune是int32的别称，byte是uint8的别称
    var g rune = 7;
    var h byte = 8;
    //不同类型的变量之间不允许互相赋值或操作
    //下面是错误的
    //tmp := a + b;

    //浮点数
    var i float32 = 1.23;
    var j float64 = 2.45;

    //复数
    var k complex64 = 5+5i;
    var l complex128 = 3+3i;

    //字符串
    var str1 string = "hello";
    //go中字符串是否可改变的，下面是错误的
    //str1[0] = ‘w‘;

    //如果要改变字符串，需要先转成[]byte类型，修改后再转string
    tmp := []byte(str1);
    tmp[0] = ‘w‘;
    str1 = string(tmp);

    //通过+进行字符串连接
    str2 := "hello";
    str3 := str2 + ",go";

    //错误类型
    err := errors.New("我是个错误");
    if err != nil {
        fmt.Print(err);
    }

    fmt.Printf("%t\n", isRun);
    fmt.Printf("%d %d %d %d %d %d %d %d\n", a, b, c, d, e, f, g, h);
    fmt.Printf("%f %f\n", i, j);
    fmt.Printf("%v %v\n", k, l);
    fmt.Printf("%s\n", str1);
    fmt.Printf("%s\n", str3);
}

package main;

import (
    "fmt"
);

func main() {
    //分组定义常量
    const (
        PI = 3.14
        CNT = 1000
        PRE = "db_"
    );
    //分组声明变量
    var (
        i int;
        pi float32;
        pre string;
    );
    //iota枚举
    const (
        a = iota;
        b = iota;
        c = iota;
    );
    //每遇到一个const关键字，iota就会重置
    const d = iota;

    fmt.Printf("%d %d %d %d", a, b, c, d);
}

package main;

import (
    "fmt"
);

func main() {
    //声明数组，5表示数组长度，int表示存储的元素类型
    var arr [5]int;
    //下标从0开始
    arr[0] = 5;
    arr[1] = 6;

    //长度也是数组类型的一部分，[4]int与[5]int是不同类型
    //数组不能改变长度，数组之间的赋值是值的赋值，而不是指针
    
    //声明并初始化
    a := [3]int{1, 2, 3};
    b := [5]int{4, 5, 6};
    //会自动计算长度
    c := [...]int{7, 8, 9};
    //多维数组，二行二列
    d := [2][2]int{[2]int{1, 2}, [2]int{3, 4}};
    e := [2][2]int{{1, 2}, {3, 4}};

    //slice并不是真正意义上的动态数组，而是一个引用类型
    //slice总是指向一个底层array
    //slice的声明类似array，只是不需要长度
    var f []int;
    g := []byte{‘a‘, ‘b‘, ‘c‘};
    //slice可以从一个数组或一个已经存在的slice中再次声明
    var h []byte = g[1:3];

    //数组和slice声明的不同
    //声明数组时，方括号内写明了数组的长度或使用...自动计算长度
    //声明slice时，方括号内没有任何字符

    var i = [6]int{1, 2, 3, 4, 5, 6};
    //声明初始化两个slice
    var j []int = i[2:5];
    var k []int = i[1:6];
    //slice是引用类型，改变j中的内容，i和k的内容也会变
    j[0] = 9;

    //map类型的声明,key是字符串，值是int
    //这种方式会创建一个nil map,所以在使用时必须用make初始化。
    var m map[string]int;
    m = make(map[string]int);

    //另一种声明方式
    n := make(map[string]int);

    //声明并初始化
    l := map[string]int {"age":30, "height":192}

    m["age"] = 25;
    m["height"] = 172;

    n["age"] = 25;
    n["height"] = 186;

    //map是无序的，长度不固定，引用类型
    //判断key是否存在
    //map有两个返回值，第二值表示key是否存在
    val, exist := m["height"];
    if exist {
        fmt.Print(val);
    }

    fmt.Printf("%v\n%v\n%v\n%v\n%v\n", a, b, c, d, e);
    fmt.Printf("%v\n%v\n%v\n", f, g, h);
    fmt.Printf("%v\n%v\n%v\n", i, j, k);
    fmt.Printf("%v\n%v\n%v\n", m, n, l);
}