Go 语言结构

一.Go 语言的基础组成有如下几个部分：

1.包声明 2.引入包 3.函数 4.变量 5.语句 & 表达式 6.注释

// 当前程序的包名
package main

// 导入其余包
import . "fmt"

// 常量定义
const PI = 3.14

// 全局变量的声明和赋值
var name = "gopher"

// 通常类型声明
type newType int

// 结构的声明
type gopher struct{}

// 接口的声明
type golang interface{}

// 由main函数做为程序入口点启动
func main() {
    Println("Hello World!")
}

//前面加个点表示省略调用，那么调用该模块里面的函数，能够不用写模块名称了:
import . "fmt"
func main (){
    Println("hello,world")
}

经过 const 关键字来进行常量的定义。
经过在函数体外部使用 var 关键字来进行全局变量的声明和赋值。
经过 type 关键字来进行结构(struct)和接口(interface)的声明。
经过 func 关键字来进行函数的声明。
Go 语言中变量的声明必须使用空格隔开
如：var age int;

2.可见性规则：

Go语言中，使用大小写来决定该常量、变量、类型、接口、结构或函数是否能够被外部包所调用。
函数名首字母小写即为 private :
func getId() {}

函数名首字母大写即为 public :
func Printf() {}

3.Print、Println、Printf三者的区别：

func main() {
    fmt.Print("a", "b", 1, 2, 3, "c", "d", "\n")
    fmt.Println("a", "b", 1, 2, 3, "c", "d")
    fmt.Printf("ab %d %d %d cd\n", 1, 2, 3)
    // ab1 2 3cd
    // a b 1 2 3 c d
    // ab 1 2 3 cd

    if err := percent(30, 70, 90, 160); err != nil {
        fmt.Println(err)
    }
    // 30%
    // 70%
    // 90%
    // 数值 160 超出范围（100）
}

3.1 Println深度理解：

package main  
  
import (  
    "fmt"  
    "strings"  
)  
  
func main() {  
    str := "这里是 www\n.runoob\n.com"  
    fmt.Println("-------- 原字符串 ----------")  
    fmt.Println(str)  
    // 去除空格  
    str = strings.Replace(str, " ", "", -1)  
    // 去除换行符  
    str = strings.Replace(str, "\n", "", -1)  
    fmt.Println("-------- 去除空格与换行后 ----------")  
    fmt.Println(str)  
}
输出结果为：

-------- 原字符串 ----------
这里是 www
.runoob
.com
-------- 去除空格与换行后 ----------
这里是www.runoob.com

4.Go 标记

Go 程序能够由多个标记组成，能够是关键字，标识符，常量，字符串，符号。

5.Go 语言数据类型

1.布尔型:布尔型的值只能够是常量 true 或者 false。
2.数字类型:整型 int8~6四、uint8~6四、 和 uintptr。和浮点型 float32~64，complex64~128，Go语言还支持其余数字类型
byte相似 uint8 rune相似 int32 uint32 或 64 位 int与 uint 同样大小 uintptr 无符号整型，用于存放一个指针。
3.字符串类型:字符串就是一串固定长度的字符链接起来的字符序列。Go的字符串是由单个字节链接起来的。
Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
4.派生类型:
(a) 指针类型（Pointer）(b) 数组类型(c) 结构化类型(struct)
(d) Channel 类型(e) 函数类型(f) 切片类型(g) 接口类型（interface）(h) Map 类型

6.Go 语言变量

变量声明
第一种，指定变量类型，声明后若不赋值，使用默认值。

var v_name v_type
v_name = value

第二种，根据值自行断定变量类型。

var v_name = value

第三种，省略var, 注意 :=左侧的变量不该该是已经声明过的，不然会致使编译错误。

v_name := value

// 例如
var a int = 10
var b = 10
c := 10

多变量声明

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)
}
//输出为：0 0 0 false 1 2 123 hello 123 hello

7.GO语言常量

多个相同类型的声明能够简写为：

const c_name1, c_name2 = value1, value2

常量还能够用做枚举：

const (
    Unknown = 0
    Female = 1
    Male = 2
)

iota，特殊常量，能够认为是一个能够被编译器修改的常量。
在每个const关键字出现时，被重置为0，而后再下一个const出现以前，每出现一次iota，其所表明的数字会自动增长1。
iota 能够被用做枚举值：

func main() {
                  const (
        aa = iota
        bb = iota
        cc = iota
    )
    fmt.Println("aa=,bb=,cc=", aa, bb, cc)
    //0 1 2
    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)
    //0 1 2 ha ha 100 100 7 8
    const (
        j = 1 << iota
        k = 3 << iota
        l
        m
    )

    fmt.Println("j=", j)
    fmt.Println("k=", k)
    fmt.Println("l=", l)
    fmt.Println("m=", m)
    /*iota 表示从 0 开始自动加 1，因此 i=1<<0, j=3<<1（<< 表示左移的意思），
    即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。
    简单表述:
    i=1：左移 0 位,不变仍为 1;
    j=3：左移 1 位,变为二进制 110, 即 6;
    k=3：左移 2 位,变为二进制 1100, 即 12;
    l=3：左移 3 位,变为二进制 11000,即 24。*/
        }