GO语言基础

基础语法

//程序所属包(必须在程序第一行)
package main
//导入依赖包
import  "fmt"
//常量定义
const NAME string = "go"
//全局变量的声明与赋值
var a string = "go"
//一般类型声明
type go int
//结构的声明
type Learn struct {
}
//接口声明
type Ilearn interface {
}
//函数定义
func learnGo() {
    fmt.Print("learnGo")
}
//main()函数
func main() {
    fmt.Print("Hello world!")
}

Package包的用法

• package是最基本的分发单位和工程管理中依赖关系的体现；
• 每个GO语言源代码文件开头都拥有一个package声明，表示源码文件所属代码包；
• 要生成GO语言可执行程序，必须要有main的package包，且必须在该包下有main()函数；
• 同一路径下只能存在一个package，一个package可以拆成多个源文件组成；

import概念及原理

概念

• import语句可以导入源代码文件所依赖的package包；
• 不得导入源代码文件中没有用到的package，否则GO语言编译会报编译错误；
• import语法格式主要有两种形式：

//第一种
import "package1"
import "package2"

//第二种【推荐】
import(
    "package1"
    "package2"
)

原理

• 如果一个main导入其他包，包将被顺序导入；
• 如果导入的包中依赖其他包（包A），会首先导入包A，然后初始化A包中常量和变量，最后如果A包中有int，会自动执行init（）；
• 所有包导入完成后才对main中变量和常量进行初始化，然后执行main中的init函数（如果存在），最后执行main函数；
• 如果一个包被导入多次则该包只会被导入一次；

别名，"."，"_"的使用

• 别名

import  "fmt"
import  alias  "fmt"

• 点（.）操作的含义是：点（.）标识的包导入后，调用该包中函数时可以省略前缀包名【不建议使用点（.），容易造成函数冲突】；

import  .  "fmt"

• 下划线（ _ ）操作的含义是：导入该包，但不导入整个包，而是执行该包中的init的函数，因此无法通过包名来调用包中的其他函数。使用下划线( _ )操作往往是为了注册包里的引擎，让外部可以方便的使用；

import  _ "fmt"

数据类型

数值类型

字符串类型

• 编码统一为"UTF-8"

布尔型

• 值只可以是常量true和false

派生类型

• 指针类型（Pointer）
• 数组类型
• 结构化类型（struct）
• Channel类型 （chan）
• 函数类型 （func）
• 切片类型 （slice）
• 接口类型 （interface）
• Map类型 （map）

类型零值和类型别名

• 类型零值不是空置，而是某个变量被声明后的默认值，一般情况下，值类型的默认值为0，布尔型默认值为false，字符串类型默认值为空字符串；

var i int32
var j float32
var b bool
var d complex64

• 我们可以对类型设置别名

//注意：别名类型不能进行运算（相同的别名类型可以
）
type go int32
func main()
{
    var i go
}

类型所占存储大小

数值类型.png

浮点型.png

其他.png

变量

单个变量声明和赋值

• 声明格式：var <变量名称> [变量类型]

var a int

• 赋值格式：<变量名称> = <值，表达式，函数等>

a = 1

• 声明和赋值同时进行：var <变量名称> [变量类型] = <值，表达式，函数等>

var a int = 1

• 分组声明格式：

var（
    i int
    j float32
    name string
    c int = 1989
）

• 同一行声明多个变量和赋值；

var a，b，c int = 1，2，3 
var a，b，c = 1，1.2，4
a，b: = 1，2 //简写方式，只能用在函数体内

• 全局变量的声明必须使用var关键字，局部变量则可以省略；
• 特殊变量下划线 "_"【可以理解成把这个值丢进垃圾桶，程序运行时不在需要这个值】；

var a，_，c = 11，21.2，4
输出 11，4

变量类型转化

• Go 中不存在隐式转换，类型转换必须是显示的；
• 类型转换只能发生在两种兼容类型之间（int和bool是无法转化的）；
• 类型转换格式：<变量名称> [:] = <目标类型> （<需要转换的变量>）【冒号可有可无】

var a int = 3
c := float32(a)
输出：3

var b float32 = 3.01
c := int32(b)
输出：3
转换会有精度的损失

变量可见性规则

• 大写字母开头的变量是可导出的，也就是其他包可以读取，是公用变量；
• 小写字母开头的就是不可导出的，是私有变量

var a = "go"
var Learn = "go"

常量

常量定义形式和类型范围

• 常量定义形式可分为显式和隐式
  1.显式：const identifier [type] = value
  2.隐式：const identifier = value
  (通常叫无类型常量)

const learn string = 'go'
const name = '007'
const(
     learn string = 'go'
     name = '007'
)
const learn，name string = 'go'，'007'
const a，b  = 1，'go'

• 常量可以使用内置表达式定义，例如：len()，unsafe.Sizeof()等；

const a，b  = 1，'go'
const alen = len(a)

• 常量范围目前支持布尔型、数字型（整数型、浮点型和复数）和字符串型；

特殊常量iota的使用

• iota在const关键字出现时将被重置为0；

const a = iota
const b = iota
输出 0 0

• const中每新增一行常量声明将使iota计数一次；

const(
    b = iota
    c = iota
)
输出 0 1

• iota常见使用法：
  1.跳值使用法
  2.插队使用法
  3.表达式隐式使用法
  4.单行使用法

//跳值【使用下划线】
const(
    a = iota
    b = iota
    _
    c = iota
)
输出 0 1 3
//插队
const(
    a = iota
    b = 5.21
    c = iota
)
输出 0 5.21 2
//表达式隐式
const(
    a = iota * 2
    b = iota
    c = iota
)
输出 0 1 2
const(
    a = iota * 2
    b
    c
)
输出 0 2 4
const(
    a = iota * 2
    b = iota * 3
    c
    d
)
输出 0 3 6 9
//单行使用法
const (
    a，b = iota，iota+3
    c，d
    f = iota
    输出 a = 0 b =3 c = 1 d=4 f=2
)

控制语句

• 条件语句if，if...else，嵌套if，else if；

func main() {
    a := 1
    if a > 0 {
   }
}

• 选择语句switch，select；

func main() {
   /* 定义局部变量 */
   var grade string = "B"
   var marks int = 90

   switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }

   fmt.Printf("你的等级是 %s\n", grade );      
}

• 循环语句for；

func main() {
    //无限循环 true可以去掉
    for true  {
        fmt.Printf("这是无限循环。\n");
    }
     //普通循环
     sum := 0
     for i := 0; i <= 10; i++ {
          sum += i
     }
     //类似while
      for sum <= 10{
          sum += sum
      }
     fmt.Println(sum)
     //foreach range循环
     strings := []string{"google", "runoob"}
     for i, s := range strings {
         fmt.Println(i, s)
     }

      numbers := [6]int{1, 2, 3, 5}
      for i,x:= range numbers {
          fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
      } 
      输出结果：
      0 google
      1 runoob
      第 0 位 x 的值 = 1
      第 1 位 x 的值 = 2
      第 2 位 x 的值 = 3
      第 3 位 x 的值 = 5
      第 4 位 x 的值 = 0
      第 5 位 x 的值 = 0 
}

• goto、break、continue

func main(){
    goto One
    fmt.Print("中间代码")
    One:
        fmt.Print("代码一")
}