Go语言基本常识篇一

/ Go技术 / 没有评论 / 539浏览

Go

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

Go基本知识

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

package main

import (
	"fmt"
	"math/rand"
)

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

包导入

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

变量

    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)
    }

短声明变量

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)

}

基本类型

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,仅当有特别的理由才使用定长整数类型或者无符号整数类型。

零值

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)

}

类型转换

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 的在不同类型之间的项目赋值时需要显式转换。 试着移除例子中 float64int 的转换看看会发生什么。

类型推导

var i int
j := i //j也是一个int
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

常量

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))
}