Go学习记录---1---包、函数、变量以及常量

1. go程序的基本组成

---

1.1 包

每一个GO程序都是由包组成的。

下面这个程序从main包开始。

---

1.2 import导入包

import导入包有两种形式，

1. 分组导入，使用括号在括号内进行多个包导入。
2. 单包导入，用import语句一条一条导入。

在这段代码中我们使用分组导入，用了括号组合导入了两个包，一个是fmt标准输入输出包，一个math里的rand包用来生成随机数。

例子：

package main

import (
	"fmt"
	"math/rand"
)

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

导包也可以也可以通过一条一条导入。例如：

import "fmt"
import "math/rand"

通过调用fmt的Println来输出语句,

fmt.Println("My favorite number is", rand.Intn(100))

输出结果：

My favorite number is 81

---

1.3 导出名

在Go中如果一个名字是以大写字母开头的，说明这个名字是已经导出的，而如果当将这个名字大写换成小写，将会找不到这个名字，导致报错。

这种以大写字母开头的名字我们称之为导出名，导出名由导入的包提供，如果导入的包不提供，则没有导出名。

举例子前的前置知识：在math包中提供一个导出名为Pi

我们接下来将使用小写与大写的输出结果进行对比。

例子1：

package main

import (
	"fmt"
	"math"
)

func main()  {
	//输出小写pi
	fmt.Println("My favorite number is",math.pi)
}

结果：

例子2：

//对pi修改成Pi
fmt.Println("My favorite number is",math.Pi)

结果：

---

2 函数

函数定义是以func开头，后接函数名、参数列表、返回值以及方法体。

---

2.1 函数参数

函数可以接受0个或者 多个(包含1个) 参数。
例子：

package main

import "fmt"
//相加函数，返回传入参数的和
func add(x int,y int) int  {
	return x+y;
}

func main()  {
	fmt.Println(add(3,4))
}

ps:func函数定义在最前面 ，函数返回类型在函数名后面，类型在变量名后面.

当函数中传入参数连续两个或者多个类型相同时，除了最后一个必须写参数类型，其他的可以不要写。

例子：

package main

import "fmt"

//函数中存在一个string类型和两个int类型
func add(c string,x,y int) int  {
	fmt.Println(c)
	return x+y
}

func main()  {
	fmt.Println(add("Go~",3,4))
}

结果：

---

2.2 函数之多值返回

在函数返回值的时候可以同时返回多个结果。
例子：

package main

import "fmt"

func add(c string,x,y int) (int,int,string)  {
	fmt.Println(c)
	return x+y,y-x,"bbb"
}

func main()  {
	fmt.Println(add("aaa",3,4))
}

结果：

---

2.3 函数之命名返回值

Go中函数的返回值可以被命名，返回值的名称应当有一定的意义。

没有参数的return语句将直接返回已命名的返回值。

例子：

package main

import "fmt"

//函数返回值命名为x,y
func swap(sum int) (x,y int) {
	x  = sum %10
	//将y的赋值取消，查看是否会返回，结果会返回默认值0
	//y = sum*10
	//返回时没有指出具体的返回值
	return 
}

func main()  {
	fmt.Println(swap(18))
}

结果：

---

3. 变量

3.1 变量声明var

变量声明时使用var来声明。

声明格式（单个变量）： var 变量名 变量类型
例子：

package main

import "fmt"
//bool是布尔类型的意思
var c,Java,python bool;

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

结果：

---

3.2 多个变量同时声明

当有多个变量同时声明时，相同类型可在最后添加类型。

如果变量已存在初始值，变量会通过初始值的类型去获得类型。

例子：

package main

import "fmt"
//声明了两个int类型的变量i和j
var i,j int = 1,99

func main()  {
	//通过变量的初始值去判断它的类型
	var c,java,python = true,1,"python"
	fmt.Println(i,j,c,java,python);
}

结果：

---

3.3短变量声明

在函数内可以使用:=代替var，在函数外所有都必须以关键字开头(例如：func，var等等)，
因此:=不能再函数外使用。

例子：

package main

import "fmt"

func main()  {
	//使用 := 进行变量声明
	num := 89
	fmt.Println(num);
}

3.4 变量的基本类型

bool

string

int int8 int16 int 32 int64

uint uint8 uint16 uint32 uint64 uintptr

byte //uint8的别名

rune //int32的别名 表示一个Unicode码点

float32 float64

complex64 complex128

int,uint和uintptr在32位系统上通常为32位宽，在64位系统上则为64位宽。当需要使用一个整型的时候应该使用int类型。

3.5 变量声明语法块

变量的声明也可以和import语句一样，单独‘分组’成单独的一个语法块。

例子：

package main

//import导入的包块
import (
	"fmt"
	"math/cmplx"
)

//var声明的变量块
var  (
	ToBe  bool = false
	MaxInt uint64  = 1<<64-1
	z complex128 = cmplx.Sqrt(-5+12i)
)

func main()  {
	//%T打印变量类型，%v打印变量内容
	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)
}

结果：

3.6 零值（默认值）

没有明确初始值的变量会赋予一个默认的零值。
零值是：

• 数值类型是0.
• 布尔类型是false
• 字符串是""（空字符串）

例子：

package main

import (
	"fmt"
)

func main()  {
	var intS int
	var stringS string
	var boolS bool
	var float64S  float64
	fmt.Printf("%v %v %v %q\n",intS,boolS,float64S,stringS)
}

结果：

3.7 变量的类型转换

表达式T(v)将值v转变成类型T。

GO在不同类型项之间赋值时需要显示转换，如果没有显示转换则会报错。

例子：

package main

import (
	"fmt"
	"math"
)

func main()  {
	//变量类型转换
	x,y:=3,4
	//int转flat64
	f := math.Sqrt(float64(x*x+y*y))
	//float64转int
	z := int(f)
	fmt.Println(x,y,z)
}

3.8 变量类型推导

当声明一个变量既不给类型也不给初始值，则会根据使用时右值的类型推导出该变量的值。

package main

import (
	"fmt"
)

func main()  {
	//变量类型推导
	var name string= "123"
	sample1 := name
	sample2 := 123
	fmt.Printf("sample1的Type是%T\n",sample1)
	fmt.Printf("sample2的Type是%T",sample2)
}

---

4 常量

4.1 常量的声明

• 常量的声明与变量类似，但是使用的关键字是const。
• 常量可以是字符、字符串、布尔值或者数值。
• 常量不能使用:=语法声明。

例子：

package main

import "fmt"

func main()  {
	//常量使用
	const name = "世界"
	const guess = true
	const num = 3.14
	fmt.Println("hello,",name)
	fmt.Println("Guess?",guess)
	fmt.Println("优秀数字:",num)
}

结果

---

4.2 高精度的数值常量

数值常量是高精度的值。

一个没有指定类型的常量是由使用它的上下文来决定它的类型的。

例子：

package main

import "fmt"

const (
	//1左移100位
	Big = 1<<100
	//Big右移99位
	Small = Big>>99
)

func needInt(num int) int  {
	return num*10+1
}
func needFloat(num float64) float64  {
	return num/10
}
func needComplex128(num complex128) complex128  {
	return num+5i
}

func main()  {
	//常量根据使用变更类型
	fmt.Println(needInt(Small))
	fmt.Println(needFloat(Small))
	fmt.Println(needComplex128(Big))
}

结果：