Go（1）

中文文档

https://studygolang.com/pkgdoc


hello world

// 必须要有个main包
package main

// 导入包，必须使用
import "fmt"

func main() {
   // 变量定义了，必须使用
   // 只是声明，而没有初始化的变量，默认值为0
   // 函数体里的变量名是唯一的，可以使用多次赋值
   var a, b int = 999, 9999
   fmt.Println(a)
   fmt.Printf("%d
", b)

   // 自动推导类型，必须初始化，通过初始化的值确定类型
   // 此类型的变量不能再新建重名的变量名，只能使用一次，用于初始化那次
   // 同类型只可以赋值同类型的
   c := 10
   fmt.Printf("c type is %T
", c)
   c = 99
   fmt.Println(c)
   d := "hello"
   fmt.Printf("d type is %T
", d)
}

匿名变量

func test(a, b, c int) (int, int, int) {
   a, b, c = 1, 2, 3
   return a, b, c
}
func main() {
   var temp int
   // 交换两个变量
   i, j := 10, 20
   i, j = j, i
   fmt.Println(i, j)

   // _匿名变量，丢弃数据不处理,_匿名变量配合函数返回值使用，才有优势
   temp, _, _ = test(1, 3, 5)
   fmt.Printf("%d", temp)
}

常量

func main() {
   // 变量声明需要用var
   // 常量是const，不允许修改 但是可以自动推导类型
   const a int = 10
   const b = 10.6
   fmt.Printf("%T
", b)
   fmt.Println(b)
}

多个变量定义

var (
   a int
   b float64
)
a, b = 10, 3.14

// 自动推导类型
const (
   i = 10
   j = 3.14
)

枚举

func main() {
   // iota常量自动生成器，每行一个，自动累加1
   // iota给常量赋值使用
   const (
      a = iota
      b
      c
   )
   fmt.Printf("%T
", a)
   fmt.Printf("a=%d   b=%d   c=%d
", a, b, c)

   // iota遇到const，重置为0
   const d = iota
   fmt.Printf("d=%d
", d)

   //如果是同一行，值都一样
   const (
      i          = iota
      j1, j2, j3 = iota, iota, iota
      k          = iota
   )
   fmt.Printf("i=%d
", i)
   fmt.Printf("j1=%d  j2=%d  j3=%d
", j1, j2, j3)
   fmt.Printf("k=%d
", k)
}

布尔

// 声明变量
var a bool
a = true
fmt.Println("a=", a)

// 自动推导类型
var b = false
fmt.Println("b=", b)

c := false
fmt.Println("c=", c)


字符串

str1 := "abcdefg"
// 字符串长度
fmt.Println(len(str1))

// 字符
ch1 := 'a'
fmt.Println(ch1)
// 操作字符串的某个字符，从0开始
fmt.Printf("%c", str1[0])

复数类型

// 复数类型
var t complex128
t = 2.1 + 3.14i
fmt.Println(t)

//自动推导
t2 := 3.3 + 4.4i
fmt.Printf("%T
", t2)

// 通过内建函数，取实部和虚部
fmt.Println(real(t2), imag(t2))

格式化输出

a := 10
b := "a"
c := 'a'
d := 3.14
// 变量所属类型 %T
fmt.Printf("%T  %T  %T  %T
", a, b, c, d)
// %d 整数
// %s 字符串
// %c 字符
// %f 浮点型
fmt.Printf("a=%d b=%s c=%c d=%f
", a, b, c, d)
// 自动匹配格式输出 %v
fmt.Printf("a=%v b=%v c=%v d=%v
", a, b, c, d)


输入

var a int
fmt.Println("请输入：")
fmt.Scan(&a)
fmt.Println("a=", a)

可转换类型

// 不能转换的类型，叫不兼容类型
// var flag bool
// flag = true
// bool不能转为int型
// int不能转为bool型
// fmt.Printf("flag=%d
", flag)

// 可转类型
// 字符本身就是整数型
var ch byte
ch = 'a'
var t int
t = int(ch)
fmt.Println(t)

类型别名

// 类型别名 给int64起一个别名bigint
type bigint int64
var a bigint
fmt.Printf("a type is %T
", a)

type (
   long int64
   char byte
)
var b long = 11
var ch char ='a'
fmt.Printf("b type is %T
",b)
fmt.Printf("c type is %T",ch)


流程控制

s := 10
if s == 10 {
   fmt.Println("true")
}
// if支持一个初始化语句
if a := 10; a == 10 {
   fmt.Println("a==10")
}


var num int
fmt.Println("请输入：")
fmt.Scan(&num)
switch num {
case 1:
   fmt.Println("1")
case 2:
   fmt.Println("2")
case 3:
   fmt.Println("3")
case 4:
   fmt.Println("4")
default:
   fmt.Println("不在范围")
}


// 支持一个初始化语句
switch num := 10; num {
case 1:
   fmt.Println("1")
   fallthrough
case 2:
   fmt.Println("2")
   fallthrough
// 多条件满足
case 3,4,5,6:
   fmt.Println("3")
   fallthrough
default:
   fmt.Println("不在范围")
}

// 可以没有条件
num := 10
switch {
case num > 5:
   fmt.Println("1")
case num < 50:
   fmt.Println("2")
default:
   fmt.Println("不在范围")
}

fallthrough

var num int
fmt.Println("请输入：")
fmt.Scan(&num)
// fallthrough 不跳出switch，后面的无条件执行
switch num {
case 1:
   fmt.Println("1")
   fallthrough
case 2:
   fmt.Println("2")
   fallthrough
case 3:
   fmt.Println("3")
   fallthrough
case 4:
   fmt.Println("4")
   fallthrough
default:
   fmt.Println("不在范围")
}

循环

sum := 0
// 初始条件；判断条件；条件变化
for i := 0; i <= 100; i++ {
   sum += i
}
fmt.Println(sum)

迭代

str1 := "abc"
// 传统写法
for i := 0; i < len(str1); i++ {
   fmt.Printf("str[%d]=%c
", i, str1[i])
}
// 迭代
for i, data := range str1 {
   fmt.Printf("str[%d]=%c
", i, data)
}
// 第二个参数默认丢弃,返回元素的位置下标
for i, _ := range str1 {
   fmt.Printf("str[%d]=%c
", i, str1[i])
}

跳出循环与中止循环

i := 0
// 不写任何条件即为无限循环
for {
   if i == 5 {
      // 跳出循环
      break
      // 跳过本次循环，下一次继续
      //continue
   }
   fmt.Println(i)
   i++
}

goto

    fmt.Println("111111111111111")
   // goto关键字，End是用户起的名字，跳过指定位置执行
   goto End
   fmt.Println("222222222222222")
End:
   fmt.Println("333333333333333")