Go-helloworld、声明、变量

HelloWorld

package main
import "fmt"
func main() {
    fmt.Println("Hello, 世界")
}

执行、编译：

//执行
C:\Users\dell\Desktop\typoraNotes\GoSnippets>go run helloworld.go
Hello,世界

//编译
C:\Users\dell\Desktop\typoraNotes\GoSnippets>go build helloworld.go

生成
2019-10-30  08:57         2,105,856 helloworld.exe
2019-10-30  08:56                77 helloworld.go       

声明

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

---

• 常量boilingF是在包一级范围声明语句声明的，在包一级声明语句声明的名字可在整个包对应的每个源文件中访问，而不是仅仅在其声明语句所在的源文件中访问：

// Boiling prints the boiling point of water.
package main
import "fmt"

const boilingF = 212.0

func main() {
    var f = boilingF
    var c = (f - 32) * 5 / 9
    fmt.Printf("boiling point = %g°F or %g°C\n", f, c)
}

变量

var 变量名字 类型 = 表达式

• “类型”或“= 表达式”两个部分可以省略其中的一个。

• 如果初始化表达式被省略，那么将用零值初始化该变量。接口或引用类型（包括slice、map、chan和函数） 变量对应的零值是nil。

• 包级别声明的变量会在main入口函数执行前完成初始化，局部变量将在声明语句被执行到的时候完成初始化。

一组变量也可以通过调用一个函数，由函数返回的多个返回值初始化：

var f, err = os.Open(name) // os.Open returns a file and an error

• 简短变量声明 ：

func main() {
    t := 0.123456789
    fmt.Println(t)
}

声明：

in, err := os.Open(infile)   //声明了in和err两个变量
// ...
out, err := os.Create(outfile)  //只声明了out一个变量，然后对已经声明的err进行了赋值操作

简短变量声明语句中必须至少要声明一个新的变量，下面的代码将不能编译通过：

f, err := os.Open(infile)
// ...
f, err := os.Create(outfile) // compile error: no new variables

• 简短变量声明语句只有对已经在同级词法域声明过的变量才和赋值操作语句等价，如果变量是在外部词法域声明的，那么简短变量声明语句将会在当前词法域重新声明一个新的变量。

• 指针：跟c差不多

func main() {
    x := 1
    p := &x
    fmt.Println(*p)
    *p = 2
    fmt.Println(*p)
}

空指针nil：

func main() {
    var x, y int
    fmt.Println(&x == &x, &x == &y, &x == nil)
}

• 测试例子：echo版本中，就包含了两个可选的命令行参数： -n 用于忽略行尾的换行符， -s sep 用于指定分隔字符（默认是空格）

package main

import (
    "flag"
    "fmt"
    "strings"
)

var n = flag.Bool("n", false, "omit trailing newline")
var sep = flag.String("s", " ", "separator")

func main() {
    flag.Parse() //用于更新每个标志参数对应变量的值（之前是默认值）
    fmt.Print(strings.Join(flag.Args(), *sep))
    if !*n{
        fmt.Println()
    }
}


F:\GoWing>.\程序结构 -help
Usage of .\程序结构:
  -n    omit trailing newline
  -s string
        separator (default " ")

• new函数：表达式new(T)将创建一个T类型的匿名变量，初始化为T类型的零值，然后返回变量地址，返回的指针类型为 *T

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

p := new(int)
q := new(int)
fmt.Println(p == q) // "false"

• 变量的生命周期
  包一级声明的变量来说，它们的生命周期和整个程序的运行周期是一致的。
  局部变量的声明周期则是动态的：从每次创建一个新变量的声明语句开始，直到该变量不再被引用为止，然后变量的存储空间可能被回收。
  函数的参数变量和返回值变量都是局部变量。

/*
f函数里的x变量必须在堆上分配，因为它在函数退出后依然可以通过包一级的global变量找到，
虽然它是在函数内部定义的；用Go语言的术语说，这个x局部变量从函数f中逃逸了
*/
var global *int
func f() {
  var x int
  x = 1
  global = &x
} 

Go语言的自动圾收集器：将指向短生命周期对象的指针保存到具有长生命周期的对象中，特别是保存到全局变量时，会阻止对短生命周期对象的垃圾回收（从而可能影响程序的性能）。