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 循环语句
最后

1. 程序结构

1.1 名称

如果一个实体名称在函数中声明，它只在函数局部有效。如果声明在函数外，它将对包里面的所有源文件可见。

实体第一个字母的大小写决定其可见性是否跨包。如果名称是以大写字母的开头，它是导出的，意味着它对外包来说是可见的可访问的，可以被自己包外的其他程序所引用。

大写可以！

小写不行！

并且Go语言常常会使用驼峰式的风格命名

func main() {FanOne := "666" //大驼峰 （注意！一般函数内部都是用小驼峰，局部变量，大驼峰一般用于函数的命名，需要外包的导出）fanOne := "666" //小驼峰
}

当然可以使用下划线比如，不过我还是比较驼峰式~

1.2 声明

go语言可通过var进行变量的声明
var 变量名类型

例如：

func main(){var fanOne string var xiaoSheng intvar 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 runed = '1'a := 'a'b := "a"c := `'a'':"b"`  //可以把单引号和双引号整括起来fmt.Printf("%T\n",d)     // int32fmt.Printf("%T\n",a)  // int32fmt.Printf("%T\n",b)  // stringfmt.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)) //6fmt.Println(s[:3])  //Fanfmt.Println(s[1],s[2]) // 97 110
}

字符串拼接

func main(){s:="FanOne"b := "666"y := s + bfmt.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: 9s2 := baseStr[1:3]
fmt.Printf("len: %d, cap: %d\n", len(s2), cap(s2)) // len: 2, cap: 9s3 := baseStr[:3]
fmt.Printf("len: %d, cap: %d\n", len(s3), cap(s3)) // len: 3, cap: 10ss1 := 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 stringage intsex 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 := 0for i := 0; i < 10; i++ {sum += i}

 s := [3]int{1,2,3}for _,item := range s{fmt.Println(item)}

最后

小生凡一，期待你的关注。

【七天入门Go语言】程序结构数据类型 | 第二天相关推荐

[Go语言入门] 02 Go语言程序结构
文章目录 02 Go语言程序结构 2.1 Go语言的一些基本概念 2.2 go源文件的代码结构 2.3 Go项目的基本文件结构 2.4 实战:创建一个模块 2.5 实战:从另一个模块调用刚创建的模块 ...
GTK+编程入门(2)—GTK+程序结构
GTK+编程入门(2)-GTK+程序结构(2015-7-23) 分类:GTK+ 现在是晚上,快到睡觉时间了.把这小节完整看完是不可能了,索性就先开个头.这节的内容是通过一个最简单的GTK+程序的分 ...
C语言程序结构的特点
C语言程序结构的特点 C语言程序结构的特点 C语言程序结构的特点 1.一个程序由一个或多个源程序文件组成: 2.函数是C程序的主要组成部分 3.函数的组成 4.程序总是从main函数开始执行 5. 在 ...
C语言入门教程|| C语言程序结构|| C语言基本语法
在我们学习 C 语言的基本构建块之前,让我们先来看看一个最小的 C 程序结构,在接下来的章节中可以以此作为参考. C 程序主要包括以下部分: 预处理器指令函数变量语句 & 表达式注释 ...
python语言入门p-python语言程序设计基础(第2版)课后答案嵩天
嵩天等程序设计基础(Python语言)习题答案?本书系统地介绍了Python程序设计语言和程序设计的基本方法.从Python语言发展历史.配置环境开始,详细介绍了Python语言的各种数据类型.程序编 ...
学C的第一天（初识C语言、VS创建C语言程序、数据类型简单了解、简单了解变量）
========================================================================= 相关代码gitee自取:C语言学习日记: 加油努力 ...
JAVA学习笔记 03 - JAVA语言程序结构
本文是Java基础课程的第三课.计算机语言的程序结构无外乎顺序结构.分支结构.循环结构,本文主要介绍Java语言中这些程序结构是如何实现的文章目录一.程序结构二.分支结构 1.单分支if语句 2 ...
简述单片机c51语言程序结构,单片机C51程序结构
<单片机C51程序结构>由会员分享,可在线阅读,更多相关<单片机C51程序结构(14页珍藏版)>请在人人文库网上搜索. 1.1 C51程序流程与控制C语言是一种结构化的编程语言 ...
单片机c语言程序结构,科学网—单片机C语言－程序结构 - 李飞的博文
单片机C语言-程序结构已有 651 次阅读 2011-3-30 22:29 |系统分类:科研笔记先来复杂说说C言语的标识符和关键字. 标识符是用来标识源程序中某个对象的名字的, 可以写做" ...

【七天入门Go语言】程序结构数据类型 | 第二天

目录

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语言】程序结构数据类型 | 第二天相关推荐

最新文章

热门文章

【七天入门Go语言】程序结构 数据类型 | 第二天

目录

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语言】程序结构 数据类型 | 第二天相关推荐

最新文章

热门文章

【七天入门Go语言】程序结构数据类型 | 第二天

【七天入门Go语言】程序结构数据类型 | 第二天相关推荐