（二）Golang的变量

时间  2019-12-20
标签 golang 变量 栏目 Go 繁體版
原文   原文链接

为何须要变量：

  • 变量是程序的基本组成单位
    不管是使用哪一种高级程序语言编写程序，变量都是其程序的基本组成单位，好比：下面代码中sum、sub都是变量。 
    func getVal(num1 int, num2 int) (int, int) {
sum := num1 + mum2
sub := num1 - num2
return sum, sub
}
func main() {
sum, sub := getVal(30, 30)
fmt.Println("sum=", sum, "sub=", sub)
sum2, _ := getVal(10, 30)
fmt.Println("sum=", sum2)
}

    变量的介绍：

  • 变量的概念
    变量至关于内存中一个数据存储空间的表示，能够把变量看作是一个房间的门牌号，经过门牌号能够找到房间，一样的道理，经过变量名能够访问到变量（值）。
  • 变量的使用步骤
    1）定义变量
    2）给变量赋值
    3）使用变量 
    package main
import "fmt"
func main() {
//定义变量
var i int
//给i赋值
i = 10
//使用变量
fmt.Println("i=",i) 
}
D:\goproject\src\go_code\chapter02\demon01>go run main.go
i= 10

    变量使用注意事项：

  • 变量表示内存中的一个存储区域；
  • 该区域有本身的名称（变量名）和类型（数据类型）；
  • Golang变量使用的三种方式：
    1）第一种，指定变量类型，定义后若不赋值，使用默认值； 
    package main
import "fmt"
func main() {
//golang的变量使用方式
//第一种：指定变量类型，定义后若不赋值，使用默认值
//init的默认值是0
var i int
fmt.Println("i=", i)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
i= 0

    2）第二种，根据值自行判断变量类型（类型引导）程序员

    package main
import "fmt"
func main() {   
//第二种：根据值自行判断变量类型（类型推导）
var num = 10.11
fmt.Println("num=", num)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
num= 10.11

    3）第三种，省略var定义变量并赋值golang

    package main
import "fmt"
func main() {
//第三种：省略var,:= 的:不能省略，不然报错
//下面的方式等价于 var name string   name = "tom"
name := "tom"
fmt.Println("name=", name)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
name= tom

  • 多变量定义
    1）在编程中，有时咱们须要一次性定义多个变量，Golang也提供了这样的语法【在函数里面定义】编程

    package main
import "fmt"
func main() {
//该案例演示Golang如何一次性定义多个变量
var a1, a2, a3 int
fmt.Println("a1=", a1, "a2=", a2, "a3=", a3)

//一次性定义多个变量的方式二
var b1, b2, b3 = 100, "tom", 888
fmt.Println("b1=", b1,"b2=", b2,"b3=", b3)

//一次性定义多个变量的方式三，一样可使用类型推导
c1, name, c3 := 200, "mary", 999
fmt.Println("c1=", c1,"name=", name,"c3=", c3)
}
D:\goproject\src\go_code\chapter02\demon03>go run main.go
a1= 0 a2= 0 a3= 0
b1= 100 b2= tom b3= 888
c1= 200 name= mary c3= 999

    2）一次性定义全局变量【在go中函数外部定义变量就是全局变量】数组

    package main
import "fmt"
//定义全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的定义方式，也能够改为一次性定义
var (
n3 = 300
n4 = 400
name2 = "zhangsan"
)
func main() {
fmt.Println("n1=", n1,"n2=", n2,"name=", name)
fmt.Println("n3=", n3,"n4=", n4,"name2=", name2)
}
D:\goproject\src\go_code\chapter02\demon03>go run var.go
n1= 100 n2= 200 name= jack
n3= 300 n4= 400 name2= zhangsan
  • 该区域的数据值能够在同一类型范围内不断变化 
    package main
import "fmt"
func main() {
//该区域的数据值能够在同一类型范围内不断变化
var i int = 10
i = 30
i = 50
fmt.Println("i=", i)
}
D:\goproject\src\go_code\chapter02\demon03>go run var02.go
i= 50
  • 变量在同一个做用域（在一个函数或者代码块）内不能重名；
  • 变量的三要素
    变量=变量名+值+数据类型
  • Golang的变量若是没有赋初值，编译器会使用默认值，好比，int默认值为0；string默认值为空串；小数默认值为0。

  • 程序中+号的使用
    1）当左右两边都是数值型时，则作加法运算；
    2）当左右两边都是字符串时，则作字符串拼接；ide

    package main
import "fmt"
//演示golang中+号的使用
func main() {
var i = 1
var j = 2
var r = i + j //作加法运算
fmt.Println("r=", r)

var str1 = "hello"
var str2 = "world"
var res = str1 + str2 //作拼接操做
fmt.Println("res=", res)
}
D:\goproject\src\go_code\chapter02\demon04>go run main.go
r= 3
res= helloworld

    数据类型的基本介绍：

    每一种数据都定义了明确的数据类型，在内存中分配了不一样大小的内存空间。
    （二）Golang的变量函数

    整数类型：

  • 基本介绍
    简单的说，就是用于存放整数值的，好比0，-1,2345等等。
  • 整型的类型
    （二）Golang的变量
    （二）Golang的变量
    （二）Golang的变量
  • 整数的使用细节
    1）Golang各整数类型分：有符合和无符号，int uint的大小和系统有关；
    2）Golang的整数默认声明为int型； 
    package main
import(
"fmt"
)
func main() {
var n1 = 100
//%T表示内容的数据类型
fmt.Printf("n1 的类型是 %T\n", n1)
}
    D:\gocode\goproject02\main01>go run main.go
n1 的类型是 int

    3）如何在程序查看某个变量的字节大小和数据类型布局

    package main
import(
"fmt"
"unsafe" //前提引入unsafe函数
)
func main() {
var n1 = 100
//%T表示内容的数据类型
fmt.Printf("n1 的类型是 %T\n", n1)
//如何在程序查看某个变量的占用字节大小和数据类型
var n2 int64 = 10
//unsafe.Sizeof(n2) 是unsafe包的一个函数，能够返回n2变量占用的字节数
fmt.Printf("n2 的数据类型是 %T\nn2占用的字节大小是 %d", n2, unsafe.Sizeof(n2))
}
    D:\gocode\goproject02\main01>go run main.go
n1 的类型是 int
n2 的数据类型是 int64
n2占用的字节大小是 8

    4）Golang程序中整型变量在使用时，遵照保小不保大的原则，即：在保证程序正确运行下，尽可能使用占用空间小的数据类型。
    5）bit：计算机中的最小存储单位；byte：计算机中基本存储单元；1byte=8bitui

    小数类型/浮点型：

  • 基本介绍
    小数类型就是用来存放小数的，好比：1.2 0.12-1.94 
    package main
import(
"fmt"
)
//演示golang中小数类型使用
func main() {
var price float32 = 87.23
fmt.Println("price", price)
}
    D:\gocode\goproject02\main02>go run main.go
price 87.23
  • 小数类型分类
    （二）Golang的变量
    对上图的说明：
    1）浮点数=符号位+指数位+尾数位；说明浮点数都是有符号的。
    2）尾数部分可能会丢失，形成精度损失，如：-123.0000901
    //尾数部分可能会丢失，形成精度损失 
    var num3 float32 = -123.00000901
var num4 float64 = -123.00000901
fmt.Println("num3=", num3,"num4=", num4)
    D:\goproject\src\go_code\chapter02\floatdemo06>go run main.go
num3= -123.00001 num4= -123.00000901

    说明：float64 的精度比float32 的要准确。编码

  • 浮点型使用细节
    1）Golang浮点类型有固定的范围和字段长度，不受具体OS（操做系统）的影响；
    2）Golang的浮点类型默认为float64类型； 
    //Golang的浮点类型默认声明为float64类型
var a = 1.1
fmt.Printf("a的数据类型为 %T \n", a)
    D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
a的数据类型为 float64

    3）浮点型常量有两种表示形式；
    ① 十进制数形式：如 5.12 .512（必须有小数点）操作系统

    //十进制数形式
b := 5.12
c := .123
fmt.Println("b=", b, "c=", c)
    D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
b= 5.12 c= 0.123

    ② 科学计数法形式：如 5.1234e2 ==== 5.12 * 10的2次方； 5.12E-2 ==== 5.12/10的2次方

    //科学计数法形式
d := 5.1234e2 // 5.1234 * 10的2次方
e := 5.1234E2 // 5.1234 * 10的2次方
f := 5.1234E-2 // 5.1234 / 10的2次方
fmt.Println("d=", d, "e=", e, "f=",f)
    D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
d= 512.34 e= 512.34 f= 0.051234

    4）Golang浮点型只有这两种类型，float32 和 float64，float64 比 float32 更精确。

    字符类型：

  • 基本介绍
    Golang中没有专门的字符类型，若是要存储单个字符（字母），通常使用byte来保存；
    字符串就是一串固定长度的字符链接起来的字符序列。Go的字符串是由单个字节链接起来的；也就是说对于传统的字符串是由字符组成的，而Go的字符串不一样，它是由字节组成的。

  • 案例演示

    package main
import(
"fmt"
)
//演示golang中字符类型使用
func main() {
var c1 byte = 'a'
var c2 byte = '0' //字符的0
//当直接输出byte值，就是输出了对应字符的码值
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)

//若是但愿输出对应字符，须要格式化输出
fmt.Printf("c1=%c c2=%c\n", c1, c2)

//若是输出的码值高于byte（0-255）的范围，输出就会溢出,能够用int
var c3 int = '北'
fmt.Printf("c3=%c c3对应码值=%d", c3, c3)
}
    D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
c1= 97
c2= 48
c1=a c2=0
c3=北 c3对应码值=21271

    对上面代码说明：
    1）若是保存的字符在ASCII表，好比【0-1，a-z，A-Z...】直接能够保存到byte；
    2）若是保存的字符对应码值大于255，这时能够考虑使用int类型保存；好比中文；
    3）若是须要按照字符的方式输出，这时须要格式化输出，即 fmt.Printf("%c", c1)。

  • 字符类型使用细节
    1）字符常量是用单引号（‘’）括起来的单个字符；如：var c1 byte = 'a' 里面的“a”
    2）Go中容许使用转义字符“\”来将其后的字符转变为特殊字符型常量；如：var c2 char = '\n' ============='\n'表示换行符
    3）Go语言的字符使用UTF-8编码，查询字符对应的utf8码值=====直接搜索”utf8 编码“；UTF-8 编码包含 ASCII 编码；
    英文字母——1个字节；汉字——3个字节
    4）在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8码值；
    5）能够直接给某个变量赋一个数字，而后按格式化输出时%c，会输出该数字对应的unicode字符； 
    //能够直接给某个变量赋一个数字，而后按格式化输出时%c，会输出该数字对应的unicode字符；
var c4 int = 22269  //22269 -> '国'
fmt.Printf("c4=%c\n", c4)
    D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
c4=国

    6）字符类型是能够进行运算的，至关于一个整数，由于它都有对应的Unicode码；

    //字符类型是能够进行运算的，至关于一个整数，运算时按照码值运行；
var n1 = 10 + 'a' // 至关于 10 + 97 = 107
fmt.Println("n1=", n1)
    D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
n1= 107
  • 字符类型的本质探讨
    1）字符型存储到计算机中，须要将字符对应的码值（整数）找出来；
    存储：字符 ——> 对应码值 ——> 二进制 ——> 存储
    读取：二进制 ——> 码值 ——> 字符 ——> 读取
    2）字符和码值的对应关系是经过字符编码表决定的（规定好的）；
    3）Go语言的编码统一使用UTF-8，很是的方便、统一，不会出现编码乱码的问题。

    布尔类型：

  • 基本介绍
    1）布尔类型也叫bool类型，bool类型数据只容许取值true或者false；
    2）bool类型占1个字节；
    3）bool类型适于逻辑运算，通常用于程序流程控制【if条件控制语句和for循环控制语句】
    4）不能够用0或非0的整数替代false和true。
  • 案例演示 
    package main
import(
"fmt"
"unsafe"
) 
//演示golang中bool类型使用
func main() {
var b = false
fmt.Println("b=", b)
//注意事项
//1. bool类型占用存储空间为1个字节
fmt.Println("b 的占用字节 =", unsafe.Sizeof(b))
//2. bool类型只能取true或者false
}
    D:\goproject\src\go_code\chapter02\booldemo08>go run main.go
b= false
b 的占用字节 = 1

    字符串类型：

  • 基本介绍
    字符串就是一串固定长度的字符链接起来的字符序列；Go的字符串是由单个字节链接起来的；Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
  • 案例演示 
    //演示golang中string类型使用
func main() {
//string的基本使用
var address string = "北京长城 112 helloworld！"
fmt.Println(address)
}
    D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
北京长城 112 helloworld！
  • string使用细节和注意事项
    1）字符串一旦赋值，字符串就不能修改了：在Go中，字符串是不可变的；
    2）字符串的两种表示形式
    ①双引号，会识别转义字符； 
    //使用双引号，支持转义字符
str1 := "abc\nbcd"
fmt.Println(str1)
    D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
abc
bcd

    ②反引号，以字符串的原生形式输出，包括换行和特殊字符，能够输出源代码等效果。

    //使用反引号，以字符串的原生形式输出，适用于输出源码
str2 := `
package main
import(
    "fmt"
)
`
fmt.Println(str2)
    D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
    package main
    import(
            "fmt"
    )

    3）字符串拼接方式

    //字符串拼接方式
var str3 = "hello" + "world!"
fmt.Println(str3)
    D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
helloworld!

    4）当拼接字符串太长时，须要使用到多行字符串，能够以下处理【注意，将+号留在上一行】

    //当拼接的字符串很长时，能够分行写，注意将+保留在上一行
var str4 = "hello" + "world!" + "world!" + "world!" + 
"hello" + "world!" + "world!" + "world!" + "hello" + 
"world!" + "world!" + "world!" + "hello" + "world!" + 
"world!" + "world!"
fmt.Println(str4)
    D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
helloworld!world!world!helloworld!world!world!helloworld!world!world!helloworld!
world!world!

    基本数据类型的默认值

  • 基本介绍
    在go中，数据类系都有一个默认值，当程序员没有赋值时，就会保留默认值；在go中，默认值又叫零值。
  • 基本数据类型的默认值以下：
    （二）Golang的变量
  • 案例 
    package main
import(
"fmt"
)
//基本数据类型的默认值
func main() {
var a int  // =0
var b float32   // =0
var c float64   // =0
var d bool  // false
var name string  // ""
//这里的%v 表示按照变量的值输出
fmt.Printf("a=%d,b=%v,c=%v,d=%v,name=%v", a,b,c,d,name)
}
    D:\goproject\src\go_code\chapter02\defaultdemo10>go run main.go
a=0,b=0,c=0,d=false,name=

    基本数据类型的相互转换

  • 基本介绍
    Golang和 Java/c 不一样，Go在不一样类型的变量之间赋值时须要显示转换；也就是说Golang中数据类型不能自动转换。
  • 基本语法
    表达式 T(v) 将值 v 转换为类型 T。
    T：就是数据类型，好比 int32，int64，float32 等等；
    v：就是须要转换的变量。
  • 案例演示 
    package main
import(
"fmt"
)
//演示golang中基本数据类型的转换
func main() {
var i int32 = 100
//将 i => float32
var n1 float32 = float32(i)
//低精度 => 高精度
var n2 int64 = int64(i)
fmt.Printf("i=%v n1=%v n2=%v", i,n1,n2)
}
    D:\goproject\src\go_code\chapter02\transtype11>go run main.go
i=100 n1=100 n2=100
  • 基本数据类型相互转换的注意事项
    1）Go语言中，数据类型的转换能够是从 表示范围小---->表示范围大，也能够 范围大----->范围小；
    2）被转换的是变量存储的数据（即值），变量自己的数据类型并无变化！ 
    package main
import(
"fmt"
)
//演示golang中基本数据类型的转换
func main() {
var i int32 = 100
//将 i => float32
var n1 float32 = float32(i)
//低精度 => 高精度
var n2 int64 = int64(i)
fmt.Printf("i=%v n1=%v n2=%v\n", i,n1,n2)
//被转换的是变量存储的数据（即值），变量自己的数据类型并无变化！！！
fmt.Printf("i type is %T", i)
}
    D:\goproject\src\go_code\chapter02\transtype11>go run main.go
i=100 n1=100 n2=100
i type is int32

    3）在转换中，好比将 int64 转换成 int8（-128----127），编译时不会出错，只是转换的结果是按溢出处理，和咱们但愿的结果不同，所以在转换时，须要考虑范围。

    //在转换中，好比将 int64 转换成 int8（-128----127），编译时不会出错;
//只是转换的结果是按溢出处理，和咱们但愿的结果不同;所以在转换时，须要考虑范围。
var num1 int64 = 999999
var num2 int8 = int8(num1)
fmt.Println("num2=", num2)
    D:\goproject\src\go_code\chapter02\transtype11>go run main.go
num2= 63

  • 课堂练习
    1）如下代码编译不能经过和解决方案

    package main
import(
"fmt"
)
func main() {
var n1 int32 = 12
var n2 int64
var n3 int8

//不能编译经过，由于没有进行数据类型转换
n2 = n1 + 20    //int32 ----> int64 错误
n3 = n1 + 20    //int32 ----> int8 错误

//如下是解决方案
n2 = int64(n1) + 20
n3 = int8(n1) + 20
fmt.Println("n2=", n2, "n3=", n3)
}

    2）若是相加的值大于自己的数据类型范围，则编译不经过

    func main() {
//若是相加的值大于自己的数据类型范围，则编译不经过
var n4 int32 = 12
var n5 int8
var n6 int8
n5 = int8(n4) + 127 //【编译经过，可是结果按溢出处理】
n6 = int8(n4) + 128 //【编译不经过，由于128超出int8数据类型的范围】
fmt.Println("n5=", n5)
}

    基本数据类型和string的转换

  • 基本介绍
    在程序开发中，常常将基本数据类型转换成string，或者将string转换成基本数据类型。

  • 基本数据类型转换string类型
    1）方式一：fmt.Sprintf("%参数"， 表达式)
    函数介绍：

    func Sprintf
func Sprintf(format string, a ...interface{}) string
Sprintf根据format参数生成格式化的字符串并返回该字符串。

    参数须要和表达式的数据类型相匹配；fmt.Sprintf().. 会返回转换后的字符串。
    案例演示：

    package main
import(
"fmt"
)
//演示golang中基本数据类型转换string类型
func main() {
var num1 int = 99
var num2 float64 = 23.456
var b bool = true
var myChar byte = 'h'
var str string  //空的string

//使用第一种方式 fmt.Sprintf 来转换
str = fmt.Sprintf("%d", num1)
fmt.Printf("str type %T; str=%q\n", str, str)

str = fmt.Sprintf("%f", num2)
fmt.Printf("str type %T; str=%q\n", str, str)

str = fmt.Sprintf("%t", b)
fmt.Printf("str type %T; str=%q\n", str, str)

str = fmt.Sprintf("%c", myChar)
fmt.Printf("str type %T; str=%q", str, str)
}
    D:\goproject\src\go_code\chapter02\basictype2string12>go run main.go
str type string; str="99"
str type string; str="23.456000"
str type string; str="true"
str type string; str="h"

    2）方式二：使用strconv包的函数
    函数介绍：

    func FormatBool(b bool) string
func FormatInt(i int64, base int) string
func FormatUint(i uint64, base int) string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string

    案例说明：

    package main
import(
"fmt"
"strconv"
)
func main() {
//使用第二种方式 strconv 函数来转换
var num3 int = 99
var num4 float64 = 23.456
var b2 bool = true

str = strconv.FormatInt(int64(num3), 10)
fmt.Printf("str type %T; str=%q\n", str, str)

//说明:'f'格式；10：表示小数位保留10位；64：表示这个小数是float64；
str = strconv.FormatFloat(num4, 'f', 10, 64)
fmt.Printf("str type %T; str=%q\n", str, str)

str = strconv.FormatBool(b2)
fmt.Printf("str type %T; str=%q", str, str)

//strconv包中有一个函数 Itoa，能够将int类型转换成string；
var num5 int = 3456
str = strconv.Itoa(num5)
fmt.Printf("str type %T; str=%q", str, str)
}
    D:\goproject\src\go_code\chapter02\basictype2string12>go run main.go
str type string; str="99"
str type string; str="23.4560000000"
str type string; str="true"
str type string; str="3456"

  • string类型转换基本数据类型
    使用strconv包的函数，函数介绍：

    func ParseBool(str string) (value bool, err error)
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func ParseFloat(s string, bitSize int) (f float64, err error)

    案例演示：

    package main
import(
"fmt"
"strconv"
)
//演示golang中string类型转换基本数据类型
func main(){
var str string = "true"
var a bool
//strconv.ParseBool(str) 函数会返回两个值（value bool，err error）
//由于只想获取到value bool，使用_忽略第二个值；
a, _ = strconv.ParseBool(str)
fmt.Printf("a type %T; a=%v\n", a, a)

var str2 string = "1234566"
var b int64
b, _ = strconv.ParseInt(str2, 10, 64)
fmt.Printf("b type %T; b=%v\n", b, b)

var str3 string = "124.324"
var c float64
c, _ = strconv.ParseFloat(str3, 64)
fmt.Printf("c type %T; c=%v", c, c)
}
    D:\goproject\src\go_code\chapter02\string2basictype13>go run main.go
a type bool; a=true
b type int64; b=1234566
c type float64; c=124.324

    说明一下，因为strconv函数返回的是int64或float64，若是但愿获得int32，float64等，以下处理：

    var d int64
d = int32(d)

    指针：

  • 基本介绍
    1）基本数据类型，变量存的就是值，也叫值类型；变量存值都对应一个地址。
    2）获取变量的地址，用 &，好比：var num int，获取num的地址：&num
    分析一下基本数据类型在内存的布局:
    （二）Golang的变量
    3）指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值。好比：var ptr int = &num
    举例说明：指针在内存中的布局
    （二）Golang的变量
    4）获取指针类型所指向的值，使用星号，*ptr

    package main
import(
"fmt"
)
//演示golang中指针类型
func main() {
//基本数据类型在内存布局
var i int = 10
//i的地址是什么，&i
fmt.Println("i的地址=", &i)

//ptr是一个指针变量；ptr的类型是*int；
//ptr自己的值为&i（变量i对应的地址）;
var ptr *int = &i
fmt.Printf("ptr=%v\n", ptr)
fmt.Printf("ptr的地址=%v\n", &ptr)

//获取指针类型所指向的值，使用 *
fmt.Printf("ptr指向的值=%v", *ptr)
}
    D:\gocode\goproject02\pointerdemo>go run main.go
i的地址= 0xc042050058
ptr=0xc042050058
ptr的地址=0xc04206e020
ptr指向的值=10

  • 案例演示
    1）写一个程序，获取一个int变量num的地址，并显示到终端；
    2）将num的地址赋给指针ptr，并经过ptr去修改num的值。

    package main
import(
"fmt"
)
func main() {
var num int = 100
fmt.Println("num的地址=", &num)

var ptr *int = &num
fmt.Printf("ptr=%v\n", ptr)
*ptr = 200
fmt.Println("num=", num)
}
    D:\gocode\goproject02\pointerdemo>go run main02.go
num的地址= 0xc042050058
ptr=0xc042050058
num= 200
  • 指针课堂练习
    （二）Golang的变量
  • 指针的使用细节
    1）值类型，都有对应的指针类型，形式为*数据类型，好比int对应的指针就是 *int，float32对应的指针就是 *float32，以此类推。
    2）值类型包括：基本数据类型 int系列，float系列，bool，string，数组和结构体struct。

    值类型和引用类型

  • 值类型和引用类型的说明
    1）值类型：基本数据类型 int系列，float系列，bool，string，数组和结构体struct；
    2）引用类型：指针，slice切片，map，管道chan，interface等都是引用类型。
  • 值类型和引用类型的使用特色
    1）值类型：变量直接存储值，内存一般在栈中分配；
    示意图：
    （二）Golang的变量
    2）引用类型：变量存储的是一个地址，这个地址对应的空间才是真正存储数据（值），内存经过在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收。
    示意图：
    （二）Golang的变量
    3）内存的桟区和堆区示意图
    （二）Golang的变量

    标识符的命名规范

  • 标识符概念
    1）Golang对各类变量、方法、函数等命名时使用的字符序列称为标识符；
    2）凡是本身能够起名字的地方都叫标识符。
  • 标识符的命名规则
    1）由26个英文字母大小写，0-9，_组成；
    2）数字不能够开头；var num int //ok; var 3num int //error
    3）Golang中严格区分大小写；
    var num int
    var Num int
    说明：在golang中，num和Num是两个不一样的变量。
    4）标识符不能包含空格；
    （二）Golang的变量
    5）下划线“_”自己在Go中是一个特殊的标识符，称为空标识符。能够表明任何其余的标识符，可是对应的值会被忽略（好比：忽略某个返回值）。因此仅能被做为占位符使用，不能做为标识符使用。
    6）不能以系统保留关键字做为标识符（一共有25个），好比：break，if 等等。
  • 标识符命名注意事项
    1）包名：保持package的名字和目录保持一致，尽可能采起有意义的包名，简短，有意义，不要和标准库冲突 fmt
    2）变量名、函数名、常量名：采用驼峰法
    举例：var stuName string = "tom" 形式：xxxYyyyZzzz...
    3）若是变量名、函数名、常量名首字母大写，则能够被其余的包访问；若是首字母小写，则只能在本包中使用。
    （二）Golang的变量
  • 系统保留关键字
    在go中，为了简化代码编译过程当中对代码的解析，其定义的保留关键字只有25个。
    （二）Golang的变量
  • 系统的预约义标识符
    除了保留关键字外，go还提供了36个预订的标识符，其包括基础数据类型和系统内嵌函数。
    （二）Golang的变量
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程