main函数类似是一个入口
-
package是最基本的分发单位和工程管理中依赖关系的体现 - 每个Go语言源代码文件开头都拥有一个
package声明，表示源代码文件所属代码包 - 要生成Go语言可执行程序，必须要有
main的package包，且必须在该包下有main()函数 - 同一个路径下只能存在一个
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函数 - 如果一个包被导入多次则该包只会被导入一次
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位
- 整型,浮点型,复数,字符串和布尔型
数据类型的出现是为了把数据分成所需内存大小不同的数据,编程的时候需要用大数据的时候才需要申请大内存,就可以充分利用内存
布尔型的值只可以是常量
true或者false.一个简单的例子:var a bool = true字符串类型
string,编码统一为UTF-8
- 派生类型
- 指针类型(Pointer)
- 数组类型
- 结构化类型(struct)
- Channel类型(chan)
- 函数类型(func)
- 切片类型(slice)
- 接口类型(interface)
- May类型(map)
- 类型零值和类型别名
- 类型零值不是空值,而是某个变量被声明后的默认值,一般情况下,值类型的默认值为
0,布尔型默认值为false,string默认值为空字符串 - 可以对类型设置别名
package main
type imooc int32
funct main(){
var i imooc //imooc就是int32的别名
}
Go 语言 变量与常量
(一)变量
- 变量声明，初始化与赋值
- 变量可见性guiz
- 常量，常量声明和iota的使用
-
单个变量声明和赋值
(1). 变量的声明格式：
var <变量名称> [变量类型](2). 变量的赋值格式：
<变量名称> = <值，表达式，函数等>(3). 声明和赋值同时进行：
var <变量名称> [变量类型] = <值，表达式，函数等>(4). 分组声明格式：
var ( i int j float32 name string ) //分组声明格式也可以同时赋值 同一行声明多个变量和赋值：
var a,b,c int = 1,2,3或者a,b := 1,2全局变量的声明必须使用
var关键词，局部变量则可以省略特殊变量下划线
_----//作用把这个值相当于一个回收站，程序运行是不再使用Go语言中不存在隐式转换，类型转换必须是显式的
类型转换只能发生在两种兼容类型之间
类型转换格式：
<变量名称> [:] = <目标类型>(<需要转换的变量>)-
变量的可见性规则
(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常见使用方法：
- 跳值使用法
- 插队使用法
- 表达式隐式使用法
- 单行使用法
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控制语句：
- 条件语句
if if else嵌套if else if - 选择语句
switchselect - 循环语句
for - 控制语句中使用
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
示例代码：
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
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 //无限循环
}
