从零开始Golang开发（1）

1.你的第一行Go代码
任何伟大的开端都是从hello开始的

/*
import "fmt"
*/

import (
    "fmt"
)

//main函数
func main() { 
    //函数的{  一定是 和函数名在同一行的，否则编译错误
    //golang中的表达式，加";", 和不加 都可以，建议是不加
    fmt.Println(" hello Go!")
}

2.Go中四种变量声明方式
1.声明一个变量 默认的值是0

var a int

2.声明一个变量，初始化一个值

var b int = 100
var bb string = "abcd"

3.在初始化的时候，可以省去数据类型，通过值自动匹配当前的变量的数据类型

var c = 100
var cc = "abcd"

4.(常用的方法) 省去var关键字，直接自动匹配

e := 100
f := "abcd"
g := 3.14

5.声明多个变量

var xx, yy int = 100, 200
var kk, ll = 100, "Aceld"

6.多行的多变量声明

var (
        vv int  = 100
        jj bool = true
    )

测试一下

package main

/*
    四种变量的声明方式
*/

import (
    "fmt"
)

//声明全局变量 方法一、方法二、方法三是可以的
var gA int = 100
var gB = 200

//用方法四来声明全局变量
// := 只能够用在 函数体内来声明
//gC := 200

func main() {
    //方法一：声明一个变量 默认的值是0
    var a int
    fmt.Println("a = ", a)
    fmt.Printf("type of a = %T\n", a)

    //方法二：声明一个变量，初始化一个值
    var b int = 100
    fmt.Println("b = ", b)
    fmt.Printf("type of b = %T\n", b)

    var bb string = "abcd"
    fmt.Printf("bb = %s, type of bb = %T\n", bb, bb)

    //方法三：在初始化的时候，可以省去数据类型，通过值自动匹配当前的变量的数据类型
    var c = 100
    fmt.Println("c = ", c)
    fmt.Printf("type of c = %T\n", c)

    var cc = "abcd"
    fmt.Printf("cc = %s, type of cc = %T\n", cc, cc)

    //方法四：(常用的方法) 省去var关键字，直接自动匹配
    e := 100
    fmt.Println("e = ", e)
    fmt.Printf("type of e = %T\n", e)

    f := "abcd"
    fmt.Println("f = ", f)
    fmt.Printf("type of f = %T\n", f)

    g := 3.14
    fmt.Println("g = ", g)
    fmt.Printf("type of g = %T\n", g)

    // =====
    fmt.Println("gA = ", gA, ", gB = ", gB)
    //fmt.Println("gC = ", gC)

    // 声明多个变量
    var xx, yy int = 100, 200
    fmt.Println("xx = ", xx, ", yy = ", yy)
    var kk, ll = 100, "Aceld"
    fmt.Println("kk = ", kk, ", ll = ", ll)

    //多行的多变量声明
    var (
        vv int  = 100
        jj bool = true
    )
    fmt.Println("vv = ", vv, ", jj = ", jj)
}

3.Go中const常量及iota使用

//const 来定义枚举类型
const (
    //可以在const() 添加一个关键字 iota， 每行的iota都会累加1, 第一行的iota的默认值是0
    BEIJING  = 10 * iota //iota = 0
    SHANGHAI             //iota = 1
    SHENZHEN             //iota = 2
)

const (
    a, b = iota + 1, iota + 2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2
    c, d                      // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3
    e, f                      // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4

    g, h = iota * 2, iota * 3 // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9
    i, k                      // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)

测试一哈

package main

import "fmt"

//const 来定义枚举类型
const (
    //可以在const() 添加一个关键字 iota， 每行的iota都会累加1, 第一行的iota的默认值是0
    BEIJING  = 10 * iota //iota = 0
    SHANGHAI             //iota = 1
    SHENZHEN             //iota = 2
)

const (
    a, b = iota + 1, iota + 2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2
    c, d                      // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3
    e, f                      // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4

    g, h = iota * 2, iota * 3 // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9
    i, k                      // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)

func main() {
    //常量(只读属性)
    const length int = 10

    fmt.Println("length = ", length)

    //length = 10 //常量是不允许修改的。

    fmt.Println("BEIJIGN = ", BEIJING)
    fmt.Println("SHANGHAI = ", SHANGHAI)
    fmt.Println("SHENZHEN = ", SHENZHEN)

    fmt.Println("a = ", a, "b = ", b)
    fmt.Println("c = ", c, "d = ", d)
    fmt.Println("e = ", e, "f = ", f)

    fmt.Println("g = ", g, "h = ", h)
    fmt.Println("i = ", i, "k = ", k)

    // iota 只能够配合const() 一起使用， iota只有在const进行累加效果。
}

4.Go中的函数
1.返回1个返回值

func foo1(a string, b int) int {
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)

    c := 100

    return c
}

2.返回多个返回值，匿名的

func foo2(a string, b int) (int, int) {
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)

    return 666, 777
}

3.返回多个返回值， 有形参名称的

func foo3(a string, b int) (r1 int, r2 int) {
    fmt.Println("---- foo3 ----")
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)

    //r1 r2 属于foo3的形参，  初始化默认的值是0
    //r1 r2 作用域空间 是foo3 整个函数体的{}空间
    fmt.Println("r1 = ", r1)
    fmt.Println("r2 = ", r2)


    //给有名称的返回值变量赋值
    r1 = 1000
    r2 = 2000

    return
}

测试一哈

package main

import "fmt"

func foo1(a string, b int) int {
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)

    c := 100

    return c
}

//返回多个返回值，匿名的
func foo2(a string, b int) (int, int) {
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)

    return 666, 777
}

//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {
    fmt.Println("---- foo3 ----")
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)

    //r1 r2 属于foo3的形参，  初始化默认的值是0
    //r1 r2 作用域空间 是foo3 整个函数体的{}空间
    fmt.Println("r1 = ", r1)
    fmt.Println("r2 = ", r2)


    //给有名称的返回值变量赋值
    r1 = 1000
    r2 = 2000

    return
}

func foo4(a string, b int) (r1, r2 int) {
    fmt.Println("---- foo4 ----")
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)


    //给有名称的返回值变量赋值
    r1 = 1000
    r2 = 2000

    return
}

func main() {
    c := foo1("abc", 555)
    fmt.Println("c = ", c)

    ret1, ret2 := foo2("haha", 999)
    fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)

    ret1, ret2 = foo3("foo3", 333)
    fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)

    ret1, ret2 = foo4("foo4", 444)
    fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
}

相关链接：

Go开发的Go开发—即时通讯项目（包含完整源码和分析）：

分析：Go开发—即时通讯项目（包含完整源码和分析）_芙蓉铁蛋的博客-优快云博客

源码：Ming-XMU/Go-IM-project (github.com)

Go开发的两个练手应用：Go开发的两个小应用_芙蓉铁蛋的博客-优快云博客

Go语言基础：Ming-XMU/Go-IM-project (github.com)

从零开始Golang开发（1）_芙蓉铁蛋的博客-优快云博客

从零开始Golang开发（2）_芙蓉铁蛋的博客-优快云博客

从零开始Golang开发（3）_芙蓉铁蛋的博客-优快云博客

从零开始Golang开发（4）_芙蓉铁蛋的博客-优快云博客

从零开始Golang开发（5）_芙蓉铁蛋的博客-优快云博客