Go学习笔记-基础知识
Go 学习笔记-基础知识
Go(又称Golang) 是Google 开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言
Go 特性
静态类型并具有丰富的内置类型
函数多返回值
错误处理机制
语言层并发
面向对象: 使用类型、组合、接口来实现面向对象
自动垃圾回收机制
交差编译
1. 在mac 上安装
tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz
设置GOROOT GOPATH GOPROXY
#GOROOT
export PATH=$PATH:/usr/local/go/bin
#GOPATH
export GOPATH=$HOME/GoWork
export PATH=$PATH:$GOPATH/bin
#GOROOT 是go安装目录路径
#GOPATH 工作路径，
bin 是可执行文件存放路径
pkg 编译包时，生成文件存放路径
src 源码路径
#GOPROXY 设置
go env -w GOPROXY=https://goproxy.cn,direct
2. GO Module设置
go env -w GO111MODULE=on
godoc -http=:8000 官方文档查看
3. Go hello word
package main //定义包main
import (
"fmt" //导入标准包fmt
)
// 程序入口，manin 函数
func main() {
/*
注释
这里调用fmt包下的Println 函数打印内容到控制台
*/
fmt.Println("Hello world") // 打印hello world 到控制台
}
4. 基本组成元素
标识符
#go 语言提供一些预先定义的标识符用来表示内置的常量、函数、类型
#在自定义标识符时避免使用
标识符:程序中定义的名字 变量名，常量名字，函数名字，自定义类型，接口，包名等进行命名，以建立名称和使用之间的关系
Go语言标识符的命名规则:
1. 只能由非空字母(Unicode)、数字、下划线(_)组成
2. 只能以字母或下划线开
3. 不能go语言关键字
4. 避免使用go语言预定义标识符
5. 标识符区分大小写
规范:
1.必须满足: 组成只能由非空的Unicode 编码字符串、数字、下划线组成
2.必须满足: 必须以Unicode 编码的字符串或下划线开头(不能以数字开头)
3.必须满足: 不能与go 的关键字冲突(package，func,var .....25 )
建议:
1. ASCILL 编码
2. 变量使用驼峰式，多个英文字母首字母大写
多个英文字母my_name myName(驼峰)
3. 与go内置的标识符不要冲突(string ...)
说明: 标识符区分大小写
my = ""
My = ""
内置常量: true false nil iota
内置类型:
bool、byte、rune、int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64、uintptr、float32、float64、complex64、complex128、string、error
内置函数:
make、len、cap、new、append、copy、close、delete、complex、real、imag、panic、recove
空白表示符: _
5. 基本组成元素
关键字
#关键字用于特定的语法结构
#Go语言定义25个关键字
*声明：import
*实体声明和定义:
char、const、func、interface、map、struct、type、var
*流程控制:
break、case、continue、default、defer、else、fallthrough、for、go、goto、if、range、return、select、switch
*字面量:
字面量是值的表示方法，常用与对变量/常量进行初始化
主要分为:
*标识基础数据类型值的字面量，例如: 0,1.1,true,3+4i,'a',"我爱中国"
*构造自定义的复合数据类型的类型字面量，例如: type Interval int
*用于表示复合数据类型值的复合字面量，用来构造array、slice、map、struct、的值,例如:{1,2,3}
操作符:
算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符
分隔符
小括号() 中括号[] 大括号() 分号;, 逗号，
6. 变量
变量的含义: 程序允许过程中的数据都是保存在内存中，我们想要在代码中操作某个数据时就需要去内存找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。
变量的类型: 变量的功能是存储数据。不同变量保存的数据类型会不一样。常见变量的数据类型有: 整型、浮点型、布尔型等。Go语言中每一个变量都有自己的类型，并且变量必须经过声明才开始使用。
变量声明: Go 语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。并且Go语言的变量声明后必须使用，否则会报。
单个变量的声明与赋值
全局变量是在函数外
局部变量是在函数内，局部变量必须引用
变量的声明格式: var <变量名称> <变量类型> 函数外的变量声明必须都是以var 开头进行声明
变量的赋值格式: var <变量名称> <表达式>
声明的同时赋值: var <变量名称> [变量类型] =<表达式>
#单个变量的声明与赋值
package main
import "fmt"
func variableZeroValue() {
var a int
var b string
//变量赋值
a = 10
fmt.Printf("%d %q", a, b)
}
func main() {
variableZeroValue()
fmt.Println("hello, world")
}
6.1 变量的定义
在Go中，如果一个名字以大写字母开头，那么它就是已导出的，例如：
pi和pizza 并未以大写字母开头，所以它们是未导出的
如果将Pi 修改为pi 就是未导出的
package main
import "fmt"
func main() {
//局部变量给数据起一个名字
var msg string = "hello world"
fmt.Println(msg)
//其他代码
fmt.Println(msg)
//其他代码
fmt.Println(msg)
//其他代码
fmt.Println(msg)
//其他代码
}
# 多重赋值
package main
import "fmt"
func main(){
a, b := 10,20
// 交换2个变量的值
var tmp int
tmp = a
a = b
b = tmp
fmt.Printf("a=%d,b=%d\n",a,b)
i ,j := 10,20
i ,j = j,i
fmt.Printf("i=%d,j=%d",i,j)
}
6.2 变量作用域
package main
import "fmt"
//包级别
var packageVar string = "package Var "
func main() {
// 函数级别的
var funcVar string = "func Var"
{
// 块级别的
var blockVar string = "block Var "
{
//限定变量的使用范围
//子块级别
var innerBlockVar string = "inner block var"
fmt.Println(packageVar, funcVar, innerBlockVar,blockVar)
}
fmt.Println(packageVar,funcVar,blockVar)
}
fmt.Println(packageVar,funcVar)
}
# 一个大括号就是一个作用域
6.3 变量的定义方式
package main
import (
"fmt"
)
func main(){
var name string = "xingxing" //定义类型并且初始化了值
var zeroString string // 定义变量类型,但不初始化值
var typeString = "xing" // 定义变量省略类型，不能省略初始化值
//通过对应的值类型推到变量的类型
// 短声明(必须在函数内包含函数内子块使用，不能再包级别使用)
shortString := "xingxing" //通过对应的值类型推到变量的类型
fmt.Println(name,zeroString,typeString,shortString)
}
package main
import (
"fmt"
)
func main(){
// 函数内(块)定义的变量必须使用
/* var name string = "xingxing"
var msg = "hello world "
var desc string
*/
var (
name string = "xingxing"
msg = "hello world "
desc string
)
x,y := "x","y"
fmt.Println(name,msg,desc,x,y)
}
6.4 更新变量的值
package main
import (
"fmt"
)
func main(){
var name string = "xingxing"
fmt.Println(name)
name = "xing" // 更新变量的值
fmt.Println(name)
}
7 常量声明
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只有布尔型、数字型(整数型、浮点型和复数)和字符串型
使用const 进行常量声明
package main
import "fmt"
const (
name string = "xingxing"
msg = "msg"
)
func main(){
fmt.Println(name)
fmt.Println(msg)
}
7.1 枚举
iota 标识符在一个小括号内，初始化为0，每调用一次+1
package main
import "fmt"
func main() {
const (
Mon = iota //在常量组中使用iota,初始化0，每次调用+1
Tuesd
Web
Thur
Fir
Sat
Sun
)
fmt.Println(Mon,Tuesd,Web,Thur,Fir,Sat,Sun)
}
8.数据类型
布尔类型: 用来表示真假，只有两个值,真 true 假 false
数字类型
浮点类型
字符串
数组
切片
映射
自定义类型
8.1 布尔类型
*布尔类型用于真假，类型名为bool，只有两个值true 和false，占用一个字节宽度，零值为false
package main
import "fmt"
func main(){
isGirl := true
fmt.Println("%T,%#v", isGirl,isGirl)
//操作
//逻辑运算
a,b,c,d := true,true,false,false
//与: 左操作数与右操作数都为true，结果为true &&
fmt.Println("a,b:",a&&b) // true && true : true
fmt.Println("a,c:",a&&c) // true && false : false
fmt.Println("c,b:",c&&b)// flase && true : false
fmt.Println("c,d:",c&&d) // false && false : false
//或: 左操作数与右操作数只要有一个为true，结果为true ||
fmt.Println("a,b:",a&&b) // true || true : true
fmt.Println("a,c:",a&&c) // true || false : true
fmt.Println("c,b:",c&&b)// flase || true : true
fmt.Println("c,d:",c&&d) // false || false : false
//非: 取反 true=> false, false=> true !
fmt.Println("c,b:",c&&b)// !true : false
fmt.Println("c,d:",c&&d) // !false: true
}
8.2 整数类型
package main
import "fmt"
func main(){
var age8 int8 = 31
var age int = 31
fmt.Println("%T, %#v,%d\n",age8,age8,age8)
fmt.Printf("%T,%#v,%d\n",age,age,age)
}
package main
import "fmt"
func main(){
var age8 int8 = 31
var age int = 31
fmt.Println("%T, %#v,%d\n",age8,age8,age8)
fmt.Printf("%T,%#v,%d\n",age,age,age)
a,b := 2,4
fmt.Println(a + b )
fmt.Println(a - b )
fmt.Println(a * b )
fmt.Println(a/b)
fmt.Println(a%b)
a++
b--
fmt.Println(a,b)
//关系运算 > < >= <= != ==
fmt.Println(a>b)
fmt.Println(a<b)
fmt.Println(a>=b)
fmt.Println(a<=b)
fmt.Println(a==b)
fmt.Println(a !=b )
fmt.Println(a,b)
8.3 浮点数类型
浮点数用于表示带小数的数字，go 提供float32和float64两种浮点类型
package main
import (
"fmt"
)
func main(){
name := ""
fmt.Print("请输入你的名字:")
fmt.Scan(&name)
fmt.Println("你输入的名字是:",name)
age := 0
fmt.Println("你输入的年龄是:",age)
msg := ""
fmt.Print("请输入你的msg:")
fmt.Scan(&msg)
fmt.Println("你输入的msg是:",msg)
}
8.4 格式化输出
#使用fmt.Printf 进行格式化参数输出，占位符
%b 二进制
%c 以字符的方式打印
%d 以整数方式打印，十进制
%T 打印变量所属的类型
8.5 枚举类型
常使用iota 生成器用于初始化一系列相同规则的常量，批量声明常量的第一个常量使用iota进行赋值，此时iota被重置为0，其他常量省略类型和赋值，在每初始化一个常量则加1
package main
import "fmt"
func main() {
const (
c1 int = iota
c2
c3
c4
)
fmt.Println(c1,c2,c3,c4)
}
8.6 指针类型
#指针声明需要指定存储地址中对应数据的类型，并使用*作为类型前缀，指针变量声明后会被初始化为nil，表示空指针
package main
import "fmt"
func main() {
A := 2
B := A
fmt.Println(A,B)
C := &A
fmt.Println(C)
fmt.Println(*C)
*C = 5
fmt.Println(A)
}
8.7 字符串类型
Go内置了字符串类型，使用string 表示
9.注释
#go 支持两种注释方式,行注释和块注释
行注释: 以// 开头
块注释: 以/* */
10 打印
可以通过打印来调试代码
package main
import "fmt"
func main() {
var a = 1
fmt.Println(a)
a = a + 3
fmt.Println(a)
}
10.1 输出
package main
import "fmt"
func main(){
fmt.Println("1. 我叫星星") // 打印并换行
fmt.Println("2.我叫星星")
fmt.Print("3. 我叫星星") //打印
fmt.Print("4.我叫星星")
name := "星星"
fmt.Printf("5.我叫%s", name) //打印并占位
fmt.Printf("6.我叫%s",name)
}
#printf 格式化输出，
10.2 输入
package main
import "fmt"
func main(){
var name string
fmt.Print("请输入你的名字：")
fmt.Scan(&name) // 接收控制台输入内容赋值给变量name
// &name => 取name 指针(地址)
fmt.Println("你输入的内容是:", name)
}