go语言基础实例

一：变量

1）变量声明

func main() {
    var v1 int
    var v2 int
    //一次声明多个变量
    var (
        v3 int
        v4 int
    )
    //变量最开始会有一个零值
    fmt.Println(v1,v2,v3,v4)
}

打印效果：

2）变量初始化

package main

import (
    "fmt"
    "reflect"
)
func main(){
    //1 直接初始化并指定数据类型
    var v1 int =
    //2 直接初始化
    var v2 =
    //3 := 声明变量及初始化
    v3 :=
    //利用反射，查看v的类型
    fmt.Println("v3类型是：",reflect.TypeOf(v3))
    fmt.Println(v1,v2)
}

运行效果：

3）变量赋值

package main

import "fmt"
func main()  {
    //直接赋值
    var v1 int
    v1 =
    //2 声明变量并赋值
    i :=
    //3多重赋值
    var v2,v3,v4 int
    v2,v3,v4=,,
    fmt.Println(v1,v2,v3,v4,i)
}

运行效果：

4）匿名变量  (注：_   代表特殊的变量名，作用是占位)

import "fmt"

//(int,string) 指的是返回值类型
func test() (int,string){
    return ,"够浪"
}
//调用函数
func main(){
    _,s :=test()    //_ 表示占位 所以打印结果只有一个参数
    fmt.Println(s)
}

运行效果

二：常量与枚举

1）声明常量

package main

import "fmt"
//声明常量
const filename  = "abc.txt"
func consts()  {
    const (
        filename = "abc.txt"
        a,b  = ,
    )
    //究竟原则
    fmt.Println(filename)
}
func main()  {
    consts()

}

2)  iota 常量生成器

package main

import "fmt"

func enums2(){
    const (
        python =iota
        golang
        java
    )
    fmt.Println(python,golang,java)
}
func main(){
    enums2()
}

运行效果

iota参与运算（位运算原理：参考https://studygolang.com/articles/6657）

package main

import "fmt"

func enmus3(){
    const (
        //位运算
        b = <<(*iota)
        kb
        mb
        gb
        tb
        pb
    )
    fmt.Println(b,kb,mb,gb,tb,pb)
}
func main(){
    enmus3()
}

3）枚举

package main

import "fmt"
//定义枚举类型
func enums() {
    const (
        python =
        golang =
        java =
    )
    fmt.Println(python,golang,java)
}

func main()  {
    enums()
}

 三： 基本数据类型

1）整型

package main
import (
    "fmt"
    "reflect"
)
func main(){
    var v1 int32
    v1=
    v2 :=
    fmt.Println(v1,v2)
    //默认推算类型是int
    fmt.Println(reflect.TypeOf(v2))
}

运行效果

2）浮点型

package main
import (
    "fmt"
    "reflect"
)
func main(){
    var f1 float32
    f1 =
    f2 := 12.0
    fmt.Println(f1)
    fmt.Println(reflect.TypeOf(f2))
}

运行效果

3）布尔类型

package main
import (
    "fmt"
    "reflect"
)
func main(){
    var v1 bool
    v1 = true
    v2 :=(==)
    fmt.Println(v1,v2)
    fmt.Println(reflect.TypeOf(v2))
}

运行效果

4）byte字符型

package main

import "fmt"

func main(){
    var ch byte
    ch='a'
    fmt.Println(ch)
    fmt.Printf("ch=%c",ch)
}

5）字符串

package main

import "fmt"

func main(){
    var  str string
    str ="abc"
    fmt.Printf(str)
    fmt.Println()
    str2 := "hello mike \n \r 测试"
    fmt.Println(str2)
}

三： fmt 包的使用

1）格式说明

2) 输出

package main
import "fmt"
func main(){
    a :=
    //%b是二进制
    fmt.Printf("a = %b\n" ,a)
    //只输出一个%
    fmt.Printf("%%\n")

    //字符串
    ch := 'a'
    fmt.Printf("ch = %c, %c\n",ch,)

    //浮点类型
    f := 3.14
    //%g 紧凑格式
    fmt.Printf("f = %f,%.g\n" ,f ,f)

    str := "hello.go"
    fmt.Printf("str=%s\n",str)

}

3）输入

package main

import "fmt"

func main(){
    var  v int
    fmt.Println("请输入数字")
    fmt.Scan(&v)
    fmt.Println("v = ",v)
}

运行效果

4）类型别名

package main

import (
    "fmt"
    "reflect"
)

func main(){
    //int类型取个别名
    type myint int
    var i myint  =
    fmt.Println(reflect.TypeOf(i))
}

运行效果

5）类型转换

package main

import "fmt"

func  goo()  {
    var ch byte = 'a'
    var i int = int(ch)
    fmt.Println(i)
}
func main(){
    goo()
}

四：流程控制

1）选择结构 ：if else 语句

package main

import (
    "fmt"
    "io/ioutil"
)
//第一种写法
func main(){
    const filename ="abc.txt"
    //ioutil.ReadFile读文件
    contents,err := ioutil.ReadFile(filename)
    if err != nil{
        fmt.Println(err)
    }else {
        fmt.Printf("%s\n",contents)
    }
    //第二种写法
    if contents,err :=ioutil.ReadFile(filename);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Printf("%s\n",contents)
    }

}

2）switch语句

package main

import (
    "fmt"
)

//传入成绩，返回评分等级
func grade(score int) string {
    // 定义字符串
    g := ""
    // go语言switch自动每一句加了break
    switch {
    case score <  || score > :
        g = "输入错误"
    case score < :
        g = "不及格"
        fallthrough
    case score < :
        g = "一般"
    case score < :
        g = "良好"
    case score <= :
        g = "优秀"
    default:
        g="XXX"
    }
    return g
}

func main() {
    fmt.Println(
        grade(),
        grade(),
        grade(),
        grade(),
        grade(),
        grade(),
        grade(-),
    )
}

2) 循环结果

package main

import (
    "fmt"
    "time"
)
//死循环
func for1(){
    for {
        fmt.Println("日耳曼战车凉凉")
        //睡一秒
        time.Sleep(*time.Second)
    }
}
func main()  {
    for1()
}

package main

import (
    "fmt"
    "time"
)
//打印10次
func for2(){
    for i :=; i<;i++{
        fmt.Println("日耳曼战车凉凉",)
        //睡500毫秒
        time.Sleep(*time.Millisecond)
    }
}
func    main(){
    for2()
}

package main

import (
    "fmt"
    "time"
)

func for3(){
    for i :=;i<;i++{
        if i%=={
            fmt.Println("爱阿根廷")
        }else if i% == {
            fmt.Println("爱战车")
        }else{
            fmt.Println("更爱天台")
        }
        time.Sleep(*time.Millisecond)
    }
}
func main(){
    for3()
}

4）range（r然哥）

package main

import "fmt"

func main(){
    s := "abc"
    //接收下标，通过下标取值
    for  i :=range s{
        fmt.Printf("下标=%d,值=%c\n",i,s[i])
    }
    //直接都接收到
    for i,c := range s{
        fmt.Printf("下标=%d,值=%c\n",i,c)
    }

    for _,c :=range s  {
        fmt.Printf("值=%c\n",c)
    }

}

5）跳转语句（break和continue）

package main

import "fmt"

func main(){
    for i :=;i<;i++{
        if i=={
            //break  终止并退出循环
            continue       //终止本次循环进入下次循环
        }
        fmt.Println(i)
    }
}

　　goto

package main

import "fmt"

func main(){
    for i :=;i<;i++{
        fmt.Println(i)
        //goto必须跳转到方法内
        goto LABEL2
    }
    fmt.Println("程序结束")
LABEL2:
    fmt.Println("程序over")
}