《GO学习笔记》------------------------（2）



2.2 程序结构

         在学习go的基本构建模块之前，让我们来看看一个最低限度的go程序结构，该段就是通过分析最低限度的go程序结构来熟悉go的基本组成。

2.2.1以GoHello World 程序为例

         Go程序基本组成部分如下：

• Package Declaration（包的申明）
• Import Packages（导入包）
• Functions（函数）
• Variables（变量）
• Statements & Expressions（声明&表达式）
• Comments（注释）
  下面通过一段简单的代码来输出"Hello World":

package main

import "fmt"

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

通过上面的简单代码来分析go几个组成部分：

1. 包的申明。这是必须的语句在运行go程序时。包是运行程序的出发点。每个包都有一个与之关联的路径和名称。
2. 导入包。导入预处理命令“FMT”，告诉go编译器执行预处理命令所处的位置。
3. 申明函数。Func main（）是程序开始执行的入口。
4. 注释。/*...*/的内容将被编译器忽略，它已被放入到程序附加注释中。它也可以实用//进行注释。、
5. 调用函数。fmt.Println（...）是转到另一个的函数，这将导致消息"Hello,World!"显示在屏幕上。使用fmt包中的Println函数，把消息显示在电脑屏幕上。
6. Notice：Println函数开头是大写字母。在Go语言，大写字母开头的名称用于出口。出口是指函数或变量/常量能访问导入的相关包。

2.2.2 执行GO程序

怎么保存go的源代码？怎么去编译和运行代码呢？下面有简单的步骤：

1. 打开文本编辑器，输入go代码。
2. 保存go代码名称为hello.go文件。
3. 打开命令行，进入到保存文件的路径。
4. 输入命令“go run hello.go”按回车键，运行你的代码。
5. 如果程序运行成，你将看到程序运行结果打印在屏幕上。

在运行程序前，要确信编译器的环境变量设置正确，那样才能成功过运行目录下go程序。

2.3 基本语法

         了解go程序的基本结构，对于语法的学习将很容易了解go程序的其他组成部分。Go程序包括各种Token和Token可以是一个关键字，一个标识符，常量，字符串文字或符号。例如，下面的GO语句包括六个标记：

       有效：

   

fmt.Println("Hello, World!")

 

         无效：

fmt
.
Println
(
"Hello, World!"
)

2.3.1 行分隔符

         在go程序，行分隔符关键是一个语句结束标记。即，每个单独的语句不需要特殊的分隔符，例如，C语言中的“;”。在GO编译器的内部“;”作为语句终止符，表示一个逻辑实体的结束。

 

 

       例如，下面两个不同的语句：

      

fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")

2.3.2 注释

         注释在在go程序中就想一个帮助文本，帮助你去理解代码语句。注释中的内容会被编译器忽略而不去执行。注释开始标记是：“/*”,结束标记是：“*/”。如下所示：

 

/* my first program in Go */

 

         注释不能嵌套注释，注释不能出现在字符串和字符文字中。如下所示：

         注释嵌套：

/* my 

/*first program*/

 in Go */

       

 

注释在字符串和字符文本中使用：

first p/*rogra*/m

a /*a*/  c

     

 

 

 

2.3.3标识符

         GO标识符是用来标识变量、函数、任何其他用户定义的项目名称。标识符命名通常是以字母、下划线开头，之后跟零或多个字母、下划线、数字。命名公式如下：

  

identifier = letter { letter | unicode_digit }

         Go不允许标识符中包含像@、$、％这样的符号。而且GO是大小写敏感的编程语言。因此Manpower 和 manpower在GO中是两个不同的标识符。下面是一些有效标识符的例子：

      

 

mahesh   kumar   abc   move_name   a_123

myname50   _temp   j   a23b9   retVal

2.3.4 关键字

如下列表是GO的保留字。这些保留字不能被用作常量、变量或任何其他标识符名称：

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

2.3.5 GO程序中的Whitespace

         在注释行中包含一个空行，GO语言编译器会完全忽略它。Whitespace在Go中通常用来描述空格，制表符，换行符和注释术语。Whitespace可以从另一个声明中分隔出一部分，使编译器能够找出在一份声明中的一个元素，如int，结束和下一个元素开始。因此，在下面的语句：

         

var age int;

         在int和age之间至少有一个Whitespace，这样编译器才能够区分它们。如下面的入局：

fruit = apples + oranges;   // get the total fruit

 

 

         在（fruit和 =）或（=和 apples）之间是没必要有Whitespace，如果希望增加可读性，可以自己添加。

2.4数据类型

         在GO编程语言中，数据类型是通过extensivesystem声明变量或不同类型的功能。变量的类型决定了它所占的存储空间和如何进行存储的位模式。

       下边列表描述了GO语言中的数据类型：

类型	描述
Boolean	布尔类型，由两个预定义的常量： true 、false
Numeric	算术类型，它们包括整数类型、浮点数类型
string	字符串类型代表字符串值的集合。它的值是一个字节序列。字符串一旦创建就不能对其进行修改的类型，不能改变字符串的内容。预声明的字符串类型为字符串。
Derived	它们包括：指针类型、数组类型、结构类型、集合类型、函数类型、切片类型、功能类型、接口类型、地图类型、频道类型。

2.4.1整型（Integer Types）

与预定义体系相关的整型列表如下：

类型	描述
uint8	Unsigned 8-bit integers (0 to 255)
uint16	Unsigned 16-bit integers (0 to 65535)
uint32	Unsigned 32-bit integers (0 to 4294967295)
uint64	Unsigned 64-bit integers (0 to 18446744073709551615)
int8	Signed 8-bit integers (-128 to 127)
int16	Signed 16-bit integers (-32768 to 32767)
int32	Signed 32-bit integers (-2147483648 to 2147483647)
int64	Signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

2.4.2 浮点型（Floating Types）

与预定义体系相关的浮点型列表如下：

类型	描述
float32	IEEE-754 32-bit floating-point numbers
float64	IEEE-754 64-bit floating-point numbers
complex64	Complex numbers with float32 real and imaginary parts
complex128	Complex numbers with float64 real and imaginary parts

注释IEEE-754：​​https://en.wikipedia.org/wiki/IEEE_754-2008​​

n位整数的值是n比特，并使用二的补运算表示

2.4.3 其他数字类型

         与程序具体实现指定类型大小的一组数据类型：

  

类型	描述
byte	same as uint8
rune	same as int32
uint	32 or 64 bits
int	same size as uint
uintptr	一个无符号整数来存储指针值的未解释位

2.5 变量

         变量是程序可以操纵一个存储区的名称。Go每个变量都具有特定的类型，它决定了变量存储空间的大小和布局；存储在存储器内值的范围；操作集合可以使用该变量。

       变量的名称可以由字母，数字和下划线组成，但必须以字母或下划线开头。大写和小写字母是不同的，因为GO是区分大小写的。       基于基本数据类，将使用如下基本变量类型进行变量的解释说明：

类型	描述
byte	通常一个八位字节（一个字节）。这是一个字节的类型
int	机器中最自然的整型大小
float32	单精度浮点值

         GO编程语言还可以定义各种其他类型的变量，像枚举，指针，数组，结构，Union等，下载只研究基本变量类型。

 2.5.1 变量定义

         定义一个变量意味着告诉编译器在创建的变量存储在什么位置，还可以创建多少个存储变量。变量定义指定一个数据类型，并包含一个或多个变量类型的列表，如下：

var  variable_list  optional_data_type;

      

      

       variable_list表示变量名称列表；optional_data_type表示数据类型。有效的变量声明如下所示：

    

var    i, j, k int;
var   c, ch byte;
var  f, salary float32;
d = 42;

 

 

        “var    i, j, k int;”申明了三个整数类型的变量i,j, k。在申明变量时可以对变量可以进行初始化（分配一个初始值）。初始化变量的类型是编译器根据传递给它的值自动判断。初始化变的语法如下：

 

ariable_name = value;

      

 

         初始化变量如下：

	d = 3, f = 5; // declaration of d and f. Here d and f are int

 

        

 

         对于没有初始化定义：具有静态存储时间变量是隐式初始化（所有字节的值为0）；所有其它变量的初始值是它们的数据类型的零值。

2.5.2静态类型申明

         静态类型的变量声明为保证编译器有一个与现有的给定类型和名称的变量存在，以便编译器进行进一步的编辑，而不需要了解变量的具体信息。变量声明只有在编译的时候有含义，编译器在程序链接时对实际变量进行声明。

下面的例子，其中的变量已经声明不带有任何类型，并在主函数中定义和初始化。请注意，在类型推断的情况下，初始化变量y用：=操作，对x使用=操作符初始化。创建go源代码文件：Init.go

 

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)  
}

 

        对Init.go文件进行编译和运行，输出结果如下：

        

2.5.3 混合变量声明

                   不同类型的变量可以一起被声明，然后由编译器去推断数据类型。

              如下面go语言代码：Mix_Dec.go文件中的源代码。

          

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
   
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

 

       对Mix_Dec.go文件进行编译和运行，输出结果如下：

             

2.5.4 GO中的左值和右值

         在GO的表达式中有两种，它们分别是：左值和右值：

         左值：表达式参考存储位置被称作左值表达式。左值可能出现在一个表达式的左侧或右侧。

         右值：是存储在存储器地址中的数据值。右值不能有一个值分配给它，这意味着一个右值可能出现表达式右侧而不是左侧。

       变量是左值，因此可能会出现在赋值的左侧。数字文字是右值，因此可能不会被分配，不能出现在左侧。下面是一个有效的语句：    

         x=20

         下面是一个无效的语句，该语句会产生编译错误：

         

       10=20

 2.6常量

         常量指的是程序在其执行期间可能无法改变的固定值。这些固定值也被称为文字。常量可以是任何基本的数据类型，如整型常量，一个浮点常量，字符常量或字符串文本。也有枚举常量等等。常量通常被视为普通变量，只是它们的值定义后不能被修改。

2.6.1 整型常量（Integer literals）

         整数常量可以是十进制，八进制或十六进制常量。指定基或基数的前缀：0x或0X表示十六进制，0表示八进制，十进制。整数常量还可以有一个后缀是U和L的组合，为无符号和长整型。后缀可以是大写或小写，并且可以按任意顺序排列。

       下面有一些整型常量的例子：

   

 

212         /* 合法常量 */
215u        /*合法常量*/
0xFeeL      /*合法常量*/
078         /*不合法常量: 8 不是八进制数 */
032UU       /*不合法常量: 后缀不能重复（UU）*/

       如下是各种类型的常量：

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

    

 

2.6.2浮点型常量（Floating-pointliterals）

         浮点型常量有整数部分、小数点、小数部分、指数部分。浮点型常量可以是在小数形式也可以是指数形式。

       当使用十进制表示，必须包含小数点、指数，或两者兼有；当使用指数形式表示，必须包含整数部分、小数部分，或两者兼有。指数的用e或E表示。

       下面有一些浮点型常量的例子：

 

3.14159       /*合法常量 */
314159E-5L    /*合法常量*/
510E          /*不合法常量:不完整的指数 */
210f          /*不合法常量: 没有小数点或指数*/
.e55          /*不合法常量: 缺少整数或分数*/

2.6.3转义序列(Escape sequence)

         Go的某些字符，当使用用反斜杠将有特殊的含义。它们被用来表示相似的换行符（\ n）或制表符（\ t）。在这里，有一些这样的转义序列列表：

Escape sequence	Meaning
\\	\
\'	'
\"	"
\?	?
\a	警报或钟
\b	删除
\f	换页
\n	换行
\r	回车
\t	水平制表
\v	垂直制表
\ooo	一至三个八进制数
\xhh . . .	一至三个十六进制数

         如下go代码文件：ES_seq.go来演示转义使用：

 

 

package main

import "fmt"

func main() {
   fmt.Printf("Hello one\tWorld!\n");
   fmt.Printf("Hello two\nWorld!\n");
   fmt.Printf("Hello three\aWorld!\n");
   fmt.Printf("Hello four\bWorld!\n");
   fmt.Printf("Hello five\vWorld!\n");
   fmt.Printf("Hello six\rWorld!\n");
   fmt.Printf("Hello seven\rWorld!\n");
   fmt.Printf("Hello eight\\ World!\n");
   fmt.Printf("Hello ten\" World!\n");
   fmt.Printf("Hello twevel\f World!\n"); 
}

 

         编译并运行ES_seq.go文件，输出结果如下：

  

2.6.4 字符串常量

         字符串常量或常量用双引号“”括起来。字符串包含类似于：纯字符，转义序列和通用字符。可以使用字符串常量和whitespaces把很长的一行分为比较短的几行。下面是字符串的一些例子。三种形式的字符串：

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

 

2.6.5const关键字（The const Keyword）

         使用const关键字来申明特定类型的常量，格式如下所示：

  

        

const variable type = value;

         编辑并保存：const.go文件

  

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int

   area = LENGTH * WIDTH
   fmt.Printf("value of area : %d", area)   
}

 

 

 

编译并执行的结果如下：

        

         这不是一个良好编写程序的习惯在函数的首部定义变量。

2.7 运算符（operator）

         运算符是告诉编译器去执行特定数学或逻辑操作的符号。GO语言有丰富的内置运算符，并提供以下类型的运算符：

• Arithmetic Operators（数学运算符）
• Relational Operators（关系运算符）
• Logical Operators（逻辑运算符）
• Bitwise Operators（位运算符）
• Assignment Operators（赋值运算符）
• Misc Operators（其他运算符）

下面将逐一对上面的运算符进行解释。

2.7.1 Arithmetic Operators（数学运算符）

         下表列出所有Go语言支持的算术运算符。假设变量A= 10和变量B持=20则：

Operator	Description	Example
+	加	A + B ==30
-	减	A - B == -10
*	乘	A * B ==200
/	除	B / A == 2
%	取模	B % A ==0
++	递加	A++== 11
--	递减	A-- == 9

编辑go程序：Arith_Oper.go。执行Arith_Oper.go就明白了所有在Go编程语言中可用的算术运算符。编译并执行结果如下：

Arith_Oper.go源代码如下:

package main

import "fmt"

func main() {

   var a int = 21
   var b int = 10
   var c int

   c = a + b
   fmt.Printf("Line 1 - Value of c is %d\n", c )
   c = a - b
   fmt.Printf("Line 2 - Value of c is %d\n", c )
   c = a * b
   fmt.Printf("Line 3 - Value of c is %d\n", c )
   c = a / b
   fmt.Printf("Line 4 - Value of c is %d\n", c )
   c = a % b
   fmt.Printf("Line 5 - Value of c is %d\n", c )
   a++
   fmt.Printf("Line 6 - Value of a is %d\n", a )
   a--
   fmt.Printf("Line 7 - Value of a is %d\n", a )
}

2.7.2 Relational Operators（关系运算符）

         下表列出所有Go语言支持的关系运算符。假设变量A= 10和变量B持=20则：

编辑go程序： Rela_Oper.go。执行Rela_Oper.go就明白了所有在Go编程语言中可用的关系运算符：

package main

import "fmt"

func main() {
   var a int = 21
   var b int = 10

   if( a == b ) {
      fmt.Printf("Line 1 - a is equal to b\n" )
   } else {
      fmt.Printf("Line 1 - a is not equal to b\n" )
   }
   if ( a < b ) {
      fmt.Printf("Line 2 - a is less than b\n" )
   } else {
      fmt.Printf("Line 2 - a is not less than b\n" )
   } 
   
   if ( a > b ) {
      fmt.Printf("Line 3 - a is greater than b\n" )
   } else {
      fmt.Printf("Line 3 - a is not greater than b\n" )
   }
   /* Lets change value of a and b */
   a = 5
   b = 20
   if ( a <= b ) {
      fmt.Printf("Line 4 - a is either less than or equal to  b\n" )
   }
   if ( b >= a ) {
      fmt.Printf("Line 5 - b is either greater than  or equal to b\n" )
   }
}

 

编译并执行结果如下：

2.7.3 Logical Operators（逻辑运算符）

         下表列出所有Go语言支持的逻辑运算符。假设变量A= 1和变量B持=0则：

Operator	Description	Example
&&	与操作（一假全假，全真才真）	(A && B) is false.
||	或操作（一真全真，全假才假）	(A || B) is true.
!	非（真为假，假为真）	!(A && B) is true.

编辑go程序： Logic_Oper.go。执行Logic_Oper.go就明白了所有在Go编程语言中可用的逻辑运算符：

package main
import "fmt"
func main() {
   var a bool = true
   var b bool = false
   if ( a && b ) {
      fmt.Printf("Line 1 - Condition is true\n" )
   }
   if ( a || b ) {
      fmt.Printf("Line 2 - Condition is true\n" )
   }
   a = false
   b = true
   if ( a && b ) {
      fmt.Printf("Line 3 - Condition is true\n" )
   } else {
      fmt.Printf("Line 3 - Condition is not true\n" )
   }
   if ( !(a && b) ) {
      fmt.Printf("Line 4 - Condition is true\n" )
   }
}

 

编译并执行结果如下：

2.7.4 Bitwise Operators（位运算符）

位运算符适用于位和进行逐位操作。位操作符：&（与），|（或），^（亦或），~（非）如下表：

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

        

假设A=60，B=13现在把A和B转换成二进制，如下：

 

 

 

C语言支持位运算符列于下表。假设变量A=60和变量B=13，则：

Operator	Description	Example
&	位与操作（一零全零，全一才一）	(A & B) will give 12, which is 0000 1100
|	位或操作（一一全一，全零才零）	(A | B) will give 61, which is 0011 1101
^	亦或操作同结果为零，不同结果唯一）	(A ^ B) will give 49, which is 0011 0001
<<	左移操作	A << 2 will give 240 which is 1111 0000
>>	右移操作	A >> 2 will give 15 which is 0000 1111

编辑go程序： Bit_Oper.go。执行Bit_Oper.go就明白了所有在Go编程语言中可用的位操作运算符：

package main
    import "fmt"
    func main() {
   var a uint = 60   /* 60 = 0011 1100 */  
   var b uint = 13   /* 13 = 0000 1101 */
   var c uint = 0          
   c = a & b       /* 12 = 0000 1100 */ 
   fmt.Printf("Line 1 - Value of c is %d\n", c )
   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("Line 2 - Value of c is %d\n", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("Line 3 - Value of c is %d\n", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("Line 4 - Value of c is %d\n", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("Line 5 - Value of c is %d\n", c )
}

 

编译并执行结果如下：

2.7.5 Assignment Operators（赋值运算符）

         go语言支持以下赋值运算符:

Operator	Description	Example
=	把赋值操作右侧的操作数赋值给左侧	C = A + B will assign value of A + B into C
+=	赋值操作右侧的操作数加上左侧的操作数结果赋值给左侧操作数	C += A is equivalent to C = C + A
-=	赋值操作左侧的操作数减去右侧的操作数结果赋值给左侧操作数	C -= A is equivalent to C = C - A
*=	赋值操作左侧的操作数乘上右侧的操作数结果赋值给左侧操作数	C *= A is equivalent to C = C * A
/=	赋值操作左侧的操作数除以右侧的操作数结果赋值给左侧操作数	C /= A is equivalent to C = C / A
%=	赋值操作左侧的操作数取模右侧的操作数结果赋值给左侧操作数	C %= A is equivalent to C = C % A
<<=	赋值操作左侧的操作数左移右侧的操作数结果赋值给左侧操作数	C <<= 2 is same as C = C << 2
>>=	赋值操作左侧的操作数右移右侧的操作数结果赋值给左侧操作数	C >>= 2 is same as C = C >> 2
&=	赋值操作左侧的操作数 与 右侧的操作数结果赋值给左侧操作数	C &= 2 is same as C = C & 2
^=	赋值操作左侧的操作数 亦或 右侧的操作数结果赋值给左侧操作数	C ^= 2 is same as C = C ^ 2
|=	赋值操作左侧的操作数 或 右侧的操作数结果赋值给左侧操作数	C |= 2 is same as C = C | 2

编辑go程序： Ass_Oper.go。执行Ass_Oper.go就明白了所有在Go编程语言中可用的赋值操作运算符：

package main

    import "fmt"

   func main() {
   var a int = 21
   var c int
   c =  a
   fmt.Printf("Line 1 - =  Operator Example, Value of c = %d\n", c )
   c +=  a
   fmt.Printf("Line 2 - += Operator Example, Value of c = %d\n", c )
   c -=  a
   fmt.Printf("Line 3 - -= Operator Example, Value of c = %d\n", c )
   c *=  a
   fmt.Printf("Line 4 - *= Operator Example, Value of c = %d\n", c )
   c /=  a
   fmt.Printf("Line 5 - /= Operator Example, Value of c = %d\n", c )
   c  = 200; 
   c <<=  2
   fmt.Printf("Line 6 - <<= Operator Example, Value of c = %d\n", c )
   c >>=  2
   fmt.Printf("Line 7 - >>= Operator Example, Value of c = %d\n", c )
   c &=  2
   fmt.Printf("Line 8 - &= Operator Example, Value of c = %d\n", c )
   c ^=  2
   fmt.Printf("Line 9 - ^= Operator Example, Value of c = %d\n", c )
   c |=  2
   fmt.Printf("Line 10 - |= Operator Example, Value of c = %d\n", c )

}

 

编译并执行结果如下：

        

2.7.6 Misc Operators（其他运算符）

go语言的支持包括sizeof和其他一些重要的运算符？ ：。

Operator	Description	Example
&	返回变量的地址	&a;
*	指针变量	*a;

编辑go程序： Misc_Oper.go。执行Misc_Oper.go就明白了所有在Go编程语言中可用的其他操作运算符：

 

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* example of type operator */
   fmt.Printf("Line 1 - Type of variable a = %T\n", a );
   fmt.Printf("Line 2 - Type of variable b = %T\n", b );
   fmt.Printf("Line 3 - Type of variable c= %T\n", c );

   /* example of & and * operators */
   ptr = &a /* 'ptr' now contains the address of 'a'*/
   fmt.Printf("value of a is  %d\n", a);
   fmt.Printf("*ptr is %d.\n", *ptr);
}

编译并执行结果如下：

2.7.6 运算符的优先级

运算符优先级决定表达式中元素的分组。这会影响一个表达式是如何计算。某些运算符比其它运算符优先级高。例如，乘法运算符具有比加法运算符优先级高。例如X =7 + 3* 2;这里，x=13，而不是20因为运算符*优先级高于+，所以它首先执行3* 2，然后添加到7。如下表运算的优先级级别从上到下依次减小：

类别	运算符	运算顺序
Postfix	() [] -> . ++ - -	Left to right
Unary	+ - ! ~ ++ - - (type)* & sizeof	Right to left
Multiplicative	* / %	Left to right
Additive	+ -	Left to right
Shift	<< >>	Left to right
Relational	< <= > >=	Left to right
Equality	== !=	Left to right
Bitwise AND	&	Left to right
Bitwise XOR	^	Left to right
Bitwise OR	|	Left to right
Logical AND	&&	Left to right
Logical OR	||	Left to right
Conditional	?:	Right to left
Assignment	= += -= *= /= %=>>= <<= &= ^= |=	Right to left
Comma	,	Left to right

         编辑go程序： Prece_Oper.go。执行Prece_Oper.go就明白了所有在Go编程语言中操作运算符优先级次序：

 

package main

import "fmt"

func main() {
   var a int = 20
   var b int = 10
   var c int = 15
   var d int = 5
   var e int;

   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   fmt.Printf("Value of (a + b) * c / d is : %d\n",  e );

   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   fmt.Printf("Value of ((a + b) * c) / d is  : %d\n" ,  e );

   e = (a + b) * (c / d);   // (30) * (15/5)
   fmt.Printf("Value of (a + b) * (c / d) is  : %d\n",  e );

   e = a + (b * c) / d;     //  20 + (150/5)
   fmt.Printf("Value of a + (b * c) / d is  : %d\n" ,  e );  
}

 

编译并执行结果如下：