1.可见性规则：

当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，表示此标识符的对象可以被其他包调用，类似public标识
标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的，类似privite

2.使用包别名

可以通过使用包的别名来解决包名之间的名称冲突，或者说根据你的个人喜好对包名进行重新设置，如：import fm “fmt”。

  1. package main
  3. import fm "fmt" // alias3
  5. func main() {
  6.    fm.Println("hello, world")
  7. }

3.函数

程序正常退出的代码为 0 即 Program exited with code 0；如果程序因为异常而被终止，则会返回非零值，如：1。这个数值可以用来测试是否成功执行一个程序。

4.注释

多行注释一般用于包的文档描述或注释成块的代码片段。
每一个包应该有相关注释，在 package 语句之前的块注释将被默认认为是这个包的文档说明，其中应该提供一些相关信息并对整体功能做简要的介绍。
在首行的简要注释之后可以用成段的注释来进行更详细的说明，而不必拥挤在一起。另外，在多段注释之间应以空行分隔加以区分。

  1. // Package superman implements methods for saving the world.
  2. //
  3. // Experience has shown that a small number of procedures can prove
  4. // helpful when attempting to save the world.
  5. package superman

几乎所有全局作用域的类型、常量、变量、函数和被导出的对象都应该有一个合理的注释。如果这种注释（称为文档注释）出现在函数前面，例如函数 Abcd，则要以 “Abcd…” 作为开头。

  1. // enterOrbit causes Superman to fly into low Earth orbit, a position
  2. // that presents several possibilities for planet salvation.
  3. func enterOrbit() error {
  4.    ...
  5. }

5.类型

使用 var 声明的变量的值会自动初始化为该类型的零值。类型定义了某个变量的值的集合与可对其进行操作的集合。
类型可以是基本类型，如：int、float、bool、string；结构化的（复合的），如：struct、array、slice、map、channel；只描述类型的行为的，如：interface。
结构化的类型没有真正的值，它使用 nil 作为默认值（在 Objective-C 中是 nil，在 Java 中是 null，在 C 和 C++ 中是NULL或 0）。值得注意的是，Go 语言中不存在类型继承。
函数也可以是一个确定的类型，就是以函数作为返回类型。这种类型的声明要写在函数名和可选的参数列表之后
func FunctionName (a typea, b typeb) typeFunc
可以在函数体中的某处返回使用类型为 typeFunc 的变量 var
return var
一个函数可以拥有多返回值，返回类型之间需要使用逗号分割，并使用小括号 () 将它们括起来，如：
func FunctionName (a typea, b typeb) (t1 type1, t2 type2)

  1. 示例： 函数 Atoi (第 4.7 节)：func Atoi(s string) (i int, err error)
  3. //返回的形式：
  5. return var1, var2

使用 type 关键字可以定义你自己的类型
type IZ int
然后我们可以使用下面的方式声明变量：
var a IZ = 5
这里并不是真正意义上的别名，因为使用这种方法定义之后的类型可以拥有更多的特性，且在类型转换时必须显式转换。

6.Go 程序的一般结构

  • 在完成包的 import 之后，开始对常量、变量和类型的定义或声明。
  • 如果存在 init 函数的话，则对该函数进行定义（这是一个特殊的函数，每个含有该函数的包都会首先执行这个函数）。
  • 如果当前包是 main 包，则定义 main 函数。
  • 然后定义其余的函数，首先是类型的方法，接着是按照 main 函数中先后调用的顺序来定义相关函数，如果有很多函数，则可以按照字母顺序来进行排序。 ```go package main

import ( “fmt” )

const c = “C”

var v int = 5

type T struct{}

func init() { // initialization of package }

func main() { var a int Func1() // … fmt.Println(a) }

func (t T) Method1() { //… }

func Func1() { // exported function Func1 //… }

  1. <a name="cKm12"></a>
  2. #### 7.执行顺序
  4. 1. 按顺序导入所有被 main 包引用的其它包，然后在每个包中执行如下流程：
  5. 1. 如果该包又导入了其它的包，则从第一步开始递归执行，但是每个包只会被导入一次。
  6. 1. 然后以相反的顺序在每个包中初始化常量和变量，如果该包含有 init 函数的话，则调用该函数。
  7. 1. 在完成这一切之后，main 也执行同样的过程，最后调用 main 函数开始执行程序。
  9. <a name="mkeE0"></a>
  10. #### 8.类型转换
  11. Go 语言不存在隐式类型转换，因此所有的转换都必须显式说明<br />类型 B 的值 = 类型 B(类型 A 的值)
  12. ```go
  13. a := 5.0
  14. b := int(a)

从一个取值范围较大的类型转换到一个范围较小的类型，会发生精度丢失的情况
非法类型转换会引起编译时错误

9.命名规范

返回某个对象的函数或方法的名称一般都是使用名词，没有 Get… 之类的字符，如果是用于修改某个对象，则使用 SetName。有必须要的话可以使用大小写混合的方式，如 MixedCaps 或 mixedCaps，而不是使用下划线来分割多个名称。