Go的基础数据类型

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

1、命名

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、变量

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

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

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 = 10 //变量的赋值
    fmt.Println(a)

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

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

自动推导类型：

package main

import "fmt"

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

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

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

补充：printf和println的区别

package main

import "fmt"

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

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

    b, c := 20, 30
    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 1,2,3
}


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

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

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

    i,j := 30,40
    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)
    }

3、常量

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

3.1 字面常量(常量值)

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

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

3.2 常量定义

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

const ( // 常量组
  size int64 = 1024
  eof        = -1 // 整型常量, 自动推导类型
 )
const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值
const a, b, c = 3, 4, "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 = 10
    b = 3.14
    fmt.Println("a=", a)
    fmt.Println("b=", b)

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

    const (
        i int = 10
        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  // 1
        b = iota  // 2
        c = iota  // 3
    )
    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 = 0, b = 1, c = 2
d = 0
e = 0, f = 1, g = 2
h = 0, i = 1, j = 1, k = 1, m = 2
Process finished with exit code 0

几个常见的`iota`示例

使用“_”跳过某些值

const (
    n1 = iota  //0
    n2            //1
    _
    n4           //3
)

iota声明中间插队

const (
    n1 = iota //0
    n2 = 100  //100
    n3 = iota //2
    n4        //3
)
const n5 = iota //0

定义数量级

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

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

4、基础数据类型

4.1 分类

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

类型	名称	长度	零值	说明
bool	布尔类型	1	false	其值不为真即为家，不可以用数字代表true或false
byte	字节型	1	0	uint8别名
rune	字符类型	4	0	专用于存储unicode编码，等价于uint32
int, uint	整型	4或8	0	32位或64位
int8, uint8	整型	1	0	-128 ~ 127, 0 ~ 255
int16, uint16	整型	2	0	-32768 ~ 32767, 0 ~ 65535
int32, uint32	整型	4	0	-21亿 ~ 21 亿, 0 ~ 42 亿
int64, uint64	整型	8	0
float32	浮点型	4	0.0	小数位精确到7位
float64	浮点型	8	0.0	小数位精确到15位
complex64	复数类型	8
complex128	复数类型	16
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 = 123
    v2 := 64
    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 = 97
    // 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'+32)    // 大写转小写：a
    fmt.Printf("小写转大写： %c\n", 'a'-32)  // 小写转大写：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[0], str[1])
}

4.8 复数类型

complex64: 32位实数和虚数

complex128:64位实数和虚数

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

package main

import "fmt"

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

    //自动推导类型
    t2 := 3.2 +3.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 、fmt包的格式化输出输入

5.1 格式说明

格式	含义
%%	一个%字面量
%b	一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数
%c	字符型。可以把输入的数字按照ASCII码相应转换为对应的字符
%d	一个十进制数值(基数为10)
%e	以科学记数法e表示的浮点数或者复数值
%E	以科学记数法E表示的浮点数或者复数值
%f	以标准记数法表示的浮点数或者复数值
%g	以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出
%G	以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出
%o	一个以八进制表示的数字(基数为8)
%p	以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示
%q	使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字
%s	字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符）
%t	以true或者false输出的布尔值
%T	使用Go语法输出的值的类型
%U	一个用Unicode表示法表示的整型码点，默认值为4个数字字符
%v	使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话
%x	以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示
%X	以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示

5.2 格式化输出

package main

import "fmt"

func main(){
    a := 10
    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" 
                       
                    
                     
                      



鲜花




握手




雷人




路过




鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

go语言常用函数：cap发布时间：2022-07-10

GO runtime的用法发布时间：2022-07-10

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服

地址：深圳市南山区西丽大学城创智工业园

电邮：jeky_zhao#qq.com

移动电话：139-2527-9053

客服电话

电子邮件

Go的基础数据类型

1、命名

2、变量

2.1 变量声明

2.2 变量初始化

自动推导类型：

补充：printf和println的区别

多重赋值以及匿名变量

3、常量

3.1 字面常量(常量值)

3.2 常量定义

3.3 iota枚举

几个常见的`iota`示例

4、基础数据类型

4.1 分类

4.2 布尔类型

4.3 整型

4.4 浮点型

4.5 字符类型

4.6字符串类型

字符串的常用操作

4.7字符和字符串的区别

4.8 复数类型

5 、fmt包的格式化输出输入

5.1 格式说明

5.2 格式化输出

5.3输出

5.4 类型转换

请发表评论

全部评论

上一篇：

下一篇：

关于我们

产品与服务

解决方案

139-2527-9053

客服电话

电子邮件

Go的基础数据类型

1、命名

2、变量

2.1 变量声明

2.2 变量初始化

自动推导类型：

补充：printf和println的区别

多重赋值以及匿名变量

3、常量

3.1 字面常量(常量值)

3.2 常量定义

3.3 iota枚举

几个常见的iota示例

4、基础数据类型

4.1 分类

4.2 布尔类型

4.3 整型

4.4 浮点型

4.5 字符类型

4.6字符串类型

字符串的常用操作

4.7字符和字符串的区别

4.8 复数类型

5 、fmt包的格式化输出输入

5.1 格式说明

5.2 格式化输出

5.3输出

5.4 类型转换

请发表评论

全部评论

上一篇：

下一篇：

关于我们

产品与服务

解决方案

139-2527-9053

几个常见的`iota`示例