这些名字不是关键字

2.4.1 指针概念

指南针是叁个档案的次序,该项指标变量称为指针变量。指针变量存储一个变量的地点。它不相同于平日的变量,日常变量贮存的是数据自个儿,而指针变量存放的是数码之处。

 图片 1

2.变量的赋值

score = 100;
score = a;
score = b = 100;

小说由小编马志国在新浪的原创,若转发请于显明处标志出处:

}

  • 1、 差异数据类型的变量;如:char cHar, int iTimes, flaot faverage;

2、 全局变量大概叫全程变量;

3、 局部变量;

4、 静态变量: 静态全局变量和静态局地变量;关键词:static

5、 寄放器变量;关键词:register;

6、 外部变量: 关键词:extern;

C语言中,变量在内部存款和储蓄器中开垦地的深浅由数据类型决定的,由于PC机中分明多少个地方单元存四个字节,差异的数据类型的变量,为其分配的地址单元数是不平等的。C语言中除两种为主的数据类型外顾客还能和谐定义所急需的数据类型:

1、 bool型 sizeof(bool): 1

2、 char型: sizeof(char): 1

3、 short型: sizeof(short): 2

4、 int型: sizeof(int): 4

5、 long型: sizeof(long): 4

6、 float型: sizeof(float): 4

7、 double型: sizeof(double): 8

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

Go语言将数据类型分为四类:幼功项目、复合类型、援用类型和接口类型。

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

3.变量的出口

int a = 200;
printf("%i", a);
常用格式符:
1> %d%i 整数(int)
2> %f 小数(float、double)
3> %c 字符(char)
*/

规矩:上面看看例子吗!

int main()
{
/*
int score;
// 赋值操作(开始化)
score = 1000;

score = 10000;

char c;

c = 'A';

int a = 20;


//int d,e,f;

int b;

b = a = 40;

b = 30;*/

// 变量:只要有不确定的数据, 就应该定义变量来保存
int score = 205;
// 1:15
int time = 75;

int bestScore = 3161;

// %d%i是一个格式符(占位符),只能输出整数
printf("分数是%dn", score);


float height = 1.78f;


printf("身高是%.2fn", height);  // %f用来输出小数,默认是6位小数


char scoreGrade = 'D';
printf("积分等级是%cn", scoreGrade);


printf("分数是%d,身高是%f,等级是%cn", score, height, 'C');

return 0;

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

 

运算符优先级:

 

 

1.变量的定义

变量类型 变量名;
int score;

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.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.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.3.4 布尔型

三个布尔类型的值独有二种:true和false。布尔值不会隐式调换为数值0或1。布尔值能够和&&、||操作符结合,何况恐怕会有堵塞行为。假设运算符左侧已经足以分明整个布尔表达式的值,那么侧面的表达式将不再求值。

var s string

//s = "mazhiguo"

if s != "" && s[0] == 'm' {

   fmt.Println("OK")

else {

   fmt.Println("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.1 变量

变量是对一块内部存款和储蓄器空间的命名,程序可以因此定义二个变量来申请一块内部存款和储蓄器空间。然后能够经过援用变量名来使用那块存储空间。

 图片 2

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

一个宣称语句将前后相继中的实体和叁个名字关闭,譬如叁个函数或三个变量。申明语句的功能域是指源代码中得以有效运用这些名字的节制。

毫无将功能域和生命周期相提并论。注解语句的功能域对应的是叁个源代码的文书区域,它是叁个编写翻译时的性能。一个变量的生命周期是指程序运转时变量存在的有效性时间段,在这里时间区域内,它能够被前后相继的其他一些引用,是二个周转时的概念。

语法块是由花括号所满含的一五花八门讲话。语法块内部宣称的名字是回天乏术被表面语法块访谈的。语句块决定了内部宣称的名字的功能域范围。有四个语法块为一切源代码,称为全局语法块;然后是种种包的包语法块;每一个for、if和switch语句的语法块;各种switch或select的道岔也会有独立的语法块;当然也会有突显书写的语法块(花括号包涵的话语卡塔尔。

声称语句对应的词法域决定了成效域范围的高低。对于内置的项目、函数和常量,举个例子int、len和true等都以大局功效域的;任何在函数外部阐明的名字能够在包的别样源文件中探望,是包级作用域。对于导入的包,则是对应源文件级的效率域。调节流标号,便是break、continue或goto语句后接着的那种标号,是函数级功效域。

当编写翻译器蒙受叁个名字援引时,若是它是三个宣称,首先从最内层的效率域向全局作用域查找。即使搜索未果,则错误。假使名字在其令月外界分别注明过,则内部块的宣示首先被找到,它会蒙蔽外界同名的证明。

2.2 常量

在Go语言中,常量是指编写翻译时期就已知且不可改正的值。常量的神秘类型都以底工项目,富含整型、浮点型、复数型、布尔类型和字符串类型等。

2.2.1 字面常量

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

25

3.14159

2 3i

true

"hello"

在其它语言中,常量平时常有特定的档案的次序,Go语言的字面常量是无类型的。只要那几个常量在相应项目标值域范围内,就足以当作该类型的常量。譬喻,25方可赋值给int、 uint、int32、int64、float32、float64、complex64、complex128等项指标变量。

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 110001 001001,依次替代模板中的x,获得:1110-0110 10-110001 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.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.4指针

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。总结器或计算机表明10的幂是相疑似用E或e,也便是1.99E3=1986。

f1 := 1.99e 3   //1990

f2 := 1.99e-3   //0.00199

 

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

2.1.1 变量命名

Go语言中的变量名、常量名、类型名、函数名和包名等全体的命名和C语言同样都根据那样多个归纳的命名准绳:多个名字必须以多个字母或下划线从前,前面可以跟大肆数量的字母、数字或下划线。对于字母区分朗朗上口写,例如:name和Name是五个不等的名字。

取名不能与重大字相似,Go语言提供了23个重大字,只可以在特定的语法中利用。

二十二个基本点字

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.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.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

本文由云顶娱乐发布于科学频道,转载请注明出处:这些名字不是关键字