原创分享 golang 快速入门 [8.1]-变量类型、声明赋值、作用域声明周期与变量内存分配

weishixianglian · 2020年03月27日 · 35 次阅读

golang 快速入门 [8.1]-变量类型、声明赋值、作用域声明周期与变量内存分配

前文

题记

  • 在上一篇文章中,我们介绍了吸心大法—go module 的技巧来引用第三方代码,但是看过武侠小说的同学都知道,只有内力没有招式那也是花架子。正所谓"巧妇难为无米之炊",我们将在后面几章巩固基本功,介绍 go 语言的语法、基本概念和性质。 ## 前言 我们将在本文中学习到:
  • 变量的内涵
  • 变量的数据类型
  • 变量的多种声明与赋值
  • 变量的命名
  • 变量的作用域与示例
  • 变量的内存分配方式

变量是什么

  • 在计算机编程中,变量 (Variable) 是与关联的符号名配对的存储地址 (内存地址标识)
  • 变量用于存储要在计算机程序中引用和操作的信息。变量还提供了一种使用描述性名称标记数据的方法,因此读者和开发人员都可以更清楚地理解程序。可以将将变量视为保存信息的空间。
  • 编译器必须用数据的实际地址替换变量的符号名。尽管变量的名称,类型和地址通常保持不变,但存储在地址中的数据可能会在程序执行期间发生更改。

变量的数据类型

  • go 语言是静态类型的语言,需要在运行前明确变量的数据类型以及大小。如下图是静态语言与动态语言的区别。动态语言可以在运行时扩展变量的大小。

  • 数据类型是数据的属性,它告诉编译器打算如何使用数据

  • 大多数编程语言都支持基本数据类型,包括整数,浮点数,字符和布尔值等。数据类型定义了可以对数据执行的操作,数据的含义以及该类型值的存储方式

  • Go 语言的数值类型包括几种不同大小的整数、浮点数和复数。每种数值类型都决定了对应的大小范围和是否支持正负符号。让我们先从整型数类型开始介绍

  • Go 语言同时提供了有符号和无符号类型的整数运算,有 int8、int16、int32 和 int64 四种截然不同大小的有符号整型数类型,分别对应 8、16、32、64bit 大小的有符号整型数,与此对应的是 uint8、uint16、uint32 和 uint64 四种无符号整型数类型。

  • 还有两种一般对应特定 CPU 平台机器字大小的有符号和无符号整数 int 和 uint。其中 int 是应用最广泛的数值类型。这两种类型都有同样的大小,32 或 64bit,但是我们不能对此做任何的假设;因为不同的编译器卽使在相同的硬件平台上可能产生不同的大小。

  • Unicode 字符 rune 类型是和 int32 等价的类型,通常用于表示一个 Unicode 码点。这两个名称可以互换使用。同样 byte 也是 uint8 类型的等价类型,byte 类型一般用于强调数值是一个原始的数据而不是一个小的整数。

  • 最后,还有一种无符号的整数类型 uintptr,没有指定具体的 bit 大小但是足以容纳指针。uintptr 类型只有在底层编程是才需要,特别是 Go 语言和 C 语言函数库或操作系统接口相交互的地方。在介绍指针时,会详细介绍它。

变量的声明与赋值

变量的声明使用var来标识,变量声明的通用格式如下:

var name type = expression

  • 函数体外部:变量声明方式 1
var i int
  • 函数体外部:变量声明方式 2
// 外部连续声明
var U, V, W float64
  • 函数体外部:变量声明方式 3
// 赋值不带类型,自动推断
var k = 0
  • 函数体外部:变量声明方式 4
// 外部连续声明+赋值
var x, y float32 = -1, -2
  • 函数体外部:变量声明方式 5

    // 外部var括号内部
    var (
    g       int
    u, v, s = 2.0, 3.0, "bar"
    )
    
  • 函数体内部:变量声明方式 6

    func main() {
    //函数内部的变量声明  声明的变量类型必须使用 否则报错
    var x string
    
  • 函数体内部:变量声明方式 7

    // 只限函数内部 自动推断类型
    y := "jonson"
    

变量的命名

  • 名字的长度没有逻辑限制,但是 Go 语言的风格是尽量使用短小的名字,对于局部变量尤其是这样;你会经常看到 i 之类的短名字,而不是冗长的 theLoopIndex 命名。通常来说,如果一个名字的作用域比较大,生命周期也比较长,那么用长的名字将会更有意义。
  • 在习惯上,Go 语言程序员推荐使用 驼峰式 命名,当名字由几个单词组成时优先使用大小写分隔,而不是优先用下划线分隔。因此,在标准库有 QuoteRuneToASCII 和 parseRequestLine 这样的函数命名,但是一般不会用 quote_rune_to_ASCII 和 parse_request_line 这样的命名。而像 ASCII 和 HTML 这样的缩略词则避免使用大小写混合的写法,它们可能被称为 htmlEscape、HTMLEscape 或 escapeHTML,但不会是 escapeHtml。

作用域

  • 在程序设计中,一段程序代码中所用到的标识符并不总是有效/可用的,作用域就是标识符有效可用的代码范围。
  • 在 go 语言中,作用域可以分为 全局作用域 > 包级别作用域 > 文件级别作用域 > 函数作用域 > 内部作用域 universe block > package block > file block > function block > inner block

全局作用域

  • 全局作用域主要是 go 语言预声明的标识符,所有 go 文件都可以使用。主要包含了如下的标识符

內建类型: int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

內建常量: true false iota nil

內建函數: make len cap new append copy close delete
          complex real imag
          panic recover

包级别作用域

  • 全局(任何函数之外)声明的常量,类型,变量或函数的标识符是包级别作用域
  • 如下例中的变量 x 以及 fmt 包中的函数println 就是包级别作用域
package main

import "fmt"

var x int=5

func main(){

    fmt.Println("mainx:",x)
}
  • 调用例子 1
// f1.go
package main

var x int
//-------------------------------------
// f2.go
package main

func f() {
  fmt.Println(x)
}
  • 调用例子 2:调用另一个包中的函数和属性:
//testdemo/destdemo.go
package testdemo

import "fmt"

var Birth uint = 23
func Haha(){
    fmt.Println("lalalal")
}
//-------------------------------------
package main  // main/scope.go

import (
    "testdemo"
    "fmt"
)

func main(){

    testdemo.Haha()
    fmt.Println(testdemo.Birth)
}
  • 注意:如果要让包中的属性和变量被外部包调用,必须要首字母大写。

文件级别作用域

  • import 包的标识符是文件级别作用域的,只能够在本文件中使用
  • 例如下面的代码无效,因为 import 是 file block,不能跨文件
// f1.go
package main

import "fmt"
//-------------------------------------
// f2.go  无效
package main

func f() {
  fmt.Println("Hello World")
}

函数级别作用域

  • 方法接收者(后面介绍),函数参数和结果变量的标识符的范围是函数级别作用域,在函数体外部无效,在内部任何位置可见
  • 例如下面函数中的 a,b,c 就是函数级别作用域
func  add(a int,b int)(c int) {
  fmt.Println("Hello World")
  x := 5
  fmt.Println(x)
}

内部作用域

  • 函数声明的常量和变量是函数内部作用域,其作用域从声明开始,到最近的一个花括号结束。
  • 例子 1:注意参数的前后顺序
//下面的代码无效:
func main() {
  fmt.Println("Hello World")

  fmt.Println(x)
    x := 5
}
  • 例子 2:参数不能跨函数使用
//下面的代码无效2:
func main() {
  fmt.Println("Hello World")
  x := 5
  fmt.Println(x)
}
//
func test(){
    fmt.Println(x)
}
  • 例子 3:函数内部变量与外部变量重名,使用就近原则
package main

import "fmt"

var x int=5

func test(){

    var x int = 99;
    x = 100;
    // 下面的代码输出结果为: 100
    fmt.Println("testx",x)
}
  • 例子 4:内部花括号
  • 变量 x 的作用域是从 scope3 到 scope5 为止
func main() {
    fmt.Println("Hello World")  // scope1
    {                           // scope2
        x := 5                  // scope3
        fmt.Println(x)          // scope4
    }                           // scope5
}

变量的内存分配

我们在前文go 语言是如何运行的-内存概述go 语言是如何运行的-内存分配 中,详细介绍了在虚拟内存角度其不同的及其功能

  • 对于全局变量,其存储在.data.bss段。 我们可以用下面的实例来验证
// main.go
package main

var aaa int64 = 8
var ddd int64
func main() {
}
  • 在终端中输入如下指令打印汇编代码
$ go tool compile -S main.go

...
"".aaa SNOPTRDATA size=8
        0x0000 08 00 00 00 00 00 00 00
"".ddd SNOPTRBSS size=8
...

  • 从上面的汇编输出中可以看出, 变量aaa位于 .data段中, 变量ddd位于.bss
  • 对于函数的内部变量,在 go 语言的编程规范中并没有明确的划分,变量是分配在栈中还是堆中,簡單來說,Go 语言的逃逸分析 (escape analysis) 会分析各个变量的使用狀況,來決定他要放在 stack 还是 heap 段。
  • 一般的变量会在运行时在栈中创建,随着函数的调用而产生,随着函数的结束而消亡。如果编译器无法证明函数返回后未引用该变量,则编译器必须在堆上分配该变量,以避免悬空指针错误。另外,如果局部变量很大,则将其存储在堆而不是堆栈上可能更有意义
  • 有一些初始化的情况会被分配到.data段中,例如长度大于4的数组字面量、字符串 等,如下所示 func main() { var vvv = [5]int{1,2,3,4,5} var bbb string = "hello" }
  • 在终端中输入如下指令打印汇编代码 即可验证其存在于.data段中
$ go tool compile -S main.go
...
go.string."hello" SRODATA dupok size=5
    0x0000 68 65 6c 6c 6f                                   hello
type.[5]int SRODATA dupok size=72
"".ddd SNOPTRBSS size=8
...

总结

参考资料

喜欢本文的朋友欢迎点赞分享~

唯识相链启用微信交流群(Go 与区块链技术)

欢迎加微信:ywj2271840211

更多原创文章干货分享,请关注公众号
  • 加微信实战群请加微信(注明:实战群):gocnio
暂无回复。
需要 登录 后方可回复, 如果你还没有账号请点击这里 注册