1、基础篇(一):包、变量和方法


包( package)

每个Go项目都是由程序包组成的。 程序在main包中运行。

package main

import (
	"fmt"
	"math/rand"
)

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

此程序使用导入的“fmt”和“math/rand”包。 按照惯例,包名称为导入路径的最后一个元素。例如,“math/rand”包含以rand为包名的文件。

import

此代码将导入分组到一个带括号的的import语句中。

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("Now you have %g problems.\n", math.Sqrt(7))
}

您还可以编写多个import语句,如:

import "fmt"
import "math"

但是,建议使用带括号的import语句。

导出名称

在 Go 中,如果名称以大写字母开头,则会导出该名称。例如,Pizza,Pi 是是从math包中导出的名称。 pizza并且pi不要以大写字母开头,因此它们不会被导出。 导入包时,您只能引用其导出的名称。任何“未导出”的名称都无法从包外部访问。 运行代码。请注意错误消息。 要修复错误,请重命名math.pi为math.Pi并重试。

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.pi)
}

函数/方法 (Functions)

Functions

函数可以接受零个或多个参数。 在本例中,add接收两个int类型的参数。

请注意,该类型位于变量名之后。

package main

import "fmt"

func add(x int, y int) int {
	return x + y
}

func main() {
	fmt.Println(add(42, 13))
}

当两个或多个连续的命名函数参数共享一个类型时,可以从除最后一个之外的所有参数中省略该类型。在这个例子中,可以把 x int, y int 简写为 x, y int

多返回值 Multiple results

函数可以返回任意数量的结果。函数可以返回任意数量的结果。

package main

import "fmt"

func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, b := swap("hello", "world")
	fmt.Println(a, b)
}

具名返回值 Named return values

Go的返回值可以命名。这种写法将视为在函数顶部定义的变量。这些变量用于记录返回值。不带参数的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(17))
}

变量(Variables)

var语句声明了一个变量列表;在函数参数列表中,类型是最后一个。 var语句可以是包级别的,也可以是函数级别的。例子中分别展示了这两种情况。

package main

import "fmt"

var c, python, java bool

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

定义带初始值的变量

var 声明每个变量包含初始值的变量。 如果存在初始值,则可以省略类型;该变量将采用初始值设定项的类型。

package main

import "fmt"

var i, j int = 1, 2

func main() {
	var c, python, java = true, false, "no!"
	fmt.Println(i, j, c, python, java)
}

短变量声明

在函数内部,可以使用 := 短赋值语句来代替隐式类型的var声明。在函数之外,每条语句都以关键字(var、func等)开头,因此:=构造不可用。

package main

import "fmt"

func main() {
	var i, j int = 1, 2
	k := 3
	c, python, java := true, false, "no!"

	fmt.Println(i, j, k, c, python, java)
}

基本类型

Go语言的基本类型有

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32
     // represents a Unicode code point

float32 float64

complex64 complex128

该示例显示了几种类型的变量,还显示了变量声明可以被“分解”到块中,就像import语句一样

package main

import (
	"fmt"
	"math/cmplx"
)

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

func main() {
	fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
	fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
	fmt.Printf("Type: %T Value: %v\n", z, z)
}

int、uint和uintptr类型在32位系统上通常为32位宽,在64位系统上为64位宽。当您需要一个整数值时,您应该使用int,除非您有特定的理由使用大小或无符号整数类型。

零值

在没有显式初始值的情况下声明的变量将被赋予零值。 各类型零值:

  • 数字类型 0,
  • 布尔类型 false
  • string类型 "" (空字符串) .
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)

与C不同,Go语言不同类型的项之间的赋值需要显式转换。尝试删除示例中的float64或uint转换,看看会发生什么。

package main

import (
	"fmt"
	"math"
)

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

类型推断

当声明变量而不指定显式类型时(通过使用 := 语法或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() {
	v := 42 // change me!
	fmt.Printf("v is of type %T\n", v)
}

尝试更改示例代码中v的初始值,并观察其类型是如何受到影响的。

常量

常量是像变量一样声明的,但使用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 (
	// 通过向左移动1位100位来创建一个巨大的数字。
	// 换句话说,二进制数是1,后面跟着100个零。
	Big = 1 << 100
	// 再次向右移动99位,所以我们最终得到1<<1或2。
	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))
}

也可以尝试打印needInt(Big)。(int最多可以存储64位整数,有时可以存储更少的整数。)

wx

关注公众号领取Go学习资料

wx

洋葱小店

©2017-2023 鲁ICP备17023316号-1 Powered by Hugo