Go语言基本常识篇一

Gopackagevariablefunc

gopher [ˈgoʊfər] 是一种挖洞啮齿的动物，产于加拿大南部至巴拿马（Panama）地区。

Go基本知识

1. 包
2. 变量
3. 函数
4. 基本类型
5. 类型转换

包

• 每个 Go 程序都是由包组成的。
• 程序运行的入口是包 main 。 例如：

package main

import (
	"fmt"
	"math/rand"
)

func main()  {
	rand.Seed(2)
 fmt.Println("My favorite number is ",rand.Intn(10))
}

• 这个程序使用并导入了包 "fmt" 和 "math/rand" 。
• 按照惯例，包名与导入路径的最后一个目录一致。例如，"math/rand" 包由 package rand 语句开始。
• main函数必须在 main package中才能运行，main package定义的结构体等不能在main package中共通使用 注意：这个程序的运行环境是确定性的，因此 rand.Intn 每次都会返回相同的数字。 （为了得到不同的随机数，需要提供一个随机数种子，参阅 rand.Seed。）, 也就是随机的种子才能得到随机数

包导入

• 上面代码用圆括号组合了导入，这是“打包”导入语句。
• 同样可以编写多个导入语句，例如：

import "fmt"
import "math/rand"

不过使用打包的导入语句是更好的形式。

导出名

1. 在 Go 中，首字母大写的名称是被导出的，同样结构体的字段首字母大写对外才是可见的，否则外部不能引用（自己理解这里的导出的意思就是对外部包开放课访问的意思）。

2. 在导入包之后，你只能访问包所导出的名字，任何未导出的名字是不能被包外的代码访问的。 例如：

   • Foo 和 FOO 都是被导出的名称。名称 foo 是不会被导出的。
   • 执行代码，注意编译器报的错误。

       package main
   
       import (
           "fmt"
           "math"
       )
   
       func main() {
           //fmt.Println(math.pi)
           fmt.Println(math.Pi)
       }
   

函数

1. 函数可以没有参数或接受多个参数。
2. 在这个例子中， add 接受两个 int 类型的参数。 注意类型在变量名 之后 。

    package main
    
    import "fmt"
    
    func add(x int, y int) int {
        return x + y
    }
    
    func main() {
        fmt.Println(add(42, 13))
    }

函数（续）

1. 当两个或多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他都可以省略。在这个例子中 ，x int, y int被缩写为x, y int

多值返回

1. 函数可以返回任意数量的返回值。
   例如：

       package main
   
       import "fmt"
   
       func swap(x,y string)(string,string)  {
       	return y,x
       }
   
       func main()  {
       	a,b := swap("1","2")
       	fmt.Println(a,b)
       }
   

命名返回值

1. Go 的返回值可以被命名，并且就像在函数体开头声明的变量那样使用。
2. 返回值的名称应当具有一定的意义，可以作为文档使用。
3. 没有参数的 return 语句返回各个返回变量的当前值。这种用法被称作“裸”返回。 直接返回语句仅应当用在像下面这样的短函数中。在长的函数中它们会影响代码的可读性。

    package main
    
    import "fmt"
    
    func split(sum int)(x,y int)  {
        x = sum * 4 / 9
        y = sum - x
        return
    }
    
    func main(){
        fmt.Println(split(80))
    }

以上返回值像方法变量一样定义(x,y int)，return后面没有跟任何返回值，此时默认反回定义的返回值x,y

变量

• var 语句定义了一个变量的列表；跟函数的参数列表一样，类型在后面。
• 就像在这个例子中看到的一样， var 语句可以定义在包或函数级别。

    package main
    
    import "fmt"
    
    var c,python,java bool
    
    func main(){
        var i int
        fmt.Println(i,c,python,java)
    }

初始化变量

• 变量定义可以包含初始值，每个变量对应一个。
• 如果初始化是使用表达式，则可以省略类型；变量从初始值中获得类型。

    package main
    
    import "fmt"
    
    var i , j int = 2,3
    
    func main()  {
        var c,python,java = true,false,"yes!"
        fmt.Println(i,j,c,python,java)
    }

短声明变量

• 在函数中， := 简洁赋值语句在明确类型的地方，可以用于替代 var 定义。
• 函数外的每个语句都必须以关键字开始（ var 、 func 、等等）， := 结构不能使用在函数外。 注意：:=只能在函数中使用，不能再函数外使用，函数外必须使用var 、 func

package main

import "fmt"

func main()  {
	var i,j int=1,3
	k := 4
	c,python,java := true,false,"oops!"
	fmt.Println(i,j,k,c,python,java)

}

基本类型

• Go的基本类型有

bool

string

int  int8  int16   int32  int64
uint uint8 unint16 uint32 uint64

byte //uint8的别称

rune //int32的别称，代表一个Unicode码

float32 float64

complex64  complex128

• 这个例子演示了具有不同类型的变量。 同时与导入语句一样，变量的定义“打包”在一个语法块中。

package main

import (
	"fmt"
	"math/cmplx"
	)

var (
	ToBe bool = false
	MaxInt uint64 = 1<<64 - 1
	z complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
	const f = "%T(%v)\n"
	fmt.Printf(f,ToBe,ToBe)
	fmt.Printf(f,MaxInt,MaxInt)
	fmt.Printf(f,z,z)
}

1. 注意：这里使用的是Printf而不是Println %T打印变量类型%v打印变量值，

2. int，uint 和 uintptr 类型在32位的系统上一般是32位，而在64位系统上是64位。 当你需要使用一个整数类型时，你应该首选 int，仅当有特别的理由才使用定长整数类型或者无符号整数类型。

零值

• 变量在定义时没有明确的初始化时会赋值为 零值 。 零值是：
  • 数值类型为 0 ，
  • 布尔类型为 false ，
  • 字符串为 "" （空字符串）。

package main

import "fmt"

func main() {
	var i int
	var f float64
	var b bool
	var s string

	fmt.Printf("%v %v %v %q\n",i,f,b,s)

}

类型转换

• 表达式 T(v) 将值 v 转换为类型 T 。 一些关于数值的转换：

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

或者更加简单的形式

i := 42
f := float64(i)
u := uint(f)

例子：

    package main
    
    import (
        "fmt"
        "math"
        )
    
    func main() {
        var x,y int= 3,4
        var f float64 = math.Sqrt(float64(x*x + y*y))
        var u uint = uint(f)
        fmt.Println(x,y,u)
    }

注意：与 C 不同的是 Go 的在不同类型之间的项目赋值时需要显式转换。 试着移除例子中 float64 或 int 的转换看看会发生什么。

类型推导

• 在定义一个变量却并不显式指定其类型时（使用 := 语法或者 var = 表达式语法）， 变量的类型由（等号）右侧的值推导得出。
• 当右值定义了类型时，新变量的类型与其相同：

var i int
j := i //j也是一个int

• 但是当右边包含了未指名类型的数字常量时，新的变量就可能是 int 、 float64 或 complex128 。 这取决于常量的精度：

i := 42           // int
f := 3.142        // float64
g := 0.867 + 0.5i // complex128

例子如下：

    package main
    
    import "fmt"
    
    func main() {
    	j := 42.0 //change me
    	fmt.Printf("%T",j)
    }

当改变数值具体的精度时，类型也会随着变

j := 42
j := 42.0
j := 0.867 + 0.5i

常量

• 常量的定义与变量类似，只不过使用 const 关键字。
• 常量可以是字符、字符串、布尔或数字类型的值。
• 常量不能使用 := 语法定义。

package main

import "fmt"

const PI  = 3.14

func main() {
	const World = "世界"
	fmt.Println("Hello",World)
	fmt.Println("Happy",PI,"Day")

	const truth = true
	fmt.Println("Go rules?",truth)
}

数值常量

• 数值常量是高精度的 值 。
• 一个未指定类型的常量由上下文来决定其类型。

package main

import "fmt"

const (
	Big = 1 << 100
	Small = Big >> 99
)

func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
	return x * 0.1
}

func main() {
	fmt.Println(needInt(Small))
	fmt.Println(needFloat(Small))
	fmt.Println(needFloat(Big))
}

本文由 zealzhangz 创作，采用 知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
最后编辑时间为: 2018/06/29 16:38