这些名字不是必不可缺字。声明变量的一般式是运用 var 关键字。

章由作者马志国在博客园的原创,若转载请让大庭广众处于标记出处: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)

相关文章