Golang教程：类型

下面是 Go 支持的基本类型：

    • bool
    • Numeric Types 
      • int8, int16, int32, int64, int
      • uint8,uint16,uin32,uint64, uint
      • float32, float64
      • complex64, complex128
      • byte
      • rune
    • string

bool

bool 类型表示真假值，只能为 true 或 false。

import "fmt"

func main() {
    var a bool = true
    b := false
    fmt.Println("a:", a, "b:", b)
    c := a && b
    fmt.Println("c:", c)
    d := a || b
    fmt.Println("d:", d)
}

这里 a 被赋值为 true，b 被赋值为 false。

c 被赋值为 a && b。与操作符（&&）仅在 a 与 b 都为 true 时才返回 true，因此在这里 c 被赋值为 false。

或操作符（||）在 a 与 b 中至少有一个为 true 时返回 true。在这里因为 a 为 true，因此 d 也被赋值为 true（译者注：a 为 true，因此 a || b 的结果为true，因此 d 为 true）。我们将会得到如下输出：

a: true b: false
c: false
d: true

有符号整型

int8：表示8位有符号整数 
size：8 bits 
range：-128 ~ 127

int16：表示16位有符号整数 
size：16 bits 
range：-32768 ~ 32767

int32： 表示32位有符号整数 
size： 32 bits 
range： -2147483648 ~ 2147483647

int64： 表示64位有符号整数 
size： 64 bits 
range： -9223372036854775808 ~ 9223372036854775807

int： 根据底层平台（underlying platform）不同，表示32或64位整数。在实际编程中，除非对大小有明确的要求，否则一般应该使用 int 表示整数。 
size： 在32位系统下 32 bits，在64位系统下 64 bits 
range： 在32位系统下 -2147483648 ~ 2147483647，在64位系统下 -9223372036854775808 ~ 9223372036854775807

package main

import "fmt"

func main() {
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
}

输出结果为：

value of a is 89 and b is 95

无符号整型

uint8： 表示8位无符号整型 
size： 8 bits 
range： 0 ~ 255

uint16： 表示16位无符号整型 
size： 16 bits 
range： 0 ~ 65535

uint32： 表示32位无符号整型 
size： 32 bits 
range： 0 ~ 4294967295

uint64： 表示64位无符号整型 
size： 64 bits 
range： 0 ~ 18446744073709551615

uint ： 根据底层平台不同表示32或64位无符号整型 
size ： 32位系统下是32 bits，64位系统下64 bits 
range ：32位系统下 0 ~ 4294967295，64位系统下 0 ~ 18446744073709551615

浮点类型

float32：32位浮点型 
float64：64位浮点型

下面的程序演示了整型和浮点数类型：

package main

import (
    "fmt"
)

func main() {
    a, b := 5.67, 8.97
    fmt.Printf("type of a %T b %T\n", a, b)
    sum := a + b
    diff := a - b
    fmt.Println("sum", sum, "diff", diff)

    no1, no2 := 56, 89
    fmt.Println("sum", no1+no2, "diff", no1-no2)
}

变量 a 和 b 的类型从它们的初值推导。在这里 a 和 b 都为 float64。（float64是浮点数的默认类型）。我们将 a 与 b的和赋值给 sum。将 a 与 b 的差赋值给 diff。然后打印 sum 和 diff。no1 和 no2 也是同样的操作。上面的程序，输出如下：

type of a float64 b float64
sum 14.64 diff -3.3000000000000007
sum 145 diff -33

复数类型

complex64：实部和虚部都是 float32 
complex128：实部和虚部都是 float64

通过内置函数 complex 来构造一个包含实部和虚部的复数。它的原型为：

func complex(r, i FloatType) ComplexType

它接收一个实部和一个虚部为参数并返回一个复数类型。实部和虚部应该为同一类型（float32 或 float64）。如果实部和虚部都是 float32，该函数返回一个类型为 complex64 的复数。如果实部和虚部都是 float64，该函数返回一个类型为complex128 的复数。

复数也可以通过简短声明语法来创建：

c := 6 + 7i

让我们写一个小程序来了解复数：

package main

import (
    "fmt"
)

func main() {
    c1 := complex(5, 7)
    c2 := 8 + 27i
    cadd := c1 + c2
    fmt.Println("sum:", cadd)
    cmul := c1 * c2
    fmt.Println("product:", cmul)
}

在上面的程序中，c1 和 c2 是两个复数。c1 的实部为 5 虚部为 7。c2 的实部为 8 虚部为 27。c1 与 c2 的和赋值给 cadd。c1 与 c2 的积赋值给 cmul。运行这个程序得到如下输出：

sum: (13+34i)
product: (-149+191i)

其他数字类型

byte 是 uint8 的别称 
rune 是 int32 的别称

我们将在学习 string 类型时详细讨论 byte 和 rune。

字符串类型

在Go中字符串（String）是 byte 的集合。如果你觉得这个定义没有任何意义也没关系。我们可以暂且假定一个字符串就是一串字符的集合。在后面的教程中我们将通过一整篇的篇幅来介绍字符串的细节。

让我们写一个程序来了解字符串：

package main

import (
    "fmt"
)

func main() {
    first := "Naveen"
    last := "Ramanathan"
    name := first +" "+ last
    fmt.Println("My name is",name)
}

在上面的程序中，first 被赋值为 "Naveen"，last 被赋值为 "Ramanathan"。字符串可以通过 + 操作符连接在一起。name 被赋值为 first 、空格与 last 三者连接后的结果。上面的程序将得到如下输出：

My name is Naveen Ramanathan

还有许多操作可应用于字符串。我们将用单独的一篇教程来介绍它们。

类型转换

Go是强类型的语言，没有隐式的类型提升和转换。让我们通过一个例子说明这意味着什么：

package main

import (
    "fmt"
)

func main() {
    i := 55      //int
    j := 67.8    //float64
    sum := i + j //int + float64 not allowed
    fmt.Println(sum)
}

上面的代码在C语言中是完全合法的，但是在Go中却不是。i 的类型是 int 而 j 的类型是 float64，将这两个类型不同的数字相加是非法的。运行这个程序将会报错：main.go:10: invalid operation: i + j (mismatched types int and float64)。

为了修复这个错误，我们应该将 i 和 j 转换为同样的类型，在这里让我们将 j 转换为 int。通过 T(v)可以将 v 的值转换为 T 类型 。

package main

import (
    "fmt"
)

func main() {
    i := 55      //int
    j := 67.8    //float64
    sum := i + int(j) //j is converted to int
    fmt.Println(sum)
}

可以得到正确的输出结果：122。

在赋值时情况也是如此，将一个变量赋值给另一个类型不同的变量时必须显式转型。下面的程序说明了这一点

package main

import (
    "fmt"
)

func main() {
    i := 10
    var j float64 = float64(i) //this statement will not work without explicit conversion
    fmt.Println("j", j)
}

在 var j float64 = float64(i) 这一行，i 被转换为 float64，然后赋值给 j。当你尝试将 i 不进行转换直接赋值给 j时，编译器将报错。

原文地址：https://www.cnblogs.com/liuzhongchao/p/9158652.html

时间： 2024-10-30 02:47:55

Golang教程：类型的相关文章

Golang教程：变量

声明单一变量 声明一个变量的语法为:var name type,例如 package main import "fmt" func main() { var age int // variable declaration fmt.Println("my age is", age) } 语句 var age int 声明了一个类型为 int,名称为 age 的变量.在这里我们没有给它赋任何值.如果一个变量没有被赋予任何值,Go 会自动将这个变量初始化为其类型的 0值,

go系列教程-类型

下面是 Go 支持的基本类型: bool 数字类型 int8, int16, int32, int64, int uint8, uint16, uint32, uint64, uint float32, float64 complex64, complex128 byte rune string bool 1.bool 类型表示一个布尔值,值为 true 或者 false. 2.有符号整型 int8:表示 8 位有符号整型大小:8 位范围:-128-127 int16:表示 16 位有符号整型大

golang:interface{}类型测试

在golang中空的interface即interface{}可以看作任意类型, 即C中的void *. 对interface{}进行类型测试有2种语法: 1. Comma-ok断言: value, ok = element.(T), 其中T是具体类型. 2. Switch测试: switch element.(type) { case T1: case T2: default: } 其中T1, T2是具体类型. 注意: element.(type)语法不能在switch外的任何逻辑里使用. 在

Golang教程：Map

什么是 map? Map 是 Go 中的内置类型,它将键与值绑定到一起.可以通过键获取相应的值. 如何创建 map? 可以通过将键和值的类型传递给内置函数 make 来创建一个 map.语法为:make(map[KeyType]ValueType).(译者注:map 的类型表示为 map[KeyType]ValueType)例如: personSalary := make(map[string]int) 上面的代码创建了一个名为 personSalary 的 map.其中键的类型为 string

深入学习golang(3)—类型方法

类型方法 在Go语言中,我们可以给任何类型(包括内置类型,但不包括指针和接口)定义方法.例如,在实际编程中,我们经常使用[ ]byte的切片,我们可以定义一个新的类型: type ByteSlice []byte 然后我们就可以定义方法了.例如,假如我们不想使用内建的append函数,我们可以实现一个自己的append方法: func Append(slice, data[]byte) []byte { l := len(slice) if l + len(data) > cap(slice)

Golang教程：函数

函数是完成一个特定任务的代码块.一个函数接受输入,对输入进行一些运算并产生输出. 函数声明 在 Go 中声明一个函数的语法为: func functionname(parametername type) returntype { //function body } 函数声明以关键字 func 开头,后面是函数名字,接着是在 ( 和 ) 之间指定的参数列表,然后是函数的返回类型.指定参数的语法为参数名称后面跟着参数类型.可以指定任意数量的参数,形式为: (parameter1 type, para

golang基础类型

1.变量 Go使用关键字var定义变量,类型信息放在变量名后面,初始化为零,如下: 在函数内部还有一种更简洁的:=定义方式 变量赋值,两个变量可直接交换 注意:函数内部定义的变量没使用的话编译器会报错. declared and not used 2 常量 用关键词const定义,常量值必须是编译期间能够确定的数值. 枚举iota,从0开始按行数自增,如果重新const,则从0开始再次计算. 3 类型 Go内置以下基础类型: 布尔类型:bool. 整型:int8.byte.int16.int.u

golang mongo-driver filter 构建--bson和golang基础类型

go.mongodb.org/mongo-driver 是mongo的golang官方包 通过例子我知道连接是这样的 clientOptions := options.Client().ApplyURI("mongodb://tag:[email protected]:27017/tag") client, err := mongo.NewClient(clientOptions) if err != nil { fmt.Println(err) } ctx, _ := context

【GoLang】类型和作用在它上面定义的方法必须在同一个包里定义

cannot define new methods on non-local type int 参考资料: http://wiki.jikexueyuan.com/project/the-way-to-go/10.6.html http://stackoverflow.com/questions/28800672/how-to-add-new-methods-to-an-existing-type-in-go