脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - Go语言七篇入门教程二程序结构与数据类型

Go语言七篇入门教程二程序结构与数据类型

2021-12-01 11:08小生凡一 Golang

这篇文章主要为大家介绍了Go语言的程序结构与数据类型，本篇文章是Go语言七篇入门系列文，有需要的朋友可以借鉴参考下，希望能够有所帮助

1. 程序结构

1.1 名称

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

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

大写可以！

Go语言七篇入门教程二程序结构与数据类型

小写不行！

Go语言七篇入门教程二程序结构与数据类型

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

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

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

Go语言七篇入门教程二程序结构与数据类型

1.2 声明

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

var 变量名 类型

例如：

?
1
2
3
4
5
func main(){
    var fanOne string
    var xiaoSheng int
    var a,b,c = true , 6.6 , "fanOne" //bool ,float , string
}

当然也可以使用:=

例如

?
1
2
3
4
5
func main(){
    fanOne:="666" //string字符串
    xiaoSheng := 666  //int整型
    a,b,c := true , 6.6 ,"fanOne"  //bool ,float , string
}

1.3 注释

可以用

?
1
2
3
4
5
//单行注释
 
/*
多行注释
*/

1.4 单双引号

?
1
2
3
4
5
6
7
8
9
10
11
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 输出

?
1
//Println 自带换行 Printf 格式化输出

Go语言七篇入门教程二程序结构与数据类型

Go语言七篇入门教程二程序结构与数据类型

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函数则分别提取复数的实部和虚部：

?
1
2
3
4
5
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

当然我们也可以像这样

?
1
2
x := 1 + 2i
y := 3 + 4i

2.4 布尔型

只有两种可能true或者式false

?
1
2
var fanOne true
var xiaoSheng false

2.5 字符串

?
1
2
3
4
5
6
func main(){
    s:="FanOne"
    fmt.Println(len(s)) //6
    fmt.Println(s[:3])  //Fan
    fmt.Println(s[1],s[2]) // 97 110
}

字符串拼接

?
1
2
3
4
5
6
func main(){
    s:="FanOne"
    b := "666"
    y := s + b
    fmt.Println(y) //FanOne666
}

字符串转int

?
1
num,err:=strconv.Atoi("666")//num就是整型

int 转 字符串

?
1
str := strconv.Itoa(666) //str是字符串

2.6 常量

?
1
2
const a = 666
fmt.Println(a) //666

2.7 数组

?
1
2
3
4
var a [3]int //3个整数的数组
for i , v := range a {
    fmt.Println(i,v) 
}
?
1
2
3
4
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时，需要传入一个参数指定切片的长度，如果只指定长度，则切片的容量和长度相等。也可以传入两个参数分别指定长度和容量。不允许创建容量小于长度的切片。

?
1
2
3
4
5
6
7
8
9
10
// 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)

通过切片字面量来声明切片。

?
1
2
3
4
5
6
7
// 通过字面量声明切片，其长度和容量都为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）。这种方式下，切片的长度和容量的计算方式为：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 创建一个整型切片
// 其长度和容量都是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 表来实现的。

声明

?
1
2
3
4
/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type
/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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方法删除

?
1
delete(fan , "One")

2.10 结构体

结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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

?
1
2
3
4
5
6
7
8
9
10
11
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 条件语句

?
1
2
3
4
5
6
7
8
func main(){
    x :=1
    if x == 1 {
        fmt.Println("666")
    } else {
        fmt.Println("999")
    }
}

3.2 选择语句

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 循环语句

?
1
2
3
4
5
sum := 0
for i := 0; i < 10; i++ {
    sum += i
}
?
1
2
3
4
s := [3]int{1,2,3}
for _,item := range s{
    fmt.Println(item)
}

以上就是Go语言七篇入门程序结构与数据类型的详细内容，更多关于Go语言程序结构与数据类型的资料请关注服务器之家其它相关文章！

如何学习Go

如果你是小白，你可以这样学习Go语言~

七篇入门Go语言

第一篇：Go简介初识

第三篇：函数方法接口的介绍

第四篇：通道与Goroutine的并发编程

第五篇：文件及包的操作与处理

第六篇：网络编程

第七篇：GC垃圾回收三色标记

原文链接：https://blog.csdn.net/weixin_45304503/article/details/119333942

  • 数据类型
  • 程序结构
  • GO语言

    • 延伸 · 阅读

    精彩推荐
    • Golanggolang的httpserver优雅重启方法详解

      golang的httpserver优雅重启方法详解

      这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      helight2992020-05-14
    • GolangGolang中Bit数组的实现方式

      Golang中Bit数组的实现方式

      这篇文章主要介绍了Golang中Bit数组的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      天易独尊11682021-06-09
    • GolangGolang通脉之数据类型详情

      Golang通脉之数据类型详情

      这篇文章主要介绍了Golang通脉之数据类型，在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等，Go语言中标识符允许由...

      羌4272021-11-24
    • Golanggo语言制作端口扫描器

      go语言制作端口扫描器

      本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。 ...

      脚本之家3642020-04-25
    • Golanggolang如何使用struct的tag属性的详细介绍

      golang如何使用struct的tag属性的详细介绍

      这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍，从例子说起，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看...

      Go语言中文网11352020-05-21
    • Golanggolang json.Marshal 特殊html字符被转义的解决方法

      golang json.Marshal 特殊html字符被转义的解决方法

      今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 ...

      李浩的life12792020-05-27
    • Golanggo日志系统logrus显示文件和行号的操作

      go日志系统logrus显示文件和行号的操作

      这篇文章主要介绍了go日志系统logrus显示文件和行号的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      SmallQinYan12302021-02-02
    • Golanggolang 通过ssh代理连接mysql的操作

      golang 通过ssh代理连接mysql的操作

      这篇文章主要介绍了golang 通过ssh代理连接mysql的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      a165861639710342021-03-08
    最近更新
    编辑推荐
    阅读排行
    热门标签
    gosublime 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图