Go语言-Day01_3

Go 语言数据类型

在 Go 编程语言中，数据类型用于声明函数和变量。

数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。

Go 语言按类别有以下几种数据类型：

序号类型和描述
1 布尔型
布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
2 数字类型
整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码。
3 字符串类型:
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
4 派生类型:
包括：
  • (a) 指针类型（Pointer）
  • (b) 数组类型
  • (c) 结构化类型(struct)
  • (d) Channel 类型
  • (e) 函数类型
  • (f) 切片类型
  • (g) 接口类型（interface）
  • (h) Map 类型

数字类型

Go 也有基于架构的类型，例如：int、uint 和 uintptr。

序号类型和描述
1 uint8
无符号 8 位整型 (0 到 255)
2 uint16
无符号 16 位整型 (0 到 65535)
3 uint32
无符号 32 位整型 (0 到 4294967295)
4 uint64
无符号 64 位整型 (0 到 18446744073709551615)
5 int8
有符号 8 位整型 (-128 到 127)
6 int16
有符号 16 位整型 (-32768 到 32767)
7 int32
有符号 32 位整型 (-2147483648 到 2147483647)
8 int64
有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

浮点型：

序号类型和描述
1 float32
IEEE-754 32位浮点型数
2 float64
IEEE-754 64位浮点型数
3 complex64
32 位实数和虚数
4 complex128
64 位实数和虚数

其他数字类型

以下列出了其他更多的数字类型：

 

序号类型和描述
1 byte
类似 uint8
2 rune
类似 int32
3 uint
32 或 64 位
4 int
与 uint 一样大小
5 uintptr
无符号整型，用于存放一个指针

笔记

go 1.9版本对于数字类型，无需定义int及float32、float64，系统会自动识别。

package main
import "fmt"

func main() {
   var a = 1.5
   var b =2
   fmt.Println(a,b)
}

运行结果

# go run int.go
1.5 2

如果加上类型float，会出现如下结果

# go run int.go
# command-line-arguments
./int.go:4:10: undefined: float



在 Go 中，布尔值的类型为 bool，值是 true 或 false，默认为 false。



 

Go 语言变量

变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。变量可以通过变量名访问。

Go 语言变量名由字母、数字、下划线组成，其中首个字母不能为数字。

声明变量的一般形式是使用 var 关键字：

var identifier type

变量声明

第一种，指定变量类型，声明后若不赋值，使用默认值。

1 var v_name v_type
2 v_name = value

第二种，根据值自行判定变量类型。

var v_name = value

第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误。

1 v_name := value
2 
3 // 例如
4 var a int = 10
5 var b = 10
6 c := 10

实例如下：

1 package main
2 var a = "菜鸟教程"
3 var b string = "runoob.com"
4 var c bool
5 
6 func main(){
7     println(a, b, c)
8 }

以上实例执行结果为：

菜鸟教程 runoob.com false

多变量声明

 1 //类型相同多个变量, 非全局变量
 2 var vname1, vname2, vname3 type
 3 vname1, vname2, vname3 = v1, v2, v3
 4 
 5 var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型，自动推断
 6 
 7 vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误
 8 
 9 
10 // 这种因式分解关键字的写法一般用于声明全局变量
11 var (
12     vname1 v_type1
13     vname2 v_type2
14 )

实例如下：

 1 package main
 2 
 3 var x, y int
 4 var (  // 这种因式分解关键字的写法一般用于声明全局变量
 5     a int
 6     b bool
 7 )
 8 
 9 var c, d int = 1, 2
10 var e, f = 123, "hello"
11 
12 //这种不带声明格式的只能在函数体中出现
13 //g, h := 123, "hello"
14 
15 func main(){
16     g, h := 123, "hello"
17     println(x, y, a, b, c, d, e, f, g, h)
18 }

以上实例执行结果为：

0 0 0 false 1 2 123 hello 123 hello

值类型和引用类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值：

4.4.2_fig4.1

当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：

4.4.2_fig4.2

你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040（每次的地址都可能不一样）。值类型的变量的值存储在栈中。

内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。

更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。

一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。

4.4.2_fig4.3

这个内存地址为称之为指针，这个指针实际上也被存在另外的某一个字中。

同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。

当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。

如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。

简短形式，使用 := 赋值操作符

我们知道可以在变量的初始化时省略变量的类型而由系统自动推断，声明语句写上 var 关键字其实是显得有些多余了，因此我们可以将它们简写为 a := 50 或 b := false。

a 和 b 的类型（int 和 bool）将由编译器自动推断。

这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。使用操作符 := 可以高效地创建一个新的变量，称之为初始化声明。

注意事项

如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。

如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。

如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：

1 package main
2 
3 import "fmt"
4 
5 func main() {
6    var a string = "abc"
7    fmt.Println("hello, world")
8 }

尝试编译这段代码将得到错误 a declared and not used。

此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用

fmt.Println("hello, world", a)

会移除错误。

但是全局变量是允许声明但不使用。

同一类型的多个变量可以声明在同一行，如：

var a, b, c int

多变量可以在同一行进行赋值，如：

1 var a, b int
2 var c string
3 a, b, c = 5, 7, "abc"

上面这行假设了变量 a，b 和 c 都已经被声明，否则的话应该这样使用：

a, b, c := 5, 7, "abc"

右边的这些值以相同的顺序赋值给左边的变量，所以 a 的值是 5， b 的值是 7，c 的值是 "abc"。

这被称为 并行 或 同时 赋值。

如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。

空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。

_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。

并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。

 

 

 

 

 

 

Go 语言常量

 

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

 

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

 

常量的定义格式：

 

const identifier [type] = value

 

你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

 

  • 显式类型定义： const b string = "abc"
  • 隐式类型定义： const b = "abc"

 

多个相同类型的声明可以简写为：

 

const c_name1, c_name2 = value1, value2

 

以下实例演示了常量的应用：

 

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6    const LENGTH int = 10
 7    const WIDTH int = 5   
 8    var area int
 9    const a, b, c = 1, false, "str" //多重赋值
10 
11    area = LENGTH * WIDTH
12    fmt.Printf("面积为 : %d", area)
13    println()
14    println(a, b, c)   
15 }

 

以上实例运行结果为：

 

面积为 : 50
1 false str

 

常量还可以用作枚举：

 

const (
    Unknown = 0
    Female = 1
    Male = 2
)

 

数字 0、1 和 2 分别代表未知性别、女性和男性。

 

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

 

package main

import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main(){
    println(a, b, c)
}

 

以上实例运行结果为：

 

abc 3 16

 


注意：
a = "hello"
unsafe.Sizeof(a)

输出结果为：16

字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。

 

iota

 

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

 

在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。

 

iota 可以被用作枚举值：

 

const (
    a = iota
    b = iota
    c = iota
)

 

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

 

const (
    a = iota
    b
    c
)

 

iota 用法

 

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

 

以上实例运行结果为：

 

0 1 2 ha ha 100 100 7 8

 

再看个有趣的的 iota 实例：

 

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

 

以上实例运行结果为：

 

i= 1
j= 6
k= 12
l= 24

 

iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

 

简单表述:

i=1

    ：左移 0 位,不变仍为 1;
  • j=3：左移 1 位,变为二进制 110, 即 6;
  • k=3：左移 2 位,变为二进制 1100, 即 12;
  • l=3：左移 3 位,变为二进制 11000,即 24。

 

posted @ 2018-08-14 21:08  勋爵|X-knight  阅读(191)  评论(0)    收藏  举报