go语言 2 变量、常量和数据类型。0X02 Go 语言 变量 常量 运算符。

章由作者马志国于博客园之原创,若转载请给大庭广众处于标记出处:http://www.cnblogs.com/mazg/

1.变量

Go 语言变量名由字母、数字、下划线组成,其中首个假名不能够也数字。
声明变量的形似式是采用 var 关键字:

var identifier type  

变量声明:
先是种,指定变量类型,声明后而未赋值,使用默认值。v_name = value

var v_name v_type

其次种,根据值自行判断变量类型。

 var v_name = value

老三种植,省略var, 注意
:=左侧的变量不应有是既宣称了之,否则会导致编译错误。

 v_name := value

例如

 var a int = 10
 var b = 10
 c : = 10

实例:

package main
var a = "菜鸟教程"
var b string = "runoob.com"
var c bool

func main(){
    d:=1 //这种写法只能在 方法体内 否则会出错
    println(a, b, c)
}

图片 1

image.png

多变量声明

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type

vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型,自动推断

vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的,否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

实例:

package main

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

图片 2

image.png

值类型和援类型

具像 int、float、bool 和 string
这些核心项目且属于值类型,使用这些项目的变量直接指向是内存中的价值,更复杂的多少一般会需要以多独字,这些数据一般以引用类型保存。一个引用类型的变量
r1 存储的是 r1
的值所在的内存地址(数字),这个内存地址为叫指针,这个指针实际上也叫有另外的某某一个字中。
跟一个援类型的指针指向的差不多单字可以是于接连的内存地址中(也得以拿这些字分散存放在内存中),每个字都指示了下一个配所于的内存地址。
当以赋值语句 r2 = r1 时,只有引用(地址)被复制。
设 r1
的价值为改成了,那么这价值的持有援都见面指向于修改后的内容,在斯例子中,r2
也会遭遇震慑。

一经在一如既往之代码块被,我们不可以再次于同一名称的变量使用初始化声明。
例如:

a := 20 编译器会提示错误 no new variables on left side of :=,

然 a = 20 是好的,因为就是叫一样之变量赋予一个初的价值。
假定您于概念变量 a 之前用其,则会博得编译错误 undefined: a。
若是您声明了一个片变量却从未当平的代码块被以它们,同样会获编译错误:
a declared and not used。
徒地叫 a 赋值也是不够的,这个价必须于使用.
唯独全局变量是允许声明但无利用。

并行 或 同时 赋值

一致品种的多独变量可以声明在一如既往行,如:

 var a, b, c int

多变量可以在相同行开展赋值,如:

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

面立行而了变量 a,b 和 c 都早已为声称,否则的话语应该这样用:

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

交换两独变量的值

 a, b = b, a

一无所获标识符 _ 也被用来抛弃值,如图,交换变量 d 抛弃不用,。

图片 3

image.png

_ 实际上是一个只有写变量,你切莫可知获取其的价值。这样做是因 Go
语言中您要利用具有被声称的变量。

2.1 变量

变量是针对性平块内存空间的命名,程序可以经过定义一个变量来报名一块内存空间。然后可以透过引用变量名来使用这块存储空间。

 图片 4

2.常量

常量是一个简便值的标识符,在程序运行时,不见面让改的量。
常量中的数据类型只可是布尔型、数字型(整数型、浮点型和复数)和字符串型。

常量的定义格式:

 const identifier [type] = value

乃可简简单单类型说明符 [type],因为编译器可以依据变量的价来测算其项目。

显式类型定义: const b string = “abc”
隐式类型定义: const b = “abc”
大抵单同档次的声明可以简写为:
const c_name1, c_name2 = value1, value2

实例:

 package main

 import "fmt"

 func main() {
    const LENGTH int = 10
    const WIDTH int = 5   
    var area int
    const a, b, c = 1, false, "str" //多重赋值

    area = LENGTH * WIDTH
    fmt.Printf("面积为 : %d", area)
    println()
    println(a, b, c)   
 }

图片 5

image.png

常量还可就此作枚举:

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)
}

图片 6

image.png

流淌:unsafe.Sizeof接受任意档次的价(表达式),返回其占用的字节数,字符串类型在
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
)

故法实例

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)
}

图片 7

image.png

2.1.1 变量命名

Go语言中之变量名、常量名叫、类型名、函数名为与包名等所有的命名和C语言一样都照这样一个简易的命名规则:一个名字务必为一个假名或生划线开头,后面可以与任意数量的字母、数字还是生划线。对于字母区分轻重缓急写,例如:name和Name是少数只不同之名字。

取名不可知与重大字相同,Go语言提供了25单至关重要字,只能于一定的语法中使用。

25独重要字

break

default

func

interface

select

case

defer

go

map

struct

chan

else

goto

package

switch

const

fallthrough

if

range

type

continue

for

import

return

var

 

除此以外,Go语言还有大约30大多独预定义的名字,主要用来内建的常量、类型以及函数。这些名字不是第一字,可以更定义跟运,虽然当一部分出奇状况中再次定义是来意义的,但建议尽量不要还定义,以促成语义混乱问题。

内建常量

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

 

3.运算符

运算符用于当程序运行时实行数学还是逻辑运算。
Go 语言内置的运算符有:
算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、其他运算符

主要是 其他运算符

运算符 描述
& 返回变量存储地点 &a; 将受有变量的其实地址。

  • 指南针变量。 *a; 是一个指针变量

图片 8

image.png

★ sublime代码自动重新缩进,使代码缩进重排
主意:Ctrl+A选中全部内容,然后以菜单中选择Edit->Line->Reindent

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 //右值是常量表达式

假定是批量宣称的常量,除第一独他其他的常量的下手的初始化表达式都可以简单,默认使用前常量的初始化表达式写法。例如:

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之幂相乘的样式,这种记数法叫做科学记数法。例如:1990=1.99×10^3。计算器或者微机表达10之挂是形似是用E或e,也就是1.99E3=1990。

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("%x\n", s) //e4b896e7958c,utf8编码

r := []rune(s)

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

 

 

譬如”汉”字的Unicode编码是6C49。6C49以0800-FFFF之间,所以如果因此3字节模板:1110xxxx 10xxxxxx 10xxxxxx。将6C49描绘成二进制是:0110 1100 0100 1001,将是比特流按三字节模板的分方法分为0110 110001 001001,依次代替模板被之x,得到:1110-0110 10-110001 10-001001,即E6 B1 89,这就是是彼UTF8的编码。

s := "汉"

fmt.Printf(" %x\n", s) // e6b189,UTF8编码

r := []rune(s)

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

unicode相当于字符编码,即字典。utf8、uft16凡是怎样为字节的方囤这个编码。字符串可正如、可遍历、不可修改。

2.4指针

2.4.1 指针概念

指南针是一个类别,该档的变量称为指针变量。指针变量存储一个变量的地点。它不同为一般的变量,一般变量存放的凡数额我,而指针变量存放的凡多少的地方。

 图片 9

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,%v\n", a, b)

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

    // 2 打印变量的地址

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

    fmt.Printf("%v,%v\n", 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,%v\n", 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)

Leave a Comment.