golang基础结构

1.命名

Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等全部的命名,都遵循一个简单的命名规则：一个名字必须以一个字母（Unicode字母）或下划线开头,后面能够跟任意数量的字母、数字或下划线.大写字母和小写字母是不一样的：heapSort和Heapsort是两个不一样的名字.

Go语言的关键字有25个,关键字不能用于自定义名字. 分别为:

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

还有大约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

在习惯上，Go语言程序员推荐使用 驼峰式 命名，当名字有几个单词组成的时优先使用大小写分隔，而不是优先用下划线分隔。

2.声明

Go语言主要有四种类型的声明语句：var、const、type和func，分别对应变量、常量、类型和函数实体对象的声明。

一个Go语言编写的程序对应一个或多个以.go为文件后缀名的源文件中。每一个源文件以包的声明语句开始，说明该源文件是属于哪一个包。包声明语句以后是import语句导入依赖的其它包，而后是包一级的类型、变量、常量、函数的声明语句.

package main // main包

import "fmt" // 引入fmt内部包

const price = 212.0 // 浮点型常量

func main() {
	var f = price                        // f浮点型变量
	var c = (f - 32) * 5 / 9             // c浮点型变量
	fmt.Printf("f = %g  c = %g\n", f, c) // %g为浮点型占位符
	fmt.Printf("f:%T,c:%T", f, c)        // %T为打印类型  结果:f:float64,c:float64
}

3.变量

var声明语句能够建立一个特定类型的变量，而后给变量附加一个名字，而且设置变量的初始值。变量声明的通常语法以下：

var 变量名字 类型 = 表达式

// 例如
var name string = "zhy"

其中“类型”或“= 表达式”两个部分能够省略其中的一个。若是省略的是类型信息，那么将根据初始化表达式来推导变量的类型信息。若是初始化表达式被省略，那么将用零值初始化该变量。 数值类型变量对应的零值是0，布尔类型变量对应的零值是false，字符串类型对应的零值是空字符串，接口或引用类型（包括slice、指针、map、chan和函数）变量对应的零值是nil。数组或结构体等聚合类型对应的零值是每一个元素或字段都是对应该类型的零值。

var s string
fmt.Println(s) // ""

也能够在一个声明语句中同时声明一组变量，或用一组初始化表达式声明并初始化一组变量。若是省略每一个变量的类型，将能够声明多个类型不一样的变量（类型由初始化表达式推导）：

var i, j, k int                 // int, int, int
var b, f, s = true, 2.3, "four" // bool, float64, string

一组变量也能够经过调用一个函数，由函数返回的多个返回值初始化：

var f, err = os.Open("./project.log")  // 打开文件 f为句柄 err为错误

3.1.简短变量声明

在函数内部，有一种称为简短变量声明语句的形式可用于声明和初始化局部变量。它以“名字 := 表达式”形式声明变量，变量的类型根据表达式来自动推导。

name := "zhy"
f,err := os.Open("./project.log")

3.2.指针

一个变量对应一个保存了变量对应类型值的内存空间。一个指针的值是另外一个变量的地址。一个指针对应变量在内存中的存储位置。并非每个值都会有一个内存地址，可是对于每个变量必然有对应的内存地址。经过指针，咱们能够直接读或更新对应变量的值，而不须要知道该变量的名字（若是变量有名字的话）。指针的定义为*+类型好比*int等,或者把变量的地址赋值给指针,编辑器会自动推到指针的类型

var number *int
var a = 100
var b = &a // &为取值符

用*+指针变量出去所指变量的值

fmt.Println(*p)  // 0
fmt.Println(*b)  // 100

3.3.New初始化

另外一个建立变量的方法是调用用内建的new函数。表达式new(T)将建立一个T类型的匿名变量，初始化为T类型的零值，而后返回变量地址，返回的指针类型为*T。

p := new(int)   // p, *int 类型, 指向匿名的 int 变量
fmt.Println(*p) // "0"
*p = 2          // 设置 int 匿名变量的值为 2
fmt.Println(*p) // "2"

3.4. 变量的生命周期

变量的生命周期指的是在程序运行期间变量有效存在的时间间隔。对于在包一级声明的变量来讲，它们的生命周期和整个程序的运行周期是一致的。而相比之下，局部变量的声明周期则是动态的：每次从建立一个新变量的声明语句开始，直到该变量再也不被引用为止，而后变量的存储空间可能被回收。函数的参数变量和返回值变量都是局部变量。它们在函数每次被调用的时候建立。

4.赋值

• 直接赋值 x = 100
• 经过指针赋值 *p = "zhy"
• 结构体赋值 stu.name = "zhy"
• 数组切片赋值 lst[1] = lst[1] + 1
• 二元运算符 x *= 6 等同于 x = x * 6
• 自加自减 x++ x--
• 交换赋值 x,y = y,x
• 函数赋值 f, err = os.Open("project.log")

5. 类型

一个类型声明语句建立了一个新的类型名称，和现有类型具备相同的底层结构。新命名的类型提供了一个方法，用来分隔不一样概念的类型，这样即便它们底层类型相同也是不兼容的。

type 类型名字 底层类型

6.包

Go语言中的包和其余语言的库或模块的概念相似，目的都是为了支持模块化、封装、单独编译和代码重用。一个包的源代码保存在一个或多个以.go为文件后缀名的源文件中，一般一个包所在目录路径的后缀是包的导入路径；

7.做用域

一个声明语句将程序中的实体和一个名字关联，好比一个函数或一个变量。声明语句的做用域是指源代码中能够有效使用这个名字的范围。

func f() {}

var g = "g"

func main() {
    f := "f"
    fmt.Println(f) // main函数的做用域
    fmt.Println(g) // g包做用域
    fmt.Println(h) // pinic报错 没有找到
}

用:=声明变量,只能在函数内使用,在全局使用会报错