目录
- 1. 程序结构
- 1.1 名称
- 1.2 声明
- 1.3 注释
- 1.4 单双引号
- 1.5 输出
- 2. 数据类型
- 2.1 整型
- 2.2 浮点型
- 2.3 复数
- 2.4 布尔型
- 2.5 字符串
- 2.6 常量
- 2.7 数组
- 2.8 切片
- 2.9 map
- 2.10 结构体
- 2.11 json
- 3. 流程控制
- 3.1 条件语句
- 3.2 选择语句
- 3.3 循环语句
- 如何学习go
1. 程序结构
1.1 名称
如果一个实体名称在函数中声明，它只在函数局部有效。如果声明在函数外，它将对包里面的所有源文件可见。
实体第一个字母的大小写决定其可见性是否跨包。如果名称是以大写字母的开头，它是导出的，意味着它对外包来说是可见的可访问的，可以被自己包外的其他程序所引用。
大写可以！
小写不行！
并且go语言常常会使用驼峰式的风格命名
func main() {
fanone := "666" //大驼峰 （注意！一般函数内部都是用小驼峰，局部变量，大驼峰一般用于函数的命名，需要外包的导出）
fanone := "666" //小驼峰
}
当然可以使用下划线比如，不过我还是比较驼峰式~
1.2 声明
go语言可通过var进行变量的声明
var 变量名 类型
例如：
func main(){
var fanone string
var xiaosheng int
var a,b,c = true , 6.6 , "fanone" //bool ,float , string
}
当然也可以使用:=
例如
func main(){
fanone:="666" //string字符串
xiaosheng := 666 //int整型
a,b,c := true , 6.6 ,"fanone" //bool ,float , string
}
1.3 注释
可以用
//单行注释 /* 多行注释 */
1.4 单双引号
func main(){
var d rune
d = '1'
a := 'a'
b := "a"
c := `'a'':"b"` //可以把单引号和双引号整括起来
fmt.printf("%t\n",d) // int32
fmt.printf("%t\n",a) // int32
fmt.printf("%t\n",b) // string
fmt.printf("%t\n",c) // string
}
1.5 输出
//println 自带换行 printf 格式化输出
2. 数据类型
2.1 整型
整型数据可以分为两类，有符号和无符号两种类型
有符号: int, int8, int16, int32, int64
无符号: uint, uint8, uint16, uint32, uint64, byte
另外rune是int32的别名
在保证程序正确运行下，尽量使用占用空间小的数据类型
- 不同位数的整型区别在于能保存整型数字范围的大小；
- 有符号类型可以存储任何整数，无符号类型只能存储自然数
- int和uint的大小和系统有关，32位系统表示int32和uint32，如果是64位系统则表示int64和uint64
- byte与uint8类似，一般用来存储单个字符
2.2 浮点型
有 float64 和 float32 两种
- float64的精度要比float32的要准确
- 如果我们要保存一个精度高的数，则应该选择float64
浮点型的存储分为三部分：符号位+指数位+尾数位，在存储过程中，精度会有丢失
go的浮点型默认为float64类型
2.3 复数
有complex64和complex128 ， 二者分别由float32和float64 构成，内置的complex函数根据给定的实部和虚部创建复数，而内置的real函数和img函数则分别提取复数的实部和虚部：
var x complex128 = complex(1,2) //1+2i var y complex128 = complex(3,4) //3+4i fmt.println(x*y) //-5+10i fmt.println(real(x*y)) //-5 fmt.println(imag(x*y)) //10
当然我们也可以像这样
x := 1 + 2i y := 3 + 4i
2.4 布尔型
只有两种可能true或者式false
var fanone true var xiaosheng false
2.5 字符串
func main(){
s:="fanone"
fmt.println(len(s)) //6
fmt.println(s[:3]) //fan
fmt.println(s[1],s[2]) // 97 110
}
字符串拼接
func main(){
s:="fanone"
b := "666"
y := s + b
fmt.println(y) //fanone666
}
字符串转int
num,err:=strconv.atoi("666")//num就是整型
int 转 字符串
str := strconv.itoa(666) //str是字符串
2.6 常量
const a = 666 fmt.println(a) //666
2.7 数组
var a [3]int //3个整数的数组
for i , v := range a {
fmt.println(i,v)
}
var fan [3]int{1,2,3}
var one [3]int{1,3}
t := [...]int{1,2,3} //省略号
fmt.printf("%t",t) //[3]int
go语言的数组的长度是固定的，所以在某些场景下数组存在着它的局限性
而切片的存在就解决了数组长度局限的问题,切片可以看做一个可以自动扩容的数组，但是它跟数组还是有着区别。
2.8 切片
可以通过make或切片字面量来创建和初始化切片，也可以利用现有数组或切片直接创建切片（go语言中的引用类型（slice、map、chan）不能使用new进行初始化）。
使用make时，需要传入一个参数指定切片的长度，如果只指定长度，则切片的容量和长度相等。也可以传入两个参数分别指定长度和容量。不允许创建容量小于长度的切片。
// make只传入一个参数指定长度，则容量和长度相等。以下输出："len: 10, cap: 10"
s := make([]int, 10)
fmt.printf("len: %d, cap: %d\n", len(s), cap(s))
// make 传入长度和容量。以下输出："len: 10, cap: 15"
s := make([]int, 10, 15)
fmt.printf("len: %d, cap: %d\n", len(s), cap(s))
// 不允许创建容量小于长度的切片。下面语句编译会报错："len larger than cap in make([]int)"
s := make([]int, 10, 5)
通过切片字面量来声明切片。
// 通过字面量声明切片，其长度和容量都为5。以下输出：“len: 5, cap: 5”
s := []int{1, 2, 3, 4, 5}
fmt.printf("len: %d, cap: %d\n", len(s), cap(s))
// 可以在声明切片时利用索引来给出所需的长度和容量。
// 通过指定索引为99的元素，来创建一个长度和容量为100的切片
s := []int{99: 0}
基于现有数组或切片来创建切片的方法为：s := basestr[low:high:max]，low指定开始元素下标，high指定结束元素下标，max指定切片能增长到的元素下标。这三个参数都可以省略，low省略默认从下标0开始，high省略默认为最后一个元素下标，max省略默认是底层数组或切片的容量（这里也要注意max不能小于high）。这种方式下，切片的长度和容量的计算方式为：
len = hith - low
cap = max - low
s1 := basestr[1:3:10]
fmt.printf("len: %d, cap: %d\n", len(s1), cap(s1)) // len: 2, cap: 9
s2 := basestr[1:3]
fmt.printf("len: %d, cap: %d\n", len(s2), cap(s2)) // len: 2, cap: 9
s3 := basestr[:3]
fmt.printf("len: %d, cap: %d\n", len(s3), cap(s3)) // len: 3, cap: 10
ss1 := s1[2:5]
ss2 := s1[3:8]
fmt.printf("len: %d, cap: %d\n", len(ss1), cap(ss1)) // len: 3, cap: 7
fmt.printf("len: %d, cap: %d\n", len(ss2), cap(ss2)) // len: 5, cap: 6
增加可以用append
// 创建一个整型切片
// 其长度和容量都是5个元素
slice := []int{1, 2, 3, 4, 5}
// 创建一个新切片
// 其长度为2 个元素，容量为4个元素
newslice := slice[1:3]
// 使用原有的容量来分配一个新元素
// 将新元素赋值为 60
newslice = append(newslice, 6)
fmt.printf("slice: %v\n", slice) // slice: [1 2 3 6 5]
fmt.printf("newslice: %v\n", newslice) // newslice: [2 3 6]
2.9 map
map 是一种无序的键值对的集合。map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，map 是无序的，我们无法决定它的返回顺序，这是因为 map 是使用 hash 表来实现的。
声明
/* 声明变量，默认 map 是 nil */ var map_variable map[key_data_type]value_data_type /* 使用 make 函数 */ map_variable := make(map[key_data_type]value_data_type)
var fan map[string]string //创建集合
fan = make(map[string]string)
//map插入key-value对
fan [ "one" ] = "666"
fan [ "four" ] = "999"
//使用键输出
for value := range fan {
fmt.println(value, "is", fan [value])
}
//查看元素在集合中是否存在
val, ok := fan [ "two" ] //如果确定是真实的,则存在,否则不存在
if ok {
fmt.println("fantwo is", val)
} else {
fmt.println("fantwo not exist")
}
delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。
可以使用delete方法删除
delete(fan , "one")
2.10 结构体
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：
type person struct{
name string
age int
sex string
}
func main(){
person := person{ //初始化
name: "fanone",
age: 16,
sex: "male",
}
fmt.println(person.name) //引用
}
2.11 json
type person struct{
name string `json:"name"` //序列化成string类型
age int `json:"age"`
sex string `json:"sex"`
}
func main(){
person := &person{} //创建一个对象
var data = `{"name":"fanone","age":"11","sex":"male"}`
_ = json.unmarshal([]byte(data), &person) //将这个data序列化成person的结构体，并传入其中
fmt.println(person.name)
}
3. 流程控制
3.1 条件语句
func main(){
x :=1
if x == 1 {
fmt.println("666")
} else {
fmt.println("999")
}
}
3.2 选择语句
switch i {
case 0:
fmt.printf("0")
case 1:
fmt.printf("1")
case 2:
fmt.printf("2")
case 3:
fmt.printf("3")
case 4, 5, 6:
fmt.printf("4, 5, 6")
default:
fmt.printf("default")
}
3.3 循环语句
sum := 0
for i := 0; i < 10; i++ {
sum += i
}
s := [3]int{1,2,3}
for _,item := range s{
fmt.println(item)
}
以上就是go语言七篇入门程序结构与数据类型的详细内容，更多关于go语言程序结构与数据类型的资料请关注www.887551.com其它相关文章！
如何学习go
如果你是小白，你可以这样学习go语言~
七篇入门go语言
第一篇：go简介初识
第三篇：
第四篇：通道与goroutine的并发编程
第五篇：
第六篇：
第七篇：gc垃圾回收三色标记
