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)

admin

网站地图xml地图