快速入门GO语言之Lesson00-基础语法
**
快速入门GO语言之Lesson00-基础语法
**
一、基本常识
1、go语言只有一个入口函数main，一个文件夹代表一个工程，每个工程只能有一个main
2、打印，Println（）会自动换行
3、调用函数，大部分都需要导入包
4、go语言以包作为管理单位，每个文件必须先声明包
5、程序必须要一个main包
6、go语言每一行的结尾没有“；”结尾
二、cmd命令
1、go build xxx.go //编译go代码，生成一个可执行程序，运行可执行程序xxx.exe
2、cls 清屏命令
3、go run xxx.go //不生成可执行文件，直接编译运行
三、数据类型
1、数据类型的作用：告诉编译器变量应该以多大的内存存储
2、变量命名规范：
a、字母，数字，下划线
b、不能以数字开头
c、名字不能是关键字
d、大小写区分
四、变量声明
1、声明格式：var 变量名 数据类型 //声明的变量必须使用
2、没有初始化的变量，默认值为0
3、同一个函数内的变量声明唯一，可以同时声明多个同一类型的变量
4、自动推导类型，必须初始化通过初始化的值确定类型
五、练习代码块（1）
package main
import "fmt"
func main() { //左括号必须和函数放在同一行
fmt.Println("Hello World!")
var a int
a = 10
fmt.Println("a= ", a)
var b int = 20
fmt.Println("b= ", b)
//自动推导类型
c := 30
fmt.Printf("c type is %T\n", c) //%T打印变量的数据类型
e, f := 10, 20
//传统的方式交换两个变量的值
var temp int
temp = e
e = f
f = temp
//go语言交换两个变量的值
i, j := 10, 20
i, j = j, i
fmt.Printf("i = %d,j = %d\n", i, j)
//匿名变量，丢弃数据不处理
//匿名变量配合函数返回值使用才有意义
temp, _ = e, f
fmt.Printf("temp= %d", temp)
}
// 运行结果
// Hello World!
// a= 10
// b= 20
// c type is int
// i = 20,j = 10
六、练习代码块（2）
package main
import "fmt"
func main() {
//常量的使用
//常量：程序运行区间，不可以改变的量 关键字const
//变量：程序运行区间，可以改变的量
const a int = 10
//a = 20 报错：常量不可修改
const b = 10 //没有":="
fmt.Printf("b type is %T\n", b)
//多个变量或常量的定义
//不同类型变量的声明（定义）
var c int
var d float64
c, d = 10, 3.1415926
fmt.Printf("c = %d,d = %f \n", c, d)
//ctrl+/ 注释和取消注释快捷键
//const i int = 10
//const j float64 = 3.1415926
const (
i = 10
j = 3.1415926
)
fmt.Printf("i = %d,j = %v\n", i, j)
}
// 运行结果
// b type is int
// c = 10,d = 3.141593
// i = 10,j = 3.1415926
七、练习代码块（3）
package main
import "fmt"
func main() {
//iota常量自动生成器，每个一行，自动累加一
//iota给常量赋值使用
const (
a = iota //0
b = iota //1
c = iota //2
)
fmt.Printf("a= %d,b= %d,c= %d\n", a, b, c)
//iota遇到const重置为0
const d = iota
fmt.Printf("d = %d\n", d)
//可以只写一个iota
const (
a1 = iota //0
b1 //1
c1 //2
)
fmt.Printf("a1= %d,b1= %d,c1= %d\n", a1, b1, c1)
//如果是同一行，值都一样
const (
i = iota
j1, j2, j3 = iota, iota, iota
k = iota
)
fmt.Printf("i = %d,j1 = %d,j2 = %d,j3 = %d,k = %d\n", i, j1, j2, j3, k)
}
//运行结果
//a= 0,b= 1,c= 2
//d = 0
//a1= 0,b1= 1,c1= 2
//i = 0,j1 = 1,j2 = 1,j3 = 1,k = 2
八、练习代码块（4）
package main
import "fmt"
func main() {
//bool类型
//1、声明变量
var a bool
a = true
fmt.Println("a = ", a)
//2、自动推导
b := false
fmt.Println("b = ", b)
//浮点型
//1、声明变量
var f1 float32
f1 = 3.1415926
fmt.Println("f1 = ", f1)
var f2 float64
f2 = 3.1415926
fmt.Println("f2 = ", f2)
//字符类型
var ch byte
ch = 97
fmt.Printf("%c = %d\n", ch, ch) //格式化输出，%c以字符串方式打印，%d以整型方式打印
//大小写转化,加减32
fmt.Printf("大写：%d,小写：%d\n", 'A', 'a')
fmt.Printf("大写转小写：%c\n", 'A'+32)
fmt.Printf("小写转大写：%c\n", 'a'-32)
//字符串类型
var str string
str = "abc"
fmt.Println("str = ", str)
//自动推导类型
str2 := "mike"
fmt.Println("str2 = ", str2)
//内建函数，len（）返回字符串长度
fmt.Println("str2 的长度： ", len(str2))
//字符与字符串的区别，字符串都是隐藏了一个结束符
//只有一个字符，转义字符除外
//一个或多个字符组成
var str3 string
str3 = "hello,world"
fmt.Printf("str3 = %c%c%c%c%c\n", str3[0], str3[1], str3[2], str3[3], str3[4])
//复数类型
var t complex128
t = 2.1 + 3.14i
fmt.Println("t = ", t)
//自动推导类型
t2 := 3.3 + 2.2i
fmt.Println("t2 = ", t2)
//通过内建函数，取实部和虚部
fmt.Println("real(t2) = ", real(t2), "imag(t2) = ", imag(t2))
}
//运行结果
// a = true
// b = false
// f1 = 3.1415925
// f2 = 3.1415926
// a = 97
// 大写：65,小写：97
// 大写转小写：a
// 小写转大写：A
// str = abc
// str2 = mike
// str2 的长度： 4
// str3 = hello
// t = (2.1+3.14i)
// t2 = (3.3+2.2i)
// real(t2) = 3.3 imag(t2) = 2.2
九、练习代码块（5）
package main
import "fmt"
func main() {
//类型转换
var flag bool
flag = true
//bool类型不能转换为int，int 不能转换为bool，这种不能转换类型成为不兼容类型
fmt.Printf("flag = %T\n", flag)
var ch byte
ch = 'a'
var t int
t = int(ch)
fmt.Printf("t = %d\n", t)
//类型别名 type
type bigint int64 //给int64起别名为bigint
var a bigint
fmt.Printf("a type is %T\n", a)
type (
long int64
char byte
)
var b long
b = 11
var ch1 char
ch1 = 'e'
fmt.Printf("b = %d,ch1 = %c\n", b, ch1)
}
//运行结果
// flag = bool
// t = 97
// a type is main.bigint
// b = 11,ch1 = e