Go语言基础一

一、基本数据类型和操作符

（1）文件名&关键字&标识符

• 1.1、文件名

  go程序的文件名后缀为 .go

• 1.2、标识符

  标识符即表示成变量/函数名/类名等的字符串，以字母或下划线开头，大小写敏感（和python类似）， _ 是特殊标识符，用来忽略结果

• 1.3、保留关键字

  go语言保留了25个系统关键字:

（2）Go程序基本结构

go程序大体上由 “package包” “import引用包” “main函数主题” 组成：

注意事项

（3）Go程序包的概念

• 3.1、在包内引用另一个包

  通过import关键字来引用包，go默认从 GOROOT 和 GOPATH 环境变量所在的路径下的src目录开始寻找import导入的包，因此建议你的包路径要从 $GOPATH /src 的后面开始写。

  如果是系统提供的包，不需要输入路径，安装GO语言环境时，已经默认在 $GOROOT /src 目录下

• 3.2、如何引用另一个包内的变量/函数/方法

  按照3.1的介绍，使用 import <包路径> 来导入包，注意包的路径，使用 <包名>/<包别名>.[函数]/[方法] 的形式来引用另一个包的变量或者方法

• 3.3、包的“自执行函数”

  如果在包内声明一个名称为 init 的函数，那么其他包在调用它时，会自动执行init函数（类似python类里面的 _init_ 方法）,具体写法为：

  func init(){
  
  ...<函数体>
  
  }

  main包引用其他包时，执行的顺序为：其他包的全局变量—>其他包的init函数—>main包内的main函数，当包的引用有嵌套时（引用的包又引用其他的包），优先执行嵌套最里面的包

• 3.4、包的别名

  在引用其他包时，在包的前面可以添加别名，使用别名来代替引用的包名，而特殊的别名： “_” 表示不调用引用包内的任何方法，只执行引用包的init自执行函数

  package main
  
  import (
  my_add "lessions/day2/pro2/add" //引用add包，并定义了包的别名为 my_add
  _  "lessions/day1/pro1/calc"  //引用calc包，但不调用包内的任何变量/方法，只是自动执行包内的init函数
  )
  
  func main() {
  mt.Printf(my_add.Name)       //add包大写变量可以调用
  //fmt.Printf(my_add.age)    //add包小写变量无法调用
  }

• 3.5、包的概念代码范例

  /*add包内的代码*/
  package add
  
  var Name string = "Chen" //声明变量初始化
  var age int = 19         //声明变量初始化
  
  func init() {            //自执行函数
  Name = "Lin"
  age = 16
  }
  
  
  /*main主程序包内的代码*/
  //go调用其它包的包变量/函数/方法时，其他包需要将变量/函数/方法设置为大写才能被调用
  package main
  
  import (
    "fmt"
    //    "lessions/day2/pro2/add"
    _ "lessions/day1/pro1/calc"     //引用calcs包，但不调用包内的任何变量/方法，只是自动执行包内的init函数
    my_add "lessions/day2/pro2/add" //引用add包，并定义了包的别名为 my_add
  )
  
  func main() {
    fmt.Printf(my_add.Name) //add包大写变量可以调用
    //    fmt.Printf(my_add.age)    add包小写变量无法调用
  }

  执行结果

  Lin

（4）函数

• 4.1、函数的声明

  ==func <函数名> (参数列表) (返回值列表) { …<函数体> }==

  范例：

  func add() {...}  //简单的函数，无参数
  func add(a int,b String) {...}  //带2个形参的函数，无返回值
  func add(a int,b String) int {...}  //带2个形参的函数，有1个返回值，类型为int
  func add(a int,b String) (int，int) {...}  //带2个形参的函数，有2个返回值，类型为int

（5）常量和变量

• 5.1、常量介绍

  常量在初始化值后，无法再次改变（参考C语言里面的常量），常量能赋予的值只有boolean，number（int相关类型、浮点类型、complex）和string这些类型。

• 5.2、常量的定义

  使用关键字 ==const== 来定义一个常量：

  ==const <标识符> [type] = value==

  范例：

  const my_c string = "MY Classical Music"

  比较专业的常量定义写法：

  const (
  
    a = 1       //定义一个常量
    b= "ppap"   //定义一个常量
    c=10        //定义一个常量
  )

  定义常量可以不需要声明类型

• 5.2、变量的定义

  格式： ==var <变量名> [type]==

• 5.3、变量的赋值

  • 方法一： 在定义变量时，初始化变量：

  var number_a int = 19
  
  
  #更专业的初始化方法：
  
  
  var (
  
  a int
  b int
  c string
  d bool
  e = 67
  f ="app"
  
  )
  

  • 方法二： 定义变量后，赋值：

  var number_a int
  number_a  = 19

  • 方法三： 使用 :=符号，自动推导变量类型：

  number_a := 19

  方法三相当于方法二，但是与方法一有本质区别，方法一称为初始化。GO语言有个“不浪费”规定：当变量不使用时，变量不能赋值（赋值会占用内存空间）。但是方法一是初始化，可以在变量不使用时执行不报错

• 5.4、变量的值类型和引用类型

  程序在内存中开辟一个位置，然后将变量的值存入。存入的位置就是内存地址

  • #### 5.4.1、值类型

  变量直接存储值，内存通常在栈中分配。

  基本数据类型 int、float、bool、string 以及 数组 和 struct 都属于值类型

  • #### 5.4.2、引用类型

  变量存储的是一个内存地址，这个地址存指向存储的变量值。内存通常在堆上分配。通过GC回收。

  指针、slice、map、chan 等都是引用类型

  • #### 5.4.3、值类型和引用类型在函数内的差别

  值类型在作为函数的形式参数时，直接拷贝到函数里面称为函数内的局部变量，而引用类型（内存地址）是将内存地址真正的传入了函数，对内存地址指向的变量值的修改就是对外部传入的引用类型变量的值的修改，可以
  理解为当引用类型传入函数时，其实就变成了“全局变量”（注意是内存地址指向的值变成全局变量，内存地址本身不是）

  值类型传入函数，函数在新开辟内存空间来存放变量值，而引用类型只是复制一下内存地址

• 5.5、变量的作用域

  • 函数外部声明的变量为全局变量，在整个包内都有效，如果变量是（首字符）大写的，则在整个程序内都有效
  • 函数体内的变量为局部变量，只在函数内有效
  • 函数内的语句块变量（如for循环内部的变量）只作用于语句块内

（6）数据类型和操作符

• 6.1、数据类型

  • #### 6.1.1、数字数据类型

  数字类型，主要有int、int8、int16、int32、int64、uint8、uint16、uint32、uint64、loat32、float64

  注意：int8与int16是不同的数据类型:var a int8 、var b int32 = 19 。a和b是不同的数据类型 a=b 是错误的，因为数据类型不同

  • #### 6.1.1、数字数据类型之间的转换

  转换格式（参考python的数据类型转换）： <数据类型>(需要转换的变量)

  范例：

  var a int 
  var b uint 32 = 100
  
  a = int(b)

• 6.2、操作符

  • #### 6.2.1、布尔类型的操作符

  布尔类型的操作符有： * ！、&&、|| *

  • #### 6.2.2、整数类型的操作符

  逻辑操作符： == 、!=、<、<=、>和 >=

  数学操作符：+、-、*、/等等

（7）字符串类型

go有字符类型，定义字符：var a byte = ‘c’ ，注意值用 ” 号

字符串类型的定义： var str string

• 7.1、字符串拼接

  方法一： 可以使用“万恶的‘+’号”来拼接：

  var a string = "hello"
  var b string = "jacie"
  
  c := a + " " + b

  方法二： 利用fmt包的Sprintf格式化输出来拼接：

  var a string = "hello"
  var b string = "jacie"
  
  c:=fmt.Sprintf("%s %s",a,b)

• 7.2、字符串的切片儿

  参考python的切片，十分相似。以 [<开始元素下标>:<结束元素下标>] 来取出部分的元素 ，但是go里的下标不能为负数

  var a string = "hello 123 990"
  
  a[6:9] //取出第7到第10个元素（下标从0开始算）

  执行结果为 123