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地图