Go语言基础数据类型

前言

学无止境，无止境学。坚持每天学点编程知识，坚持每天写点小文章，坚持每天进步一点点。大家好，我是张大鹏，喜欢学习和分享，希望能够通过此公众号，将自己学到的东西分享给大家，和大家一起交流，一起成长，一起进步。

乾坤未定，你我皆是黑马。大鹏一日同风起，扶摇直上九万里。宝剑锋从磨砺出，梅花香自苦寒来。不积跬步，无以至千里，不积小流无以成江海。

如果有多余的时间，就坚持学习吧，小时候学习改变命运，长大了学习丰富内涵，老了学习带来宁静。活到老，学到老，我能行！

概述

课程说明

《Go语言零基础入门班》收费说明：

本篇文章是《Go语言零基础入门班》的第2篇文章，前面还有：

《Go语言快速入门》

数字类型

Go语言数字类型概述

Go语言主要提供了如下数字类型：

整数

浮点数

复数

其中复数的使用场景较少，在一般的开发中几乎不会被用到，可以只做了解。

整数

Go语言分别支持有符号和无符号两种整数类型，提供了四种大小的整数：

int8、uint8

int16、uint16

int32、uint32

int64、uint64

另外还有一种便捷的数字类型，int和uint，这种数据类型会根据当前操作系统的不同而自动改变大小，是一种推荐的整数类型。

示例：整数的基本用法

package main

import "fmt"

func main() {

// ● int8、uint8

var num1 int8 = 1

var num2 uint8 = 1

fmt.Printf("%T: %v\n", num1, num1)

fmt.Printf("%T: %v\n", num2, num2)

// ● int16、uint16

var num3 int16 = 1

var num4 uint16 = 1

fmt.Printf("%T: %v\n", num3, num3)

fmt.Printf("%T: %v\n", num4, num4)

// ● int32、uint32

var num5 int32 = 1

var num6 uint32 = 1

fmt.Printf("%T: %v\n", num5, num5)

fmt.Printf("%T: %v\n", num6, num6)

// ● int64、uint64

var num7 int64 = 1

var num8 uint64 = 1

fmt.Printf("%T: %v\n", num7, num7)

fmt.Printf("%T: %v\n", num8, num8)

}

浮点数

Go语言支持float32和float64两种类型的浮点数，float32类型保留6位小数精度，floa

64保留15位小数精度。

示例代码：

package main

import "fmt"

func main() {

var num1 float32 = 1

var num2 float64 = 1

fmt.Printf("%T: %v\n", num1, num1)

fmt.Printf("%T: %v\n", num2, num2)

}

复数

Go语言支持复数，不过这种数据类型在一般的开发中几乎不会被用到，了解即可。

示例代码：

package main

import "fmt"

func main() {

var num1 = 22 + 2i

var num2 = complex(5, 7)

fmt.Println(num1)

fmt.Println(num2)

}

循环

for循环

for循环的基本语法：

for i:=0;i

示例代码：求1-100所有整数的和

package main

import "fmt"

func main() {

sumNum := 0

for i := 0; i < 101; i++ {

sumNum += i

}

fmt.Println(sumNum)

}

while循环

while循环的基本语法：

while 循环条件

示例代码：求1-100所有整数的和

package main

import "fmt"

func main() {

sumNum := 0

i := 0

for i < 101 {

sumNum += i

i++

}

fmt.Println(sumNum)

}

数组

一维数组

定义一维数组的语法是：

arr := [元素个数]元素类型

示例：定义和遍历一维数组

package main

import "fmt"

func main() {

arr := [3]int

for _, v := range arr {

fmt.Println(v)

}

}

二维数组

定义二维数组的语法是：

arr := [外层元素个数][内层元素个数]元素类型

示例：定义和遍历二维数组

package main

import "fmt"

func main() {

arr := [3][3]int{

,

,

,

}

for _, v := range arr {

for _, vv := range v {

fmt.Print(vv, "\t")

}

fmt.Print("\n")

}

}

切片

切片的定义

切片是基于数组的一种动态数据类型，能够动态的修改其长度，非常的灵活。

示例：创建一维和二维的切片

package main

import "fmt"

func main() {

// 一维切片

arr1 := []int

for _, v := range arr1 {

fmt.Println(v)

}

// 二维切片

arr := [][]int{

,

,

,

}

for _, v := range arr {

for _, vv := range v {

fmt.Print(vv, "\t")

}

fmt.Print("\n")

}

}

切片增删改查

切片是Go语言中非常常用的一种数据结构，掌握其常用的增删改查方法非常有必要。

示例：切片的增删改查

package main

import "fmt"

func main() {

// 定义切片

var arr []string

// 添加

arr = append(arr, "a")

arr = append(arr, "b", "c")

fmt.Println(arr)

// 删除

index := 1

arr = append(arr[:index], arr[index+1:]...)

fmt.Println(arr)

// 修改

arr[index] = "cc"

fmt.Println(arr)

// 查询

fmt.Println(arr[0])

}

切片的复制

示例代码1：使用append方法

package main

import "fmt"

func main() {

arr := []string{"a", "b", "C"}

// 复制

var arr1 []string

arr1 = append(arr1, arr...)

fmt.Println(arr1)

fmt.Println(arr)

}

示例代码2：使用copy方法

package main

import "fmt"

func main() {

arr := []string{"a", "b", "C"}

// 复制

var arr1 = make([]string, len(arr))

copy(arr1, arr)

fmt.Println(arr1)

fmt.Println(arr)

}

切片的排序

示例1：整数切片的排序

package main

import (

"fmt"

"sort"

)

func main() {

arr := []int

fmt.Println(arr)

// 排序

sort.Ints(arr)

fmt.Println(arr)

}

示例代码2：自定义类型排序

package main

import (

"fmt"

"sort"

)

type Person struct {

Name string

Age int

}

func main() {

arr := []Person{

{"张三", 22},

{"李四", 21},

{"王五", 23},

}

fmt.Println(arr)

// 排序：根据年龄降序

sort.Slice(arr, func(i, j int) bool {

return arr[i].Age > arr[j].Age

})

fmt.Println(arr)

}

映射

映射的增删改查

映射也被称作map或字典，存储的是键值对类型的关系。

示例代码：映射的增删改查

package main

import "fmt"

func main() {

// 创建

m := make(map[string]int)

// 新增

m["a"] = 1

m["b"] = 2

fmt.Println(m)

// 删除

delete(m, "a")

fmt.Println(m)

// 修改

m["b"] = 11

fmt.Println(m)

// 查询

fmt.Println(m["b"])

}

常量

常量的基本定义

示例：定义常量

package main

import "fmt"

func main() {

const PI = 3.14

fmt.Println(PI)

}

常量的自增

示例：使用iota让常量自增

package main

import "fmt"

const (

a = iota

b

c

)

func main() {

fmt.Println(a, b, c)

}

指针

指针的基本用法

示例：指针的获取和使用

package main

import "fmt"

func main() {

var a = 33

// 获取指针

pA := &a

// 通过指针修的值

*pA = 34

// 查看指针的值

fmt.Println(*pA)

}

日期和时间

基本用法

示例：时间的基本用法

package main

import (

"fmt"

"time"

)

func main() {

// 当前时间

now := time.Now()

// 时间戳

fmt.Println(now.Unix())

// 格式化

fmt.Println(now.Format("2006-01-02 15:04:05"))

// 获取年月日

fmt.Println(now.Year(), now.Month(), now.Day(),

now.Hour(), now.Minute(), now.Second())

}

计算时间差

示例代码：计算时间差

package main

import (

"fmt"

"time"

)

func main() {

// 当前时间

now := time.Now()

// 休眠

time.Sleep(time.Second)

// 计算时间差

delta := time.Now().Sub(now)

fmt.Printf("delta: %v\n", delta)

}

总结