Go 编程实例【数据类型】

「爱情、让人受尽委屈。」 2023-10-08 21:36 9阅读 0赞

#### 阅读目录 ####

*  基础实例
 *  简述类型
 *   *  bool
     *  有符号整型
     *  无符号整型
     *  浮点型
     *  复数类型
     *  其他数字类型 byte、rune
     *  string 类型
     *   *  1.关于字符串连接，下面语法正确的是?
     *  类型转换
 *  Go语言数据类型有哪些？
 *  类型别名与类型定义的区别
 *  nil 只能赋值给指针

## 基础实例 ##

Go 拥有多种值类型，包括字符串，整型，浮点型，布尔型等。

下面是一些基本的例子。

// values.go
    package main
    
    import "fmt"
    
    func main() {
        
    
    	// 字符串可以通过 `+` 连接。
    	fmt.Println("go" + "lang")
    
    	// 整数和浮点数
    	fmt.Println("1+1 =", 1+1)
    	fmt.Println("7.0/3.0 =", 7.0/3.0)
    
    	// 布尔型，以及常见的布尔操作。
    	fmt.Println(true && false)
    	fmt.Println(true || false)
    	fmt.Println(!true)
    }

[root@bogon test]# go run values.go
    golang
    1+1 = 2
    7.0/3.0 = 2.3333333333333335
    false
    true
    false
    [root@bogon test]#

## 简述类型 ##

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

*  bool
 *  数字类型  
    int8, int16, int32, int64, int  
    uint8, uint16, uint32, uint64, uint  
    float32, float64  
    complex64, complex128  
    byte  
    rune
 *  string

### bool ###

bool 类型表示一个布尔值，值为 true 或者 false。

package main
    
    import "fmt"
    
    func main() {
        
        a := 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 b: false
    c: false
    d: true

### 有符号整型 ###

int8：表示 8 位有符号整型大小：  
8 位范围：`-128～127`

int16：表示 16 位有符号整型大小：  
16 位范围：`-32768～32767`

int32：表示 32 位有符号整型大小：  
32 位范围：`-2147483648～2147483647`

int64：表示 64 位有符号整型大小：  
64 位范围：`-9223372036854775808～9223372036854775807`

int：根据不同的底层平台（Underlying Platform），表示 32 或 64 位整型。

除非对整型的大小有特定的需求，否则你通常应该使用 int 表示整型。

大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。  
范围：在 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`。

在上述程序中，a 是 int 类型，而 b 的类型通过赋值（95）推断得出。上面我们提到，int 类型的大小在 32 位系统下是 32 位，而在 64 位系统下是 64 位。接下来我们会证实这种说法。

在 Printf 方法中，使用 %T 格式说明符（Format Specifier），可以打印出变量的类型。Go 的 unsafe\[3\] 包提供了一个 Sizeof\[4\] 函数，该函数接收变量并返回它的字节大小。unsafe 包应该小心使用，因为使用 unsafe 包可能会带来可移植性问题。不过出于本教程的目的，我们是可以使用的。

下面程序会输出变量 a 和 b 的类型和大小。格式说明符 %T 用于打印类型，而 %d 用于打印字节大小。

package main
    
    import (
        "fmt"
        "unsafe"
    )
    
    func main() {
        
        var a int = 89
        b := 95
        fmt.Println("value of a is", a, "and b is", b)
        fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) // a 的类型和大小
        fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) // b 的类型和大小
    }

以上程序会输出：

value of a is 89 and b is 95
    type of a is int, size of a is 4
    type of b is int, size of b is 4

从上面的输出，我们可以推断出 a 和 b 为 int 类型，且大小都是 32 位（4 字节）。

如果你在 64 位系统上运行上面的代码，会有不同的输出。  
在 64 位系统下，a 和 b 会占用 64 位（8 字节）的大小。

### 无符号整型 ###

uint8：表示 8 位无符号整型大小：  
8 位范围：`0～255`

uint16：表示 16 位无符号整型大小：  
16 位范围：`0～65535`

uint32：表示 32 位无符号整型大小：  
32 位范围：`0～4294967295`

uint64：表示 64 位无符号整型大小：  
64 位范围：`0～18446744073709551615`

uint：根据不同的底层平台，表示 32 或 64 位无符号整型。  
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。  
范围：在 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，把 b 和 a 的差赋值给 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**\[7\] 用于创建一个包含实部和虚部的复数。  
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、rune ###

byte 是 uint8 的别名。  
rune 是 int32 的别名。

在学习字符串的时候，我们会详细讨论 byte 和 rune。

### string 类型 ###

在 Golang 中，字符串是字节的集合。

如果你现在还不理解这个定义，也没有关系。

我们可以暂且认为一个字符串就是由很多字符组成的。

下面编写一个使用字符串的程序。

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

上面程序中，first 赋值为字符串 “Naveen”，last 赋值为字符串 “Ramanathan”。

`+` 操作符可以用于拼接字符串。

我们拼接了 first、空格和 last，并将其赋值给 name。  
上述程序将打印输出 `My name is Naveen Ramanathan`。

#### 1.关于字符串连接，下面语法正确的是? ####

A.str:= 'abc' +'123'
    B.str := "abc"+ "123"
    C. str:= '123' + "abc"
    D. fmt. Sprintf("abc%d", 123)

参考答案: BD

参考解析:  
考的知识点是字符串连接。  
除了以上两种连接方式，还有strings.Join().buffer .WriteString()等。

![在这里插入图片描述][89677c6d4cc44193a441121c202a89f5.png]  
虽然使用了 fmt.Sprintf 函数格式化字符串，但并没有将其结果打印或输出到标准输出流。  
因此，你没有看到任何输出内容。

要正确地输出格式化后的字符串，你可以使用 fmt.Println 或 fmt.Printf 函数来打印结果。  
下面是修改后的代码：

package main
    
    import "fmt"
    
    func main() {
        
    	result := fmt.Sprintf("abc%d", 123)
    	fmt.Println(result)
    }

在上面的示例中，我们将 fmt.Sprintf 的结果存储在 result 变量中，并使用 fmt.Println 将其打印输出。  
这样，你将能够在控制台上看到输出内容。

另外，如果你只想在控制台上直接输出格式化的字符串而不存储它，  
你可以使用 fmt.Printf 函数：

package main
    
    import "fmt"
    
    func main() {
        
    	fmt.Printf("abc%d", 123)
    }

在这个示例中，fmt.Printf 直接将格式化后的字符串输出到标准输出流。

### 类型转换 ###

Go 有着非常严格的强类型特征。

Go 没有自动类型提升或类型转换。

我们通过一个例子说明这意味着什么。

package main
    
    import (
        "fmt"
    )
    
    func main() {
        
        i := 55      //int
        j := 67.8    //float64
        sum := i + j //不允许 int + float64
        fmt.Println(sum)
    }

上面的代码在 C 语言中是完全合法的，然而在 Go 中，却是行不通的。

`i` 的类型是 int ，而 `j` 的类型是 float64 ，我们正试图把两个不同类型的数相加，Go 不允许这样的操作。如果运行程序，你会得到 `main.go:10: invalid operation: i + j (mismatched types int and float64)`。

要修复这个错误，i 和 j 应该是相同的类型。  
在这里，我们把 j 转换为 int 类型。把 v 转换为 T 类型的语法是 `T(v)`。

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) // 若没有显式转换，该语句会报错
        fmt.Println("j", j)
    }

`i` 转换为 float64 类型，接下来赋值给 j。  
如果不进行类型转换，当你试图把 i 赋值给 j 时，编译器会抛出错误。

## Go语言数据类型有哪些？ ##

基本数据类型：数字、布尔型、字符串；

派生数据类型：指针、数组、结构体（struct）、通道（channel）、切片（slice）、函数、接口（interface）、map。

## 类型别名与类型定义的区别 ##

![在这里插入图片描述][f5f6df9d8bd44cf588247f5868c3c4d7.png]  
参考解析:

这道题考的是类型别名与类型定义的区别。

第 5 行代码是基于类型 int 创建了新类型 MyInt1，  
第6行代码是创建了 int 的类型别名 MyInt2，注意类型别名的定义时 =。

所以，第10行代码相当于是将 int 类型的变量赋值给 MyInt1 类型的变量，Go是强类型语言，编译当然不通过;

而 MyInt2 只是 int 的别名，本质.上还是 int，可以赋值。

> 第 10 行代码的赋值可以使用强制类型转化 `var i1 MyInt1 = MyInt1(i)`。

![在这里插入图片描述][a31a65fe8c474926b401d50dec5d25ad.png]

## nil 只能赋值给指针 ##

nil 只能赋值给指针、chan、 func、 interface、 map或slice类型的变量。

强调下D选项的error类型，它是一-种内置接口类型，看它的源码就知道，所以D是对的。

A.varx= nil
    B. var x interface{
        }= nil
    C. var x string= nil
    D. var x error= nil

参考答案及解析: BD。

type error interface {
        
    	Error() string
    }

[89677c6d4cc44193a441121c202a89f5.png]: https://img-blog.csdnimg.cn/89677c6d4cc44193a441121c202a89f5.png
[f5f6df9d8bd44cf588247f5868c3c4d7.png]: https://img-blog.csdnimg.cn/f5f6df9d8bd44cf588247f5868c3c4d7.png
[a31a65fe8c474926b401d50dec5d25ad.png]: https://img-blog.csdnimg.cn/a31a65fe8c474926b401d50dec5d25ad.png