Go的基础类型

阅读原文时间：2023年07月09日阅读：6

Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。大写字母和小写字母是不同的：heapSort和Heapsort是两个不同的名字。这个和Python基本相同。

Go语言中类似if和switch的关键字有25个(均为小写)。关键字不能用于自定义名字，只能在特定语法结构中使用。

break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

此外，还有大约30多个预定义的名字，比如int和true等，主要对应内建的常量、类型和函数。

内建常量:
true false iota nil
内建类型:
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
内建函数:
make len cap new append copy close delete
complex real imag
panic recover

扩展（补充）：

　　Python中的关键字

　　在python中若想查询python中有哪些关键字可以先导入keyword模块

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from',
'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass',
'raise', 'return', 'try', 'while', 'with', 'yield']

变量是几乎所有编程语言中最基本的组成元素，变量是程序运行期间可以改变的量。

从根本上说，变量相当于是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。

2.1 变量声明

Go语言的变量声明方式与Python语言有明显的不同。对于纯粹的变量声明， Go语言引入了关键字var，而类型信息放在变量名之后，示例如下：

var v1 int
var v2 int

//一次定义多个变量
var v3, v4 int

var (
v5 int
v6 int
)

Python中不需要提前声明变量，用的时候直接可以拿过去用。

2.2 变量初始化

对于声明变量时需要进行初始化的场景， var关键字可以保留，但不再是必要的元素，如下所示：

package main

import "fmt" //导入包含，必须要使用

func main(){
// 变量，程序运行期间可以改变的量

// 1声明变量  var 变量名  类型  
// 2只是声明没有初始化的变量，默认值为0  
// 3同一个{}里，声明的变量名是唯一的  
var a int  
fmt.Println(a)  //Println有自动换行功能

// 4同时可以声明多个变量  
//var b,c int  
//fmt.Println(b,c)

a =  //变量的赋值  
fmt.Println(a)

// 变量的初始化，声明变量时，同时赋值  
var b int =    //初始化， 声明和赋值同时进行  
b =    //赋值  先声明，后赋值  
fmt.Println(b)

// 自动推导类型，必须初始化，通过初始化的值确定类型  
c :=  
// %T 打印变量所属的类型  
fmt.Printf("c type is %T\\n", c)

自动推导类型：

package main

import "fmt"

func main(){
// 赋值，赋值前，必须先声明变量
var a int
a = // 赋值可以使用n次
fmt.Println("a = ", a)

// :=, 自动推导类型，先声明变量b，再给b赋值给20  
// 自动推导，同一个变量名只能使用一次，用于初始化  
b :=  
fmt.Println("b = ",b)

// b := 30 //前面已经有变量b,不能再建一个变量b

}

补充：printf和println的区别

package main

import "fmt"

func main(){
a :=
// 一段一段处理，自动加换行
fmt.Println("a = ", a)

// 格式化输出，把a的内容放在%d的位置  
fmt.Printf("a = %d\\n", a)

b, c := ,  
fmt.Println("a = ",a, ", b = ", b, ", c =", c )  
fmt.Printf("a = %d, b = %d, c = %d\\n", a,b,c)

}

多重赋值以及匿名变量

_（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃（Python中也有此方法）

package main

import "fmt"

//go函数可以返回多个值
func test()(a,b,c int){
return ,,
}

func main(){
// a := 10
// b := 20
// c := 30
a, b := ,

//交换两个变量的值  
var tmp int  
tmp = a  
a = b  
b = tmp

fmt.Printf("a = %d, b=%d\\n", a,b)

i,j := ,  
i,j = j,i  
fmt.Printf("i = %d,j = %d\\n", i,j)

// \_匿名变量，丢弃数据不处理,匿名变量配合返回值使用，才有优势  
tmp,\_ = i,j  
fmt.Println("tmp = ",tmp)

var c,d,e int  
c,d,e = test()  
fmt.Printf("c = %d, d = %d, e = %d\\n",c,d,e)

\_,d,\_ = test()  
fmt.Println("d = ", d)  
}

在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。

3.1 字面常量(常量值)

所谓字面常量（literal），是指程序中硬编码的常量，如：

3.1415 // 浮点类型的常量
3.2+12i // 复数类型的常量
true // 布尔类型的常量
"foo" // 字符串常量

3.2 常量定义

const Pi float64 = 3.14
const zero = 0.0 // 浮点常量, 自动推导类型

const ( // 常量组
size int64 =
eof = - // 整型常量, 自动推导类型
)
const u, v float32 = , // u = 0.0, v = 3.0，常量的多重赋值
const a, b, c = , , "foo"
// a = 3, b = 4, c = "foo" //err, 常量不能修改

多个变量或常量定义实例：

package main

import "fmt"

func main(){
// 不同类型变量的声明（定义）
//var a int
//var b float64

var (  
    a int  
    b float64  
)

a =  
b = 3.14  
fmt.Println("a=", a)  
fmt.Println("b=", b)

//const i int = 10  
//const j float64 = 3.14

const (  
    i int =  
    j float64 = 3.14  
)

fmt.Println("i = ", i)  
fmt.Println("j = ", j)

}

3.3 iota枚举

常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。

package main

import "fmt"

func main(){
// 1.iota常量生成器，每一行自动加 1
// 2.iota给常量赋值使用
const(
a = iota //
b = iota //
c = iota //
)
fmt.Printf("a = %d, b = %d, c = %d\n", a,b,c)

//3.iota遇到const重置为0  
const d = iota  
fmt.Printf("d = %d\\n", d)

//4.可以只写一个iota  
const(  
    e = iota  
    f  
    g  
)  
fmt.Printf("e = %d, f = %d, g = %d\\n ",e,f,g)

//5.如果是同一行，值都一样  
const (  
    h = iota  
    i, j, k = iota,iota,iota  
    m = iota  
)  
fmt.Printf("h = %d, i = %d, j = %d, k = %d, m = %d",h,i,j,k,m)

　　
}

a = , b = , c =
d =
e = , f = , g =
h = , i = , j = , k = , m =
Process finished with exit code

几个常见的`iota`示例

使用“_”跳过某些值

const (
n1 = iota //
n2 //
_
n4 //
)

iota声明中间插队

const (
n1 = iota //
n2 = //
n3 = iota //
n4 //
)
const n5 = iota //

定义数量级

这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。

const (
_ = iota
KB = << ( * iota)
MB = << ( * iota)
GB = << ( * iota)
TB = << ( * iota)
PB = << ( * iota)
)

4.1 分类

Go语言内置以下这些基础类型：

类型

名称

长度

零值

说明

bool

布尔类型

false

其值不为真即为家，不可以用数字代表true或false

byte

字节型

uint8别名

rune

字符类型

专用于存储unicode编码，等价于uint32

int, uint

整型

4或8

32位或64位

int8, uint8

整型

-128 ~ 127, 0 ~ 255

int16, uint16

整型

-32768 ~ 32767, 0 ~ 65535

int32, uint32

整型

-21亿 ~ 21 亿, 0 ~ 42 亿

int64, uint64

整型

float32

浮点型

0.0

小数位精确到7位

float64

浮点型

0.0

小数位精确到15位

complex64

复数类型

complex128

复数类型

uintptr

整型指针

4或8

⾜以存储指针的uint32或uint64整数

string

字符串

utf-8字符串

4.2 布尔类型

true 对应1

false 对应0

package main

import "fmt"

func main(){
//1 声明变量，没有初始化，零值（初始化值）为False
var a bool
fmt.Println("a = ", a)

a = true  
fmt.Println("a = ", a )

// 自动推导类型  
var b = false  
fmt.Println("b = ",b)

c := false  
fmt.Println("c = ",c)

}

4.3 整型

uint8:无符号8为整型(0—255)

uint16:无符号16位整型(0—65535)

uint32:无符号32位整型(0—4294967295)

uint64:无符号64位整型(0到18446744073709551615)

int8:有符号整型(-128—127)

int16:有符号16位整型(-32768—32767)

int32:有符号32位整型(-2147483648—2147483647)

int64:有符号64位整型

byte:类似uint8,常用于ASCII码字符，美国标准信息交换码，128个最基本的字符，大小写字母，阿拉伯数字，英文标点符号，常用的其他符号。

rune:类似int32

uint:32或64位

int与uint一样大小

uintptr:无符号整型，用于存放一个指针

package main

import "fmt"

func main(){
var v1 int32
v1 =
v2 :=
fmt.Println("v1 = ", v1, " ,v2 = ", v2)
}

4.4 浮点型

float32

float64

package main

import "fmt"

func main(){
// 声明变量
var f1 float32
f1 = 3.14
fmt.Println("f1=", f1)

//自动推导类型  
f2 := 3.14  
fmt.Printf("f2 type is %T\\n", f2)  
// float 64比32存储的更准确

}

4.5 字符类型

在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表utf-8字符串的单个字节的值；另一个是rune，代表单个unicode字符。

package main

import "fmt"

func main(){
var ch byte // 声明字符类型
ch =
// fmt.Println("ch = ", ch)
// 格式化输出，%c以字符方式打印，%d以整型方式打印
fmt.Printf("%c %d\n", ch , ch) // a 97

ch = 'a' //字符，单引号  
fmt.Printf("%c, %d\\n", ch, ch)   // a 97  
//大写转小写，小写转大写  小写比大写大32  
fmt.Printf("大写： %d,  小写： %d\\n", 'A', 'a')   // 大写：65, 小写：97  
fmt.Printf("大写转小写 %c\\n", 'A'+)    // 大写转小写：a  
fmt.Printf("小写转大写： %c\\n", 'a'-)  // 小写转大写：A

}

4.6字符串类型

go语言中要定义一个多行字符串时，就必须使用反引号字符。

s1 := `第一行
　　第二行
　　第三行`
fmt.Println(s1)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串的常用操作

方法

介绍

len(str)

求长度

+或fmt.Sprintf

拼接字符串

strings.Split

分割

strings.contains

判断是否包含

strings.HasPrefix,strings.HasSuffix

前缀后缀判断

strings.Index(),strings.LastIndex()

子串出现的位置

strings.Join(a[]string, sep string)

join操作

package main

import "fmt"

func main(){
var str1 string //声明变量
str1 = "abc"
fmt.Println("str1 = ", str1) // str1 = abc

// 自动推导类型  
str2 := "mike"  
fmt.Printf("str2类型是 %T\\n", str2)  // str2类型是 string

// 内建函数，len()可以测试字符串的长度，有多少个字符，这个和python中的len()用法类似  
fmt.Println("len(str2)=", len(str2))  // len(str2)=4

}

4.7字符和字符串的区别

字符一般都用单引号表示，且只有一个字符，转义字符除外（如‘\n’）

字符串一般有用双引号表示，由一个字符或多个字符所组成，字符串都隐藏一个结束符‘\0’

package main

import "fmt"

func main(){
var ch byte
var str string

//字符  
//1单引号  
//2字符往往都只有一个字符，转义字符除外'\\n'  
ch = 'a'  
fmt.Println("ch = ", ch)

//字符串  
//1双引号  
//2字符串由一个或多个字符组成  
//3字符串都是隐藏一个结束符,'\\0'  
str = "a" // 由'a'和 '\\0'组成一个字符串  
fmt.Println("str=", str)

str = "hello go"  
//只想操作字符串的某个字符，从0开始操作,和python中的索引类似  
fmt.Printf("str\[0\]=%c, str\[1\]=%c\\n", str\[\], str\[\])

}

4.8 复数类型

complex64: 32位实数和虚数

complex128:64位实数和虚数

复数实际上由两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）。

package main

import "fmt"

func main(){
var t complex128 //声明
t = 2.1 + .14i // 赋值
fmt.Println("t = ", t)

//自动推导类型  
t2 := 3.2 +.2i  
fmt.Printf("t2 type is %T\\n", t2)

//通过内建函数，取实部和虚部  
fmt.Println("real(t2) = ", real(t2), "imag(t2) = ", imag(t2))

}

在python中，用j或者J来表示虚部。

a = 3.13 + 2.23j
a.read # 获取复数的实部
a.imag # 获取复数的虚部

5.1 格式说明

格式

含义

一个%字面量

一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数

字符型。可以把输入的数字按照ASCII码相应转换为对应的字符

一个十进制数值(基数为10)

以科学记数法e表示的浮点数或者复数值

以科学记数法E表示的浮点数或者复数值

以标准记数法表示的浮点数或者复数值

以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出

以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出

一个以八进制表示的数字(基数为8)

以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示

使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字

字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符）

以true或者false输出的布尔值

使用Go语法输出的值的类型

一个用Unicode表示法表示的整型码点，默认值为4个数字字符

使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话

以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示

以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示

5.2 格式化输出

package main

import "fmt"

func main(){
a :=
b := "abc"
c := 'a' // 字符类型是int32
d := 3.14
// %T操作变量所属类型
fmt.Printf("%T,%T,%T,%T\n", a,b,c,d)

// %d整型号格式  
// %s 字符串格式  
// %c 字符格式  
// %f 浮点型格式  
fmt.Printf("a=%d, b=%s, c=%c, d=%f\\n", a,b,c,d)

//%v自动匹配格式输出  
fmt.Printf("a=%v, b=%v, c=%v, d=%v\\n", a,b,c,d)

}

5.3输出

package main

import "fmt"

func main(){
var a int
var b int
fmt.Print("请输入变量a:")

fmt.Scanf("%d", &a)  // 别忘了&  
fmt.Print("请输入变量b:")  
fmt.Scan(&b)  
fmt.Println("a = ", a)  
fmt.Println("b = ", b)

}

补充：在python中直接使用input,和python相比，go中的输入就略显的有些麻烦了

a = input("请输入变量a:")
print(a)

5.4 类型转换

Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。

package main

import "fmt"

func main(){
// 不能转换类型，叫不兼容类型
var flag bool
flag = true
fmt.Printf("flag = %t\n", flag)

// bool 类型不能转换为int  
// fmt.Printf("flag = %d \\n", int(flag))

// 0就是假，非0就是真  
// 整型也不能转bool  
// flag = bool(1)

var ch byte  
ch = 'a'  // 字符类型本质上是整型  
var t int  
t = int(ch) // 类型转换，把ch的值取出来后，转成int 在赋值给t  
fmt.Println("t = ", t)

}

5.5类型别名

package main

import "fmt"

func main(){
// 给int64 起一个别名叫bigint
type bigint int64

var a bigint  // 等价于var a int64  
fmt.Printf("a type is %T\\n", a)

type(  
    long int64  
    char byte  
)

var b long =  
var ch char = 'a'  
fmt.Printf("b = %d, ch = %c\\n", b, ch)

}

组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。字符用单引号（’）包裹起来，如：

var a := '中'
var b := 'x'

Go 语言的字符有以下两种：

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。

修改字符串

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

func changeString() {
s1 := "big"
// 强制类型转换
byteS1 := []byte(s1)
byteS1[] = 'p'
fmt.Println(string(byteS1))

s2 := "白萝卜"  
runeS2 := \[\]rune(s2)  
runeS2\[\] = '红'  
fmt.Println(string(runeS2))

}

7、类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

强制类型转换的基本语法如下：

T(表达式)

其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.

比如计算直角三角形的斜边长时使用math包的Sqrt()函数，该函数接收的是float64类型的参数，而变量a和b都是int类型的，这个时候就需要将a和b强制类型转换为float64类型。

func sqrtDemo() {
var a, b = ,
var c int
// math.Sqrt()接收的参数是float64类型，需要强制转换
c = int(math.Sqrt(float64(a*a + b*b)))
fmt.Println(c)
}

8、练习

编写代码统计出字符串"hello西安古城"中汉字的数量。

package main

import "fmt"

func main() {
var str string = "hello西安古城"
　 var d int
　　for _, v := range str{
　　　　if len(v) >= 3{
　　　　　　d += 1
　　}
}
fmt.Printf("汉字总计数量：%d", d)
}

手机扫一扫

移动阅读更方便

你可能感兴趣的文章

go项目实现在配置文件实现配置项统一管理

Go，从命名开始！Go的关键字和标识符全列表手册和代码示例！

Go学习笔记1

4.go语言复合类型简述

前瞻｜Java 21 新特性 String Templates（字符串模版）

Go的基础类型

2.1 变量声明

2.2 变量初始化

自动推导类型：

补充：printf和println的区别

多重赋值以及匿名变量

3.1 字面常量(常量值)

3.2 常量定义

3.3 iota枚举

几个常见的iota示例

4.1 分类

4.2 布尔类型

4.3 整型

4.4 浮点型

4.5 字符类型

4.6字符串类型

字符串的常用操作

4.7字符和字符串的区别

4.8 复数类型

5.1 格式说明

5.2 格式化输出

5.3输出

5.4 类型转换

5.5类型别名

修改字符串

7、类型转换

8、练习

几个常见的`iota`示例