Go语言培训第二天

第二天课程

[toc]

基本数据类型和操作符

• 文件名
  • 所有的go源码文件以.go结尾
• 标识符以字母或下划线结尾
  • _是特殊标识符，用来忽略结果
• 保留关键字如下：
  

• go程序基本结构

  package main
  import(         //导入本地包或者第三方包
  "fmt"
  )
  func main(){    //声明函数必须以func开头，用花括号包含
  fmt.Println("hello world!!")
  }

  详细分析如下：

  1. 任何代码文件隶属于一个包
  2. import 关键字，用来引用其他包
  3. golang可执行程序，package main只有一个main入口函数
  4. 包中的调用：
  5. 在同一个包中的函数直接调用
  6. 不同包中的函数，通过包名+点+函数名进行调用
  7. 包的访问控制规则：
  8. 大写意味着这个变量/函数是可以导出的
  9. 小写意味着这个变量/函数是私有的，在包外不能访问

• 小练习一:
  给定一个数字n,求出所有两两相加等于n的组合
  

  package main
  import "fmt"
  func Sums(n int) {
  for i :=0;i <= n;i++{
      fmt.Printf("%d+%d=%d\n",i,n-i,n)
  }
  }
  func main(){
  Sums(5)
  }

• 小练习二：
  一个程序包含两个包add和main，其中add包里面有两个变量Name和Age，怎么让main去访问
  目录结构如下：

  ─ask_variables
  │  ├─add
  │  └─main

  1. add/add.go

     package add
     var Name string = "Wanghui"
     var Age int = 23

  2. main/main.go

     package main
     import (
     "one/day2/ask_variables/add"
     "fmt"
     )
     func main() {
     var a string = add.Name
     var b int = add.Age
     fmt.Printf("Name %s,Age %d",a,b)
     }

• 包的别名应用
  只需将上述的例子中的main.go修改成如下即可：

  package main
  import (
  add_func "one/day2/ask_variables/add"
  "fmt"
  )
  func main() {
  var a string = add_func.Name
  var b int = add_func.Age
  fmt.Printf("Name %s,Age %d",a,b)
  }

• 每个源文件都包含一个init函数，这个init函数自动被go运行框架调用，演示如下的功能，目录结构如下：

  ├─add
  ├─main
  └─test

  代码如下：

  1. add/add.go

     package add
     import(
     "fmt"
     _ "one/day2/init_test/test"
     )
     var Name string
     var Age int
     func init() {
     Name = "init test"
     Age = 19
     fmt.Println("This is in the init_test dir")
     }

  2. main/main.go

     package main
     import (
     "fmt"
     a "one/day2/init_test/add"
     )
     func main() {
     fmt.Println("this is in the main func!!")
     fmt.Println("Name=",a.Name)
     fmt.Println("Age=",a.Age)
     }

  3. test/test.go

     package test
     import "fmt"
     var Name string = "TEST PACKAGE"
     var Age int = 1000
     func init(){
     fmt.Println("this is in the test!!")
     fmt.Println("test.package.Name=",Name)
     fmt.Println("test.package.Age=",Age)
     }

     包的初始化操作，直接在引用的时候加上_就好。

     函数的声明和注释

     func 函数名（参数列表）（返回值列表）{
     函数体
     }

• 注释：

  // 单行注释
  /*多行注释*/

  常量

• 只读的，用const修饰的
• 只能修饰bool，数字和string类型
• 语法

  const a string = "hello"
  const (
  b = 1
  c = 2
  d = 3 
  )
  或者
  const(
  b1 = iota
  b2
  b3
  )

• 小例子：

  定义两个常量，Man=1，Female=2，获取当前系统的时间秒数，如果能被Femal整除，则在终端上打印female，否则打印man

1. 代码

   package main
   import (
   "time"
   "fmt"
   )
   const(
   Man = 1
   Female = 2
   )
   func main(){
   for {
       second := time.Now().Unix()
       if (second % Female) == 0 {
           fmt.Println("F" +
               "Female")
       }else {
           fmt.Println("Man")
       }
       time.Sleep(1)
   }   
   }

   变量

   • 语法: var 变量名 数据类型

     var(
     a int      //默认为0
     b string   //默认为空
     d = 8      //定义为8
     )

   • 小例子：获取当前操作系统的主机名和PATH环境变量：

     package main
     import (
     "os"
     "fmt"
     )
     func main(){
     hostname,err :=os.Hostname()
     os_path := os.Getenv("PATH")
     fmt.Printf("hostname = %v\nos_path = %v",hostname,os_path,err)
     }

     值类型和引用类型

   • 值类型： var a int = 19;
   • 包含：基本数据类型：int，float，string，数组，struct
   • 引用类型： 函数的引用等
   • 包含：指针，slice，chan

     小例子：
     写一个程序来打印值类型和引用类型变量到终端，并观察输出结果

package main
import "fmt"
func main() {
    var a string = "hello word!"
    var b chan int = make(chan int,1)
    b <- 13
    fmt.Printf("a=%s\nb=%v",a,b)
}

小例子：交换两个数字的值

package main
import "fmt"
func Test(a int,b int) (int,int){
    return b,a
}
func main() {
    var a int = 8
    var b int = 9
    a,b = Test(a,b)
    fmt.Println("\n",a)
    fmt.Println(b)
}