GO语言基础语法(1)
[Go语言标准库文档中文版](Go语言标准库文档中文版 | Go语言中文网 | Golang中文社区 | Golang中国 (studygolang.com))
介绍写GO语言的框架，如下
package main //声明文件所在的包，每个GO文件必须要有归属包
import "fmt" //引入程序中需要用的包，为了使用包下的函数 比如Println
func main(){ /main 程序入口
fmt.println("Hello World !") //在控制台输出双引号的内容
}
变量
package main
import (
"fmt"
)
func main() {
var age int //变量声明
age = 18 //变量赋值
fmt.Println("age = ", age) //变量的使用
var age2 int = 19 //变量的声明和赋值可以合成一个，赋值时类型要匹配
fmt.Println("age2 = ", age2)
/*不可以重复定义变量age
var age int = 20
fmt.Println("age = ", age)
//# command-line-arguments
//src\gocode\test1\main\test2.go:15:6: age redeclared in this block
//src\gocode\test1\main\test2.go:8:6: other declaration of age*/
//意思是重复使用变量
}
变量的使用方法:（ps：整个代码一起看，我分开是为了理解）
全局变量：定义在函数外的变量
package main
import "fmt"
//全局变量：定义在函数外的变量
var n7 = 80
var n8 = 6.6
//一般用这种声明全局变量
var (
n9 = 888.6
n10 = "go"
)
局部变量：定义在花括号中的变量
func main() {
//局部变量：定义在花括号中的变量
//第一种：变量使用方式：指定值并赋值
var num int = 18
fmt.Println(num)
//第二种：指定变量类型不给赋值，使用默认值打印
var num2 int //默认值为0
fmt.Println(num2)
//第三种：如果没有写变量的类型，那么根据=后面的值进行判定变量的类型（自动类型推断）
var num3 = 10.26
fmt.Println(num3)
//第四种：省略var 注意 ：= 不能写为=
sex := "男"
fmt.Println(sex)
声明多个变量：方法有三种
//声明多个变量
//第一种
var n1, n2, n3 int
fmt.Println(n1)
fmt.Println(n2)
fmt.Println(n3)
//第二种
var n4, name, n5 = 10, "TOM", 2.5
fmt.Println(n4)
fmt.Println(name)
fmt.Println(n5)
//第三种
n6, height := 5.5, 160
fmt.Println(n6)
fmt.Println(height)
fmt.Println(n7) //打印的全局变量的值
fmt.Println(n8)
fmt.Println(n9)
fmt.Println(n10)
}
数据类型
Golang数据类型有两个大类：
一：基础数据类型
数值型：
整数类型：int，int8，int16，int32，int64，uint，uint8，uint16，uint32，uint64，byte
浮点类型：float32，float64
字符型
没有单独的字符型，使用byte来保存单个字母字符
布尔型
bool
字符串
string
| 数据类型 | 默认值 |
|---|---|
| 整数类型 | 0 |
| 浮点类型 | 0 |
| 布尔类型 | false |
| 字符串类型 | "" |
二：复杂数据类型
指针 数组 结构体 管道 函数 切片 接口 map
基本数据类型
整数类型：存放整数值
Go程序中整型变量在使用时，遵循保小不保大原则 即：在保证程序正确运行下，尽量使用占用空间小的数据类型
//学生年龄：不会太大也没负数，所以选择uint8或者byte
var age byte = 18
fmt.Println(age)
有符号整数类型：正负都有
| 类型 | 有无符号 | 占用存储空间 | 范围 |
|---|---|---|---|
| int8 | 有 | 1字节 | -2^7~2^7-1 |
| int16 | 有 | 2字节 | -2^15~2^15-1 |
| int32 | 有 | 4字节 | -2^31~2^31-1 |
| int64 | 有 | 8字节 | -2^63~2^63-1 |
无符号：没有负数
| 类型 | 有无符号 | 占用存储空间 | 范围 |
|---|---|---|---|
| uint8 | 无 | 1字节 | 0~2^8-1 |
| uint16 | 无 | 2字节 | 0~2^16-1 |
| uint32 | 无 | 4字节 | 0~2^32-1 |
| uint64 | 无 | 8字节 | 0~2^64-1 |
其他整数类型
| 类型 | 有无符号 | 占用存储空间 | 范围 |
|---|---|---|---|
| int | 有 | 32位系统-4字节，64位系统-8字节 | -2^31 |
| uint | 无 | 32位系统-4字节，64位系统-8字节 | 0 |
| rune | 有 | 等价int32 | -2^31~2^31-1 |
| int64 | 无 | 等价uint8 | 0~255 |
ps：golang的整数类型，默认声明为int类型
整型的代码，容易出错的点 ps：代码一起看，分开是为了解释
使用时不可以超出它是范围，否则报错，以下是报错的
package main
import (
"fmt"
"unsafe"
)
func main() {
/*var num1 int8 = 230
fmt.Println(num1)
//# command-line-arguments
//src\gocode\Unit1\main\test4.go:6:18:
//cannot use 230 (untyped int constant) as int8
//value in variable declaration (overflows) 230 超出int8范围，错误*/
%T：查看这个的数据类型，要用printf去格式化才可以用
var num2 uint8 = 20
fmt.Println(num2)
var num3 = 26
//printf函数的作用就是格式化，把num3的类型填充到%T的位置上，%T表示值的类型
fmt.Printf("num3的类型是: %T", num3)
unsafe：想要输出占的字节数，则需要加包unsafe在import里
fmt.Println(unsafe.Sizeof(num3)) //输出占多数字节，
//unsafe用这个要提前加包
}
浮点类型
就是存放小数值的，可正可负，可以用十进制表示，可以用科学计数法表示
package main
import "fmt"
func main() {
var num1 float32 = 3.14
fmt.Println(num1)
var num2 float32 = -3.14
fmt.Println(num2)
var num3 float32 = 314e-2 //科学计数法：3.14*10^-2
fmt.Println(num3)
var num4 float32 = 314e+2 //3.14*10^2
fmt.Println(num4)
var num5 float64 = 314e+2 //e和E一样，大写小写都可以
fmt.Println(num5)
| 类型 | 占用存储空间 | 范围 |
|---|---|---|
| float32 | 4字节 | -3.403E38~3.403E38 |
| float64 | 8字节 | -1.798E308~1.798E308 |
ps：底层存储空间和操作系统无关
ps：浮点类型底层存储：符号位+指数位+尾数位，所以尾数位只存了个大概，很可能会出现精度损失
//浮点数可能会有精度损失，通常情况下建议用float64
var num6 float32 = 666.6666666
fmt.Println(num6)
var num7 float64 = 666.6666666
fmt.Println(num7)
看类型用%T
//go中默认浮点数为：float64
var num8 = 3.14
fmt.Printf("num8的数据类型是: %T", num8)
字符类型 byte= ''
本质就是一个整数，也可以直接参与运算，输出字符的时候，会对相应的码值做一个输出，字母，数字，标点等字符是按照ASCLL进行存储
package main
import "fmt"
func main() {
var c1 byte = 'a' //97
fmt.Println(c1)
var c2 byte = '9' //57
fmt.Println(c2)
//输出的是他们对应的ASCLL码
GOlang字符对应的使用的是UTF-8的编码（Unicode是对应的字符集，UTF-8是Unicode的其中一种编码方案）
var c4 int = '中' //把int换成byte不行，溢出了
fmt.Println(c4)
//汉字字符，底层对应的是Unicode码值
//对应的码值是20013，byte类型溢出，可以用int
%c:想显示对应字符，必须采用格式化输出,用%c ，没有%c就是数字
var c5 byte = 'A'
fmt.Printf("c5对应的具体字符为: %c", c5) //A
转义字符
| 转义符 | 含义 | Unicode值 |
|---|---|---|
| \b | 退回 | \u0008 |
| \n | 换行 | \u000a |
| \r | 回车 | \u000d |
| \t | 制表符（tab） | \u0009 |
| " | 双引号 | \u0022 |
| ' | 单引号 | \u0027 |
| \ | 反斜杠 | \u005c |
package main
import "fmt"
func main() {
//转义字符，这里输出有问题
//用控制台输出，找到其在的文件上面直接输入cmd回车，在写go run test7.go
// \n,换行输出
fmt.Println("aaa\nbbb")
// \b,回退一格接着输出
fmt.Println("aaa\bccc") //aaccc
// \r,光标回到本行开头，后续输入就会替换原有字符
fmt.Println("aaaa\rbbb") //bbba
// \t:制表符，8个为一整体
fmt.Println("aaaa\tbbb") //aaaa bbb
fmt.Println("aaaaaaaa\tbbb") //aaaaaaaa bbb 中间8个空格
// \" 想要输出的带双引号
fmt.Println("\"aaaaaaaa\"") //"aaaaaaa"
}
布尔类型
bool，只允许取值true和false，布尔类型只占一个字节
package main
import "fmt"
func main() {
var flag01 bool = true
fmt.Println(flag01)
var flag02 bool = false
fmt.Println(flag02)
var flag03 bool = 5 < 9
fmt.Println(flag03)
}
字符串类型：
字符串就是一串固定长度的字符连接起来的字符序列
String =""，用双引号 代码如下：连起来看，分开是方便解释
package main
import "fmt"
func main() {
//1.定义一个字符串
var s1 string = "拥抱GOlang"
fmt.Println(s1)
//2.字符串是不可变的：定义了好了，字符的值是不变的
var s2 string = "abc"
s2 = "ffff"
// 语法错误：s2[0]='t'
fmt.Println(s2)
字符串表示形式
//（1）如果字符串中没有特殊的字符，字符串的表示形式用双引号
var s3 string = "kklfajf"
fmt.Println(s3)
//(2)如果字符串中有特殊字符，字符串的表示形式用单引号 ``
var s4 string = `
package main
import "fmt"
func main() {
var flag01 bool = true
fmt.Println(flag01)
var flag02 bool = false
fmt.Println(flag02)
var flag03 bool = 5 < 9
fmt.Println(flag03)
}
`
fmt.Println(s4)
.字符串的拼接效果
var s5 string = "abc" + "def"
s5 += "hijk"
fmt.Println(s5)
//当一个字符串过长时，注意加号保留在上一行最后
var s6 string = "abc" + "def" + "abc" + "def" +
"abc" + "def" + "abc" + "def" + "abc" +
"def" + "abc" + "def" + "abc" + "def"
fmt.Println(s6)
}
