go入门篇1
一、go语言环境搭建
1.1 常用命令
go env
go version
1.2 一些基础的语法
- 自动类型推导
a: = 20
b: = "hello"
- 定义变量
var name string = "jack"
- 多重赋值
a,b,c := 10,10,20
- 输出格式
Printf()必须带格式输出
Print(),Println()不需要带格式
%f 默认保留6位
a := 9
b := 21.721782
fmt.Printf("%d %f",a, b)
- 输入格式
scan不需要输入占位符:如%s %d
scanf则需亚输入占位符
func main(){
var name string
var age int
fmt.Println("请输入name和age")
fmt.Scanf("%s %d",&name, &age)
fmt.Println(name, age)
}
- 查看数据类型
func main(){
flag := true
fmt.Printf("%T", flag)
}
1. 3 基本的数据类型
- bool
- int
- float
单精度float32(小数位数7位),双精度float64(小数位数15位)
- byte uint8
- int
- string
go中一个汉字占3个字符
- 枚举类型
1.4 格式化输入输出
- 多进制输出
func main(){
var num int = 139
fmt.Printf("%b\n",num)
fmt.Printf("%o\n",num)
fmt.Printf("%x\n",num)
fmt.Printf("%X",num)
var b int = 19
var c int = 012
var d int = 0xa1
fmt.Println(b, c, d)
}
1.5 常量的定义
- 常量的地址不允许访问
func main(){
const A int = 89
fmt.Println(A)
}
- 字面常量
比如下面的29就是字面常量
var num a = 289
num = num + 29
1.6 iota枚举类型
- 被定义为iota的值与上面的枚举的值没有关系
func main(){
const(
a = iota
b
c
d = 20
e,f = iota, iota
)
println(a)
println(b)
println(c)
println(d)
println(e)
println(f)
}
func main(){
const(
a = "jay"
b = "jkk"
c = "as"
d = "dss"
e,f = "sd", iota
)
println(a)
println(b)
println(c)
println(d)
println(e)
println(f)
}
二、变量，值类型，引用类型
2.1 全局变量
var(
v_name v_type = v_value
)
var (
name string = "jack"
age int = 39
)
func main(){
fmt.Println(name)
fmt.Println(age)
}
2.2 值类型和引用类型
2.2.1 值类型
赋值操作操作的是变量的值
2.2.2 引用类型
赋值操作操作的是变量的地址
2.3 交换两个变量的值
/*
以下方法的前提是:a,b的类型相同
*/
a,b = b,a
2.4 空白标识符’_’
func main(){
var name int
var age int
name,_,age = value()
fmt.Println(name, age)
}
func value()(int,int,int){
a,b,c := 23,23,44
return a,b,c
}
三、go语言条件语句
3.1 switch语句
- case后面默认有break,如果我们需要执行后面的 case，可以使用 fallthrough
- fallthrough 会强制执行后面的 case 语句
package main
import "fmt"
func main(){
var num int
fmt.Scanf("%d", &num)
switch num {
case 1:fmt.Println("这是1")
case 2:fmt.Println("这是2")
fallthrough
case 3:fmt.Println("这是3")
case 4:fmt.Println("这是4")
default:
fmt.Println("默认执行的数据")
}
3.2 select语句
四、go语言循环语句
4.1 for-each range对数组进行遍历
func main(){
var list = [5]int32{
1,2,3,4,5}
for num := range list{
fmt.Println(num)
}
}
4.2 break跳出循环
func main(){
flag:
for i:=0; i < 9; i= i + 2{
if i > 7 {
print("此时的i已经大于7了",i)
break flag
}
}
}
4.3 continue语句跳出当前循环
func main(){
for i := 0; i < 4; i++ {
if i == 3{
continue
}
fmt.Println(i)
}
}
4.4 goto语句跳转到指定行
func main(){
for i := 0; i < 4; i++ {
if i == 2{
goto flag
}
fmt.Println(i)
}
flag:
fmt.Println("跳转到这里了")
}
五、go语言函数
5.1 函数的格式
func func_name(param_list)(return_type_list){
body}
5.2 举例
func cal()(int, int, int){
return 1,3,3
}
func main(){
a,b,c := cal()
fmt.Println(a,b,c)
}
六、数组
6.1 数组的定义及使用
- 声明数组:var list [6]int
func main() {
//声明数组
var list [6]int
//给数组赋值
for i := 0; i < 6; i++ {
fmt.Println("请输入数字")
fmt.Scan(&list[i])
}
for i := 0; i < len(list); i ++{
fmt.Println(list[i])
}
}
- 声明并初始化数组：var list = [5]int{1,2,3,4,5}
func main() {
//声明数组
var list = [5]int{
1,2,3,4,5}
for num := range list{
fmt.Println(num)
}
}
- 只初始化数组中的个别元素：var list = […]int{1:4, 6:49}
func main() {
//声明数组
var list = [...]int{
1:4, 6:49}
for num := range list{
fmt.Println(list[num])
}
}
- 声明二维数组: var list [3][2] int
- 声明并且初始化二维数组
func main() {
//声明数组
var list = [2][2]int{
{
1,2},
{
3,4},
}
for i := 0; i < 2; i++{
for j := 0; j < 2; j++{
fmt.Println(list[i][j])
}
}
}
6.2 数组作为参数传递到函数中
七、指针
7.1 指针的简介
- 指针的含义
简单的来说，指针存储的是数据的地址
7.2 指针数组
func main(){
var list = [3] int {
1,2,3}
var str [3] *int
for i := 0; i < 3; i++{
str[i] = &list[i]
}
for i := 0; i < 3; i++{
fmt.Println(*str[i])
}
}
八、结构体
8.1定义及使用结构体
func main(){
type student struct{
name string
age int
address string
}
stu1 := student{
"jack", 15, "西安"}
stu2 := student{
name: "jack", age: 15, address: "西安"}
fmt.Println(stu1.name)
fmt.Println(stu2.name)
}
8.2 结构体作为函数参数
func show_Student(stu Student){
if stu != (Student{
}){
fmt.Println("学生的姓名是:",stu.name)
fmt.Println("学生的年龄是:",stu.age)
fmt.Println("学生的地址是:",stu.address)
}
}
func main(){
var stu3 Student
stu3 = Student{
"jack", 23, "西安"}
show_Student(stu3)
}
九、go语言切片
9.1 切片含义
切片就是动态数组
9.2 定义切片
var slice1 []type = make([]T, length, capacity)
9.3 切片初始化
func main(){
slice := make([]int, 4, 9)
//slice = [] int{1,2,3}
fmt.Println(len(slice))
fmt.Println(cap(slice))
}
9.5 切片截取
func main(){
slice := make([]int, 4, 9)
//slice = [] int{1,2,3}
fmt.Println(len(slice))
fmt.Println(cap(slice))
}
9.6 append和copy方法
- append
func main() {
str := [] int{
1,2,3}
str1 := append(str, 3)
fmt.Println(len(str), cap(str))
fmt.Println(len(str1), cap(str1))
fmt.Println(str1, str)
}
3 3
4 6
[1 2 3 3] [1 2 3]
- copy
func main() {
str := [] int{
1,2,3}
var slice [] int = make([]int, len(str), (cap(str))*2)
fmt.Println(len(slice))
fmt.Println(cap(slice))
copy(slice, str)
fmt.Println(slice)
}
- 对切片进行遍历
func main() {
str := [] int{
1,2,3}
for index, value := range str{
fmt.Println(index, value)
}
}
十、map
10.1 定义map
var my_map map[string]string
my_map = make(map[string]string)
10.2 使用map
my_map = make(map[string]string)
my_map["name"] = "jack"
my_map["age"] = "20"
my_map["address"] = "西安"
10.3 遍历map
for key := range my_map{
fmt.Println(key, my_map[key])
}
10.4 删除map中的元素
delete(my_map, "name1")
十一、go类型转换
11.1 go不支持隐式转换结果
var num1 int8 = 5
var num2 int16
num2 = num1
结果：
# command-line-arguments
.\test1.go:8:7: cannot use num1 (type int8) as type int16 in assignment
11.2 只能进行强制类型转换
- convert_type(convert_value)
func main() {
var num1 int8 = 5
var num2 int16
num2 = int16(num1)
fmt.Println(num2)
}