澳门新银河国际网站-www.2G.com【注册登录】
做最好的网站

go语言 2 变量、常量和数据类型

作品由作者马志国在和讯的原创,若转发请于显然处标识出处:

2.1 变量

变量是对一块内部存款和储蓄器空间的命名,程序能够通过定义二个变量来报名一块内部存款和储蓄器空间。然后可以经过引用变量名来使用那块存款和储蓄空间。

 图片 1

2.1.1 变量命名

Go语言中的变量名、常量名、类型名、函数名和包名等具有的命名和C语言同样都遵守这样多少个简便的命名法规:三个名字必得以三个假名或下划线发轫,前面可以跟大肆数量的字母、数字或下划线。对于字母区分轻重缓急写,比方:name和Name是五个不等的名字。

命名无法与重大字一样,Go语言提供了23个重大字,只可以在特定的语法中动用。

23个关键字

break

default

func

interface

go语言 2 变量、常量和数据类型。select

case

defer

go

map

struct

go语言 2 变量、常量和数据类型。chan

go语言 2 变量、常量和数据类型。else

goto

package

switch

const

fallthrough

if

range

type

continue

for

import

go语言 2 变量、常量和数据类型。return

var

 

其他,Go语言还大概有大致30几个预约义的名字,首要用于内建的常量、类型和函数。这么些名字不是任重(英文名:rèn zhòng)而道远字,可以另行定义和使用,尽管在有的异样现象中再一次定义是有含义的,但提出尽量不要再度定义,以促成语义混乱难题。

内建常量

true false iota nil

内建档案的次序

int int8 int16 int32 int64

uint uint8 uint16 uint32 uint64 uintptr

float32 float64 complex128 complex64

bool byte rune string error

内建函数

make len cap new append copy close delete

complex real imag

panic recover

 

2.1.2 变量证明

1 平日宣称格式

动用var能够创立贰个一定项目标变量。变量注脚的相似语法如下:

var 变量名 类型 =  表达式

中间“类型”或“=表达式”多少个部分能够轻巧当中的三个。假若轻易的是类型音信,那么将依据早先化表达式来演绎变量的类型。如若表明式省略,将用零值初叶化该变量。

var i int = 1

var j int   //j的值初始化为0

var k = 10  // k的类型自动推导

假定叁个名字在函数内部定义,那么它不得不在函数内部使用,假使在函数外界定义,那么在现阶段包的具备文件都得以访谈。名字首字母的分寸写决定了它在包外的可以看到性,首字母大写在包外可以访问。包本人的名字平常总是用小写字母。

在包等级申明的变量会在main入口函数施行以前实现开首化,局地变量就要表明语句被实践的时候做到开端化。若无体现开始化,那么将用零值起首化该变量。贰个变量申明后并未有选取也会挑起编写翻译错误。

2 简短变量注解

“名字 := 表明式”,变量的项目依据表明式自动推导。由于选取简便利落,被普遍用于大多数的片段变量的扬言和初步化。注意,简短变量注明不能用于包级其他变量证明。

i := 100

 

3 多少个变量表明

var i, j, k int = 1, 2, 3

var m, n int

var a, b, c = 1, 2, 3

d, e, f := 1, 2, 3

name, age := "张三", 20

也能够这么写:

var (

     name string

     age  int

)

 

2.1.3 赋值

1 轻巧赋值

赋值语句是立异一个变量的值,最轻巧易行的赋值”变量名= 新值的表达式”

var i int

i = 1      //简单赋值

 

2复合赋值运算符

特定的二元算术运算符和赋值语句的复合操作有二个轻松的款型

var i int

i = i + 1

i += 1    //与i = i + 1等价

 

数值变量也能够支撑++递增和--递减语句。注意它是话语,不是表明式,所以x=i++那样的表明式是指鹿为马的。

3多种赋值

多种赋值允许相同的时候革新四个变量的值。在赋值在此以前,赋值语句侧面的具有表明式会先实行求值,然后再统一更新侧面对应的变量的值。那样在做多个数值沟通时,没有要求引进第多个变量了。

x,y=y,x

4 _标识符

稍许表明式会生出多少个值,譬如调用二个有五个重返值的函数。能够利用下划线空白标记符_来丢弃无需的值。

_, err := io.Copy(dst, src)//丢弃字节数

 

2.2 常量

在Go语言中,常量是指编写翻译时期就已知且不可改动的值。常量的暧昧类型都以基础项目,包罗整型、浮点型、复数型、布尔类型和字符串类型等。

2.2.1 字面常量

所谓字面常量,是指程序中硬编码的常量,如:

25

3.14159

2+3i

true

"hello"

在别的语言中,常量日常有特定的连串,Go语言的字面常量是无类型的。只要这几个常量在对应品种的值域范围内,就能够当作该类型的常量。譬喻,25得以赋值给int、 uint、int32、int64、float32、float64、complex64、complex128等类型的变量。

2.2.2 常量申明

使用const来声称常量,可以给常量三个温馨的名字比如:

const pi = 3.1415926

也足以批量证明:

const (

     e = 2.7182818

     pi = 3.1415926

)

三个常量的宣示也能够界定品种,但不是至关重要的。若无呈现内定项目,那么它与字面量同样,是无类型常量。常量定义的右值也能够是一个在编写翻译期运算的常量表明式,比方:

const i = 1 << 3 //右值是常量表达式

万一是批量评释的常量,除第1个外其余的常量的侧边的早先化表达式都得以省略,暗许使用前边常量的最早化表明式写法。比方:

const (

        a = 1

        b

        c = 2

        d

        e

    )

    fmt.Println(a, b, c, d, e)

打印结果:1 1 2 2 2

2.2.3 iota常量生成器

Go语言预订义的常量有:true、false和iota,在那之中iota比较特殊。常量评释能够选用iota常量生成器开首化,它用于生成一组以相似法则伊始化的常量,可是绝不每行都写一遍初叶化表达式。在一个const表明语句中,在第多个阐明的常量所在的行,iota将会被置为0,然后在每三个有常量申明的行加一。下边是根源time包的例证。这种定义法在Go语言中何奇之有用于定义枚举值。

type weekday int

const(

    Sunday weekday iota   //0

    Monday                //1   

    Tuesday               //2

    Wednesday             //3

    Thursday              //4

    Friday                //5 

    Saturday              //6

)

小编们也得以在错落有致的常量表明式中选取iota,比方上面各个常量都以1024的幂。

const (

    _ = 1 << (10 * iota)

    KiB

    MiB

    GiB

    TiB

)

fmt.Println(KiB, MiB, GiB, TiB)

打印结果:1024 1048576 1073741824 1099511627776

小结:var 申明变量,const阐明常量。注明时得以带项目。也得以不带项目,通过右测度。

2.3 数据类型

Go语言将数据类型分为四类:基础项目、复合类型、引用类型和接口类型。

  1. 中央数据类型:数值、字符串和布尔型。
  2. 复合数据类型:数组和结构体。
  3. 援引类型:指针、切块、字典、函数和通道。
  4. 接口类型。

2.3.1 整数

1 整数类型

Go语言的数值类型包涵了三种分歧尺寸的板寸、浮点数和复数。各类数值类型都决定了相应的取值范围和是或不是协助正负号。

 

类型

长度(字节)

取值范围

int8

1

(0~255)

uint8

1

(-128~127)

int16

2

(0~65535)

uint16

2

(-32768~32767)

int32

4

(-2147483648~2147483647)

uint32

4

(0~4294967295)

int64

8

(-9223372036854775808~9223372036854775807)

uint64

8

(0~18446744073709551615)

int

4或8

与机器字长和编译器都有关系

uint

4或8

与机器字长和编译器都有关系

uintptr

4或8

32平台4个字节,64位平台8个字节,底层编程才需要

byte

1

与uint8等价,通常表示一个unicode字符编码

rune

4

与int32等价,一般强调是一个原始数据而不是一个小整数。在一个字符串中,表示一个字符对应utf8的码点。

 

2 运算符

Go语言提供了增加的内置运算符,包括算术运算符、相比运算符、逻辑运算符、位运算符、赋值运算符和别的运算符等。

算术运算符:

运算符

描述

+

-

*

/

%

模运算(求余数)

++

自增

--

自减

 

在Go语言中,%取模运算符的标志和被取模的标志总是同样的,因而5%3和5%-3的结果都以2。除法运算符的结果则依赖于操作数是不是全为整数,举例5.0/4.0的结果是1.25,不过7/4的结果为1,去掉小数部分,实际不是四舍五入。

关系(比较)运算符:

三个一样的整数类型可以使用下边包车型大巴二元关系运算符举办相比较,比较表明式的结果是布尔类型。

运算符

描述

==

相等

!=

不等

<

小于

<=

小于或等于

>

大于

>=

大于或等于

 

 

逻辑运算

运算符

描述

!

&&

||

 

位运算:

前4个操作运算符并不区分是有暗记如故无符号数:

运算符

描述

&

位与and (左侧和右侧都为1,则为1;否则为0)

|

位或 or(左侧或右侧只要有一个为1,结果为1;都为0结果才为0)

^

位异或 xor (相同为0,不同为1)

&^

位清空and not(右侧是0,左侧数不变;右侧是1,则左侧数清零)

<<

左移

>>

右移

位运算的事例:

X=2,y=15

二进制结果

十进制结果

0000 0010 & 0000 1111

0000 0010

 2

0000 0010 | 0000 1111

0000 1111

15

0000 0010 ^ 0000 1111

0000 1101

13

0000 0010 &^ 0000 1111

0000 0000

0

0000 0010<<3  

0001 0000

16

0000 0010>>1

0000 0001

1

 

运算符优先级:

 

 

2.3.2 浮点数

浮点数用于表示包涵小数点的数码。Go语言提供了二种精度的浮点数,float32和float64。float32与float64之间供给强制调换。强制调换的格局T(V),T为要转移的靶子项目,V需求改换的变量。

1 浮点数表示

var f1 float32

f1 = 10

f2 := 12.0 //带小数点的自动推导为float64

f2 = float64(f1) //需强制转换

 

2 浮点数相比较

因为浮点数不是一种标准的表明格局,所以不能够像整型那样直接用==相比。推荐的法子如下,引入math包,总括八个数值之差的断然值,假使这么些结果一点都不大,大家就觉着那七个数值是相等的。至于那些数小到何以水平定义为相等,技师能够依靠项目供给和谐定义。

import  "math"

func IsEqual(f1, f2, p float64) bool {

    return math.Abs(f1-f2) < p

}

 

3 科学计数法

把四个数表示成a(1≤a<10,n为整数)与10的幂相乘的款型,这种记数法叫做科学记数法。例如:1988=1.99×10^3。计算器或Computer表明10的幂是平日是用E或e,也正是1.99E3=一九八九。

f1 := 1.99e+3   //1990

f2 := 1.99e-3   //0.00199

 

2.3.3 复数

Go语言提供了三种精度的复数类型:complex64和complex128,分别对应float32和float64二种浮点数精度。内建函数和自然的书写格局。

x := complex(1, 2) //内建函数

y := 1 + 2i     //自然书写

// real返回实部,imag返回虚部

fmt.Println(x, y, real(x), imag(x), real(y), imag(y))

打印结果:(1+2i) (1+2i) 1 2 1 2

2.3.4 布尔型

三个布尔类型的值唯有二种:true和false。布尔值不会隐式调换为数值0或1。布尔值能够和&&、||操作符结合,并且恐怕会有不通行为。借使运算符左边已经足以规定整个布尔表明式的值,那么左侧的表明式将不再求值。

var s string

//s = "mazhiguo"

if s != "" && s[0] == 'm' {

   fmt.Println("OK")

else {

   fmt.Println("error")

}

2.3.5 字符串

1 字符串常用操作

在Go语言中字符串也是一种为主项目。三个字符串是叁个不足更换的字节类别。常用的字符串操作如下表所示:

运算

含义

备注

s1+s2

字符串连接

 

len(s)

字符串长度

字符串中的字节数,不是字符数

s[i]

取字符

索引i不能越界

s[i:j]

取子字符串

左闭右开,包含s[i],不包含s[j]。子字符串是一个新的字符串。

i,j都可能被忽略,忽略时,从0开始,最后一个字符结束。

 

s := "hello " + "world"

fmt.Println(len(s))// 11

fmt.Println(s[0], s[len(s)-1])//104 100 (h 和 d)

fmt.Println(s[1:4])//"ell"

fmt.Println(s[:5])//"hello"

fmt.Println(s[6:])//"world"

fmt.Println(s[:])//"hello world"

2 字符串值不可变

字符串的值是不可变的:一个字符串包蕴的字节系列永恒不会被转移,当然大家得以给三个字符串变量分配三个新字符串值。

s := "hello world"

s[0] = "H"  //这是错误演示,字符串序列不能修改

s = "Hello" //给字符串变量s重新赋值

3 字符串遍历

字符串遍历帮助以字节的不二等秘书技遍历和以字符的不二诀窍遍历。

s := "hello 世界"

n := len(s)

//以字节的方式遍历

for i := 0; i < n; i++ {

  fmt.Println(i, s[i])

}

//以字符的方式遍历

for i, ch := range s {

  fmt.Println(i, ch)

}

 

打印结果:

0 104

1 101

2 108

3 108

4 111

5 32

6 228

7 184

8 150

9 231

10 149

11 140

0 104

1 101

2 108

3 108

4 111

5 32

6 19990

9 30028

 

4转义种类

在三个双引号包罗的字符串字票面价值中,能够用反斜杠开头的转义连串插入任性的多寡。

遍布的ASCII调控代码的转义格局:

 

 

 

a

响铃

b

退格

f

换页

n

换行

r

回车

t

水平制表符

v

垂直制表符

单引号

双引号

\

反斜杠

 

 

5原生字符串字面值

原生的字符串字面值,用` `代表双引号。可用以编写正则表达式。常用于HTML模板、JSON面值、命令提醒音信乃至需求扩充到多行的现象。

tips := `请按要求执行以下操作:

 1 输入参数

 2 计算

 3 打印结果`

fmt.Println(tips)

 

6 UTF8编码

UTF8编码是一种字符编码,使用1到4个字节表示三个字符。ASCII部分字符只行使1个字节,常用字符部分使用2或3个字节。变长的编码不可能直接通过索引来访谈第n个字符。

Go语言的源文件接纳UTF8编码,unicode/utf8包提供提供了用来rune字符系列的UTF8编码和平解决码功用。如果关心种种unicode字符,可以运用UTF8解码器。unicode/utf8包蕴提供了该意义。

s := "hello 世界"

fmt.Println(len(s))    //12

fmt.Println(utf8.RuneCountInString(s))//8

将一个整数型调换为字符串意思是生成以只含有对应unicode编码字符的UFT8字符串,借使对应的编码的字符无效,将用‘uFfFD’无效字符作为替换:

fmt.Println(string(65))      //"A"

fmt.Println(string(0x4eac))  //"京"

fmt.Println(string(12345678)) //无效字符

 

string 接受到[]rune的类型调换,能够将多少个UTF8编码的字符串解码为unicode字符串连串:

s := "世界"

fmt.Printf("%xn", s) //e4b896e7958c,utf8编码

r := []rune(s)

fmt.Printf("%xn", r) //[4e16 754c],unicode编码

 

 

举个例子"汉"字的Unicode编码是6C49。6C49在0800-FFFF之间,所以要用3字节模板:1110xxxx 10xxxxxx 10xxxxxx。将6C49写成二进制是:0110 1100 0100 1001,将这些比特流按三字节模板的分层方法分为0110 1一千1 001001,依次代替模板中的x,获得:1110-0110 10-1一千1 10-001001,即E6 B1 89,那正是其UTF8的编码。

s := "汉"

fmt.Printf(" %xn", s) // e6b189,UTF8编码

r := []rune(s)

fmt.Printf("%xn", r)  //[6c49],unicode编码

unicode也正是字符编码,即字典。utf8、uft16是怎样以字节的措施存款和储蓄那一个编码。字符串可正如、可遍历、不可修改。

2.4指针

2.4.1 指针概念

指南针是八个档案的次序,该品种的变量称为指针变量。指针变量存款和储蓄贰个变量的地方。它分化于平日的变量,日常变量寄存的是数码本人,而指针变量贮存的是数额的地点。

 图片 2

2.4.2 评释指针变量

声明指针变量的相似格局如下:

var 变量名 *类型

例如:

var ip *int     //指向int类型的变量

var fp *float32 //指向float32类型的变量

var ptr [MAX]*int;//指向数组的指针

 

指南针操作注意事项:

  1. 默认值 nil,没有 NULL 常量。
  2. 操作符 "&" 取变量地址, "*" 通过过指针访谈目的对象。
    不⽀持指针运算,不⽀持 "->" 运算符,直接⽤ "." 访问目的成员
  3. 不可能对指针做加减法等运算
  4. 不真实函数的指针

package main

 

import "fmt"

 

type Student struct {

    Name string

    Age  int

}

 

func main() {

    a := 10

    b := 12.5

    var pa *int = &a

    var pb *float64 = &b

    //1 打印变量的值

    fmt.Printf("%v,%vn", a, b)

    fmt.Printf("%v,%vn", *pa, *pb)

    // 2 打印变量的地址

    fmt.Printf("%v,%vn", &a, &b)

    fmt.Printf("%v,%vn", pa, pb)

    // 3 指针默认值为nil

    var pc *int

    fmt.Printf("%v,n", pc)

    // 4 通过指针访问对象成员

    ps := &Student{"张三", 18}

    fmt.Println(ps.Name, ps.Age)

}

2.4.3数组指针和指针数组

数组指针是只贰个指南针变量保存的是数组的地点。指针数组,是指数组的各类元素都以指针类型。

package main

 

import "fmt"

 

func main() {

 

    var ptr *[3]int //数组指针

    arr := [3]int{1, 2, 3}

    ptr = &arr //保存了数组的地址

    fmt.Println(*ptr)

 

    var ptr2 [3]*int //指针数组,每一个元素都是指针

    a, b, c := 10, 20, 30

    ptr2[0] = &a

    ptr2[1] = &b

    ptr2[2] = &c

    fmt.Println(ptr2) //ptr2数组中的3个指针分别保存了a,b,c的地址

 

}

// 打印结果:

[1 2 3]

[0xc04200a2c8 0xc04200a2e0 0xc04200a2e8]

 

 

2.4.4 二级指针(多级指针)

二级指针保存一流指针变量的地方。

package main

 

import "fmt"

 

func main() {

 

    var a int = 100

    var pa *int = &a

    var ppa **int = &pa

 

    //打印a的值

    fmt.Printf("%v,%v,%vn", a, *pa, **ppa)

    //打印a的地址

    fmt.Printf("%v,%v,%v", &a, pa, *ppa)

 

}

//打印结果:

100,100,100

0xc0420401d0,0xc0420401d0,0xc0420401d0

 

2.5 type定义类型

在其余程序中都会设有有的变量有着同样的内部结构,不过却意味着完全差别的概念。 二个类型注解语句创立了三个新的花色名称,和水保项目具有一样的底层结构。

type 类型名字 底层类型

例如:

type Age int    //年龄

type Height int //身高

type Grade int  //分数

type绝不只是对应于C/C++中的typedef,它不是用于定义一多级的外号。更首要的是,它定义了一层层互不相干的行事特征:通过这一个互不相干的行事特征,本质上平等的东西展现出差异事物的性状:整数如故大背头,但年龄却不是莫斯中国科学技术大学学亦不是分数。大家得以分级为Age、Height、Grade定 义出下列差别的行为(表示为形式依然函数):

type Age int    //年龄

type Height int //身高

type Grade int  //分数

 

func (a Age) IsOld() bool {

// 超过50岁算老年

return a > 50

}

func (h Height ) NeedTicket() bool {

// 高于120cm需要买票

return h > 120

}

func (g Grade) Pass() bool {

// 60分及格

return g >= 60

}

系列证明语句常常出未来包一级,由此一旦新创造的品类名字首字母大写,则在包外能够利用。对于每三个类型T,都有贰个一见青眼的类型调换操作T(x),用于将x转变为T类型。

package main

 

import (

    "fmt"

)

 

type Integer int

 

func (a Integer) Less(b Integer) bool {

    return a < b

}

func main() {

    var a Integer = 1

    fmt.Println(a.Less(2))

    var b int

    //不能直接赋值,需要T(x)类型转换

    b = a

    b = int(a)

    fmt.Println(b)

}

 

2.6作用域

二个声称语句将次第中的实体和多少个名字关闭,比方贰个函数或多少个变量。注明语句的功用域是指源代码中得以有效选取那一个名字的限制。

不要将效能域和生命周期混为一谈。注解语句的成效域对应的是多个源代码的文本区域,它是一个编写翻译时的天性。八个变量的生命周期是指程序运转时变量存在的卓有成效时间段,在此时间区域内,它能够被先后的别样一些援引,是三个运作时的定义。

语法块是由花括号所含有的一八种讲话。语法块内部宣称的名字是无力回天被外表语法块访问的。语句块决定了在那之中宣称的名字的成效域范围。有四个语法块为一切源代码,称为全局语法块;然后是各种包的包语法块;每一个for、if和switch语句的语法块;各样switch或select的分段也是有单独的语法块;当然也可以有展现书写的语法块(花括号满含的说话)。

宣示语句对应的词法域决定了功用域范围的大小。对于内置的体系、函数和常量,举个例子int、len和true等都是全局功效域的;任何在函数外界注脚的名字能够在包的别的源文件中访谈,是包级效能域。对于导入的包,则是对应源文件级的成效域。调整流标号,就是break、continue或goto语句后继之的这种标号,是函数级功能域。

当编写翻译器境遇三个名字引用时,要是它是三个扬言,首先从最内层的成效域向全局成效域查找。假使寻找未果,则错误。假诺名字在里边和表面分别评释过,则内部块的扬言首先被找到,它会掩盖外界同名的申明。

2.7 数据输入输出

2.7.1 标准输出函数

Print( )函数接纳私下认可格式将其参数格式化并写入标准输出。若是多个相邻的参数都不是字符串,会在它们的出口之间加多空格。重返写入的字节数和境遇的其他错误。函数原型如下:

func Print(a ...interface{}) (n int, err error)

 

Println( )与Print( )函数的功力基本一致,唯一分裂的是在输出甘休后,自动扩张换行。函数原型如下:

func Println(a ...interface{}) (n int, err error)

 

Printf()函数依照format参数生成格式化的字符串并写入规范输出。重回写入的字节数和境遇的别的不当。函数原型如下:

func Printf(format string, a ...interface{}) (n int, err error)

2.7.2 标准输入函数

Scan( )函数从专门的学业输入扫描文本,将打响读取的空域分隔的值保存进成功传送给本函数的参数。换行视为空白。再次来到成功扫描的条条框框个数和境遇的此外不当。若是读取的条目比提供的参数少,会回去一个错误报告原因。函数原型如下:

func Scan(a ...interface{}) (n int, err error)

Scanln类似Scan,但会在换行时停下扫描。最终一个条目款项后必需有换行恐怕达到截止地点。函数原型如下:

func Scanln(a ...interface{}) (n int, err error)

Scanf从正式输入扫描文本,遵照format 参数钦赐的格式将成功读取的空域分隔的值保存进成功传送给本函数的参数。重回成功扫描的条规个数和遭遇的其余不当。函数原型如下:

 

func Scanf(format string, a ...interface{}) (n int, err error)

本文由澳门新银河国际网站发布于澳门新银河国际网站,转载请注明出处:go语言 2 变量、常量和数据类型

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。