Golang语言学习

main函数类似是一个入口

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

Go工程中共有三个文件夹，分别是:src、pkg、bin。
src：存放Go源码文件
pkg：存放编译后的包文件
bin：存放编译后的可执行文件src目录需要手动创建，一般pkg和bin目录不需要创建，编译时会自动创建。
由于当前章节视频中没有真正的执行install，所以代码直接放在工程目录下build暂时还没有报错。如果执行install的话就会报错了。

Go语言基础语言--import

• import语句可以导入源代码文件所依赖的package包；

• 不得导入源代码文件中没有用到的package,否则Go语言编译会报编译错误

主要有两种格式

第一种：

  import "package1"
  import "package2"
  import "package3"

第二种：

import  (
                "package1"
                "package2"
                "package3"
)

Go语言基础语法---import原理

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

gopackage.png

Go语言 基础语法---import别名," . "," _ "

• 别名操作的含义:将导入的包命名为另一个容易记忆的别名

  package main
  import (
  imooc "fmt"  //package 别名命名方法
  )
  func main(){
      imooc.Print("Hello World!")
  }
  

• 点.操作的含义是:点.标识的包导入后,调用该包中函数时可以省略前缀包名 ---不建议用,容易混淆

  package main
  import(
         . "fmt" //点`.`
  )
  func main(){
      Print(a:"hello imooc") //调用该包中函数时可以省略前缀包名fmt
  }
  

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

GO语言--数据类型

• 数据类型，字符串类型和布尔型
• 派生类型
• 类型零值和类型别名
• 类型所占存储大小

一个字节是8位

1. 整型,浮点型,复数,字符串和布尔型

• 数据类型的出现是为了把数据分成所需内存大小不同的数据,编程的时候需要用大数据的时候才需要申请大内存,就可以充分利用内存

• 布尔型的值只可以是常量true或者false.一个简单的例子:var a bool = true

• 字符串类型string,编码统一为UTF-8

2. 派生类型

• 指针类型(Pointer)
• 数组类型
• 结构化类型(struct)
• Channel类型(chan)
• 函数类型(func)
• 切片类型(slice)
• 接口类型(interface)
• May类型(map)

3. 类型零值和类型别名

• 类型零值不是空值,而是某个变量被声明后的默认值,一般情况下,值类型的默认值为0,布尔型默认值为false,string默认值为空字符串
• 可以对类型设置别名

package main
type imooc int32
funct main(){
    var i imooc //imooc就是int32的别名
}

Golangbyte.png

Go 语言 变量与常量

(一)变量

• 变量声明，初始化与赋值
• 变量可见性guiz
• 常量，常量声明和iota的使用

1. 单个变量声明和赋值

   (1). 变量的声明格式：var <变量名称> [变量类型]

   (2). 变量的赋值格式：<变量名称> = <值，表达式，函数等>

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

   (4). 分组声明格式：

   var (
       i int
       j float32
       name string
   ) //分组声明格式也可以同时赋值
   

2. 同一行声明多个变量和赋值：var a,b,c int = 1,2,3 或者 a,b := 1,2

3. 全局变量的声明必须使用var关键词，局部变量则可以省略

4. 特殊变量下划线_ ----//作用把这个值相当于一个回收站，程序运行是不再使用

5. Go语言中不存在隐式转换，类型转换必须是显式的

6. 类型转换只能发生在两种兼容类型之间

7. 类型转换格式：<变量名称> [:] = <目标类型>(<需要转换的变量>)

8. 变量的可见性规则

   (1). 大写字母开头的变量是可导出的，也就是其它包可以读取的，是公用变量

   (2). 小写字母开头的就是不可导出的，是私有变量

（二）常量

• 常量定义形式和变量类型范围
• 特殊常量iota的使用

(1) 常量定义形式和变量类型范围

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

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

• 常量范围目前只支持布尔型，数字型(整数型，浮点型和复数)和字符串类型

代码示例：

//例子1 常量可以分组赋值
const(
         cat string = "cat"
         dog = "dog"
)

//例子2 
const apple, banana string = "apple","banana" //显式单行定义多个常量
const apple, banana  = "apple","banana" //隐式单行定义多个常量

//例子3 
const a string = "apple"
const b = len(a) //表达式定义常量。只能为内置函数，自定义函数不能定义

iota只能在常量定义中使用,不能在函数体中使用

(2) 特殊常量iota的使用

• iota在const关键字出现时将被重置为0;
• const中每新增一行常量声明将iota计数一次
• iota常见使用方法：
  1. 跳值使用法
  2. 插队使用法
  3. 表达式隐式使用法
  4. 单行使用法

iota只能在常量定义中使用,不能在函数体中使用

//1. 跳值使用法
   const (
                a = iota
                b = iota
                - 
                c = iota     //c 的值为3
                )
                
//2.插队使用法
       const (
                a = iota
                b = 3.14
                c = iota     //c的值为2
                )
    
//3.表达式隐式使用法
           const (
                a = iota * 2    //a的值为0
                b                   //b的值为2
                c                   //c的值为4
                )
    
               const (
                a = iota * 2    //a的值为0
                b = iota * 3    //b的值为3
                c                   //c的值为6
                d                   //c的值为9
                )
                //隐式向上继承非空表达式
    
//4. 单行使用法
    
    const (
                a,b = iota ,iota + 3  //a的值为0,b的值为3 同一行iota不会计数加1
                c,d                                //c的值为1,的值为4
                f = iota                        //f的值为2
                )
   

GO语言运算符

• 算术运算符

  
  Image 1.png

• 关系运算符

  
  Image 2.png

• 逻辑运算符

  
  Image 3.png

• 按位运算符

  
  Image 4.png

• 赋值运算符

  
  Image 5.png

GO控制语句：

1. 条件语句if if else 嵌套if else if
2. 选择语句switch select
3. 循环语句for
4. 控制语句中使用

2. 选择语句switch select

• switch语句用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上直下逐一测试，知道匹配为止
• switch语句执行的过程从上至下

• switch语句还可以被用于type-switch来判断某个interface变量中实际存储的变量类型

  
  Image 1.png

示例代码：

package main
import "fmt"
func main() {
switch 3 {
case 1:
         fmt.Print(a:"判断为1")
case 2:
         fmt.Print(a:"判断为2")
default:
         fmt.Print(a:"以上都不满足！"）
}
}

//判断类型
package main
import "fmt"
func main() {
   var a interface{}
   a = 32
   switch a.(type) {
   case int:
           fmt.Print(a:"类型为整形")
case string:
         fmt.Print(a:"类型为字符串类型")
default:
         fmt.Print(a:"以上都不满足"）
}
}

3. 循环语句for

Image 5.png

示例代码：

package main

import (
   "fmt"
   "time"
)

func main() {
for i:=1;i<=10;i++{
    fmt.Print(a:"Keep")
    fmt.Print(i)
    fmt.Print(a:"\n")
    fmt.Sleep(1*time.Second)
}
}

package main

import (
    "fmt"
    "time"
)

func main() {
for i:=1;i<=10;i++{
     fmt.Print(a:"Keep")
     fmt.Print(i)
     fmt.Print(a:"\n")
     fmt.Sleep(1*time.Second)
}
}

package main

import (
    "fmt"
    "time"
)

func main() {

for {
        fmt.Print(a:"Keep")
}//无限循环

for i:=1;i<=10;i++ {
        fmt.Print(a:"Keep")
        fmt.Print(i)
        fmt.Print(a:"\n")
        fmt.Print(1*time.Second)
}

a := []string{"banana","apple","pear"}
for _,value := range a {
     fmt.Print(a:"value的值为：")
     fmt.Print(value)
     fmt.Print(a:"\n")
}
}

4. 控制语句中使用goto break continue

Image 8.png

package main

import (
    "fmt"
    "time"
)

func main() {
for {
       fmt.Print(a:"Keep")
       time.Sleep(1*time.Second)
       break
 }
}

package main

import (
    "fmt"
    "time"
)

func main() {

for i:= 1,i<=3;i++{
for  i:=1;j<=2;j++ {
       fmt.Print(a:"Keep")
       time.Sleep(1*time.Second)
       break  //break只终止当前循环
 }
 }
}

package main

import (
   "fmt"
   )
   
func main() {
            for i:=1;i<=3;i++ {
                    if i >= 2 {
                    fmt.Print(a:"Keep")
                    fmt.Print(i)
                    fmt.Print(a:"\n")
                    continue
            }
            fmt.Print(a:"Keep on\n")
  }
}

5. GOTO 语句

package main

import "fmt"

func main() {
          goto One
          fmt.Print(a:"中间代码块")
          One:
                   fmt.Print(a:"这里是代码块一\n")

}

package main

import  (
                   "fmt"
                   "time"
                  )

func main() {
           One:
                     fmt.Print(a:"这里是代码块一\n")
                     time.Sleep(1*time.Second)
             goto One  //无限循环
}