package main // 声明main包
import( // 导入包
"fmt"
)
func main(){ // 声明main主函数
fmt.Println("hello worod") // 打印输出
}
func 函数名(形式参数列表)(返回值列表){
函数体
}
// 形式参数包括形式参数名以及参数类型
// 返回值列表描述了返回值的变量名以及类型
var a, b *int // 声明，此处a,b即为指针
var(
a int
b string
c []float32
)
/*
Go语言的基本类型有：
bool
string
int、int8、int16、int32、int64
uint、uint8、uint16、uint32、uint64、uintptr
byte // uint8 的别名
rune // int32 的别名 代表一个 Unicode 码
float32、float64
complex64、complex128
当一个变量被声明之后，系统自动赋予他该类型的零值：
int 0
float 0.0
bool false
string ""
指针 nil
*/
var 变量名 类型 = 表达式 // 变量初始化标准格式
var 变量名 = 表达式 // 编译器推导类型的格式
变量名 := 表达式 // 短变量声明并初始化
i,j := 1, 2 // 简短变量声明语句，定义变量同时显示初始化
i, j = j, i // 多重赋值，交换
// 匿名变量：下划线“_”在go中称为空白标识符
/* 二、变量的作用域 */
/*
全局变量，函数体外,声明全局变量必须用var关键字声明，私有变量首字母小写，公有变量首字母大写
局部变量，函数体内
形式参数，形参，函数名变量后括号中的变量
*/
/* 三、数据类型转换 */
a := 5.0
b := int(a)
/* 四、指针 pointer */
/*
每个变量都拥有地址，指针的值就是地址
要明白指针，需要知道几个概念：指针地址、指针类型和指针取值
v 代表被取地址的变量，变量 v 的地址使用变量 ptr 进行接收，
ptr 的类型为*T，称做 T 的指针类型，*代表指针
*/
func main() {
// 准备一个字符串类型
var house = "Malibu Point 10880, 90265"
// 对字符串取地址, ptr类型为*string，称为指针
ptr := &house
// 打印ptr的类型
fmt.Printf("ptr type: %T\\n", ptr) // T型数据 ptr type: *string
// 打印ptr的指针地址
fmt.Printf("address: %p\\n", ptr) // address: 0xc0420401b0
// 对指针进行取值操作
value := *ptr
// 取值后的类型
fmt.Printf("value type: %T\\n", value) // value type: string
// 指针取值后就是指向变量的值
fmt.Printf("value: %s\\n", value) //value: Malibu Point 10880, 90265
}
/*
1、对变量进行取地址操作使用&操作符，可以获得这个变量的指针变量
2、指针变量的值是指针地址
3、对指针变量进行取值操作使用*操作符，可以获得指针变量只想的原始变量的值
*/
// 使用指针修改值，交换函数
func swap(a, b *int) {
// 取a指针的值, 赋给临时变量t
t := *a
// 取b指针的值, 赋给a指针指向的变量
*a = *b
// 将a指针的值赋给b指针指向的变量
*b = t
}
func main() {
// 准备两个变量, 赋值1和2
x, y := 1, 2
// 交换变量值
swap(&x, &y)
// 输出变量值
fmt.Println(x, y) // 2 1
}
// 创建指针的另一种方法——new() 函数
str := new(string)
*str = "Go语言教程"
fmt.Println(*str)
// new() 函数可以创建一个对应类型的指针，创建过程会分配内存，被创建的指针指向默认值。
/* --> 五、变量逃逸分析*/
/*
1、栈：线性表数据结构，栈只允许从线性表的同一端放入和取出数据，按照新进先出的顺序
*/
func calc(a, b int) int {
var c int
c = a * b
var x int
x = c * 10
return x
}
/*
上面代码会进行变量 c 和 x 的分配过程。Go语言默认情况下会将 c 和 x 分配在栈上，这两个变量在 calc()
函数退出时就不再使用，函数结束时，保存 c 和 x 的栈内存再出栈释放内存，
整个分配内存的过程通过栈的分配和回收都会非常迅速
*/
/*
变量逃逸--自动决定变量分配方式，提高运行效率
Go语言将这个过程整合到了编译器中，命名为“变量逃逸分析”。
通过编译器分析代码的特征和代码的生命周期，决定应该使用堆还是栈来进行内存分配。
编译器觉得变量应该分配在堆和栈上的原则是：
变量是否被取地址
变量是否发生逃逸
*/
/* --> 六、常量，*/
const name [type] = value // 常量声明语句格式
const b string = "abd" // 显式类型定义
const b = "abc" // 隐式类型定义
const (
a = 1
b
c = 2
d
)
fmt.Println(a, b, c, d) // "1 1 2 2"
// iota 常量生成器
type Weekday int // 定义一个Weekday 命名类型
const (
Sunday Weekday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
)
/* --> 七、模拟枚举*/
type Weapon int // 定义新的数据结构体
const (
Arrow Weapon = iota // 开始生成枚举值, 默认为0
Shuriken
SniperRifle
Rifle
Blower
)
// 输出所有枚举值，如上iota会从0依次增加
fmt.Println(Arrow, Shuriken, SniperRifle, Rifle, Blower) // 0 1 2 3 4
// 使用枚举类型并赋初值
var weapon Weapon = Blower
fmt.Println(weapon) // 4
/*
1、注意：一个const声明内的每一行常量声明，将会自动套用前面的iota格式，并自动增加
*/
type ChipType int
const (
None ChipType = iota
CPU // 中央处理器
GPU // 图形处理器
)
func (c ChipType) String() string {
switch c {
case None:
return "None"
case CPU:
return "CPU"
case GPU:
return "GPU"
}
return "N/A"
}
func main() {
// 输出CPU的值并以整型格式显示
fmt.Printf("%s %d", CPU, CPU)
}
/*
String() 方法的 ChipType 在使用上和普通的常量没有区别。
当这个类型需要显示为字符串时，Go语言会自动寻找 String() 方法并进行调用。
*/
/* --> 八、类型别名*/
// 将NewInt定义为int类型
type NewInt int
// 将int取一个别名叫IntAlias
type IntAlias = int
func main() {
var a NewInt
// 查看a的类型名
fmt.Printf("a type: %T\\n", a) // a type: main.NewInt
// 将a2声明为IntAlias类型
var a2 IntAlias
// 查看a2的类型名
fmt.Printf("a2 type: %T\\n", a2) // a2 type: int
}
/*
结果显示 a 的类型是 main.NewInt，表示 main 包下定义的 NewInt 类型，
a2 类型是 int，IntAlias 类型只会在代码中存在，编译完成时，不会有 IntAlias 类型。
*/
/* --> 九、字符串和数值类型的相互转换*/
ltoa() // 整型转字符串，函数签名func Itoa(i int) string
Atoi() // 字符串转整型，函数签名func Atoi(s string) (i int, err error)
ParseBool() // 字符串转换为bool类型值，函数签名func ParseBool(str string) (value bool, err error)
Parselnt() // 字符串转换为整数值（包括正负号），函数签名func ParseInt(s string, base int, bitSize int) (i int64, err error)
ParseUnit() // 字符串转换为整数值（不包括正负号），函数签名func ParseUint(s string, base int, bitSize int) (n uint64, err error)
ParseFloat() // 浮点数字符串转为float，函数签名func ParseFloat(s string, bitSize int) (f float64, err error)
FormatBool() // bool类型转换为字符串，函数签名func FormatBool(b bool) string
FormatInt() // 整型转换为字符串，函数签名func FormatInt(i int64, base int) string
FormatUint() // 整型转换为字符串（无符号的uint64类型），函数签名func FormatUint(i uint64, base int) string
FormatFloat() // 浮点转换为字符串，函数签名func FormatFloat(f float64, fmt byte, prec, bitSize int) string
AppendBool() // append系列函数和format系列函数使用方法类似，append多了将转换后结果追加到一个切片中
AppendFloat()
AppendInt()
AppendUint()
閱讀更多 消逝的初心 的文章
