当前位置:美高梅游戏 > 德军总部新巨人 > 这些名字不是关键字

这些名字不是关键字

文章作者:德军总部新巨人 上传时间:2019-09-11

2.2 常量

在Go语言中,常量是指编译时期就已知且不可更换的值。常量的秘闻类型都是基础项目,蕴含整型、浮点型、复数型、布尔类型和字符串类型等。

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的幂相乘的花样,这种记数法叫做科学记数法。举个例子:1989=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.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.4.1 指针概念

指南针是三个门类,该项指标变量称为指针变量。指针变量存款和储蓄三个变量的地点。它分化于一般的变量,一般变量寄存的是数据自己,而指针变量寄放的是数量的地址。

这些名字不是关键字。 图片 1

2.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.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.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.3 数据类型

这些名字不是关键字。Go语言将数据类型分为四类:基础项目、复合类型、援用类型和接口类型。

  1. 主导数据类型:数值、字符串和布尔型。
  2. 复合数据类型:数组和结构体。
  3. 援用类型:指针、切成条、字典、函数和通道。
  4. 接口类型。

2.1.1 变量命名

Go语言中的变量名、常量名、类型名、函数名和包名等具备的命名和C语言同样都依据那样多个差不离的命名准绳:三个名字必需以三个字母或下划线伊始,前面能够跟任意数量的假名、数字或下划线。对于字母区分轻重缓急写,比如:name和Name是四个区别的名字。

取名不可能与主要字同样,Go语言提供了24个关键字,只可以在特定的语法中应用。

22个基本点字

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

 

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.6作用域

一个宣称语句将次第中的实体和贰个名字关闭,比方二个函数或三个变量。评释语句的功能域是指源代码中得以有效采用这些名字的范围。

并不是将功能域和生命周期混为一谈。注明语句的成效域对应的是多个源代码的文本区域,它是多个编译时的性质。二个变量的生命周期是指程序运转时变量存在的立竿见影时间段,在此时间区域内,它能够被先后的别的一些援引,是贰个运作时的定义。

语法块是由花括号所满含的一多级讲话。语法块内部宣称的名字是心余力绌被外表语法块访谈的。语句块决定了当中宣称的名字的功能域范围。有贰个语法块为一切源代码,称为全局语法块;然后是各样包的包语法块;每一种for、if和switch语句的语法块;每一个switch或select的道岔也许有单独的语法块;当然也可以有突显书写的语法块(花括号包蕴的话语)。

声称语句对应的词法域决定了功能域范围的大小。对于内置的类型、函数和常量,比方int、len和true等都以全局效率域的;任何在函数外部申明的名字能够在包的其余源文件中访谈,是包级成效域。对于导入的包,则是对应源文件级的作用域。调节流标号,正是break、continue或goto语句后继之的这种标号,是函数级功用域。

当编写翻译器遇到三个名字援引时,借使它是叁个宣称,首先从最内层的功效域向全局作用域查找。即便搜索未果,则错误。假如名字在里面和外界分别注脚过,则内部块的宣示首先被找到,它会掩盖外界同名的扬言。

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.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.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.7 数据输入输出

2.2.1 字面常量

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

25

3.14159

2+3i

true

"hello"

在其他语言中,常量平常有一定的档期的顺序,Go语言的字面常量是无类型的。只要那么些常量在对应项目标值域范围内,就足以当作该品种的常量。比方,25足以赋值给int、 uint、int32、int64、float32、float64、complex64、complex128等门类的变量。

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)

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.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.1 变量

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

 图片 2

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

本文由美高梅游戏发布于德军总部新巨人,转载请注明出处:这些名字不是关键字

关键词: