Go-数据类型以及变量,常量,函数,包的使用

一.数据类型

1.字符串类型

string

-双引号包裹的："xxx"

-反引号包裹，可以换行，

注意：

区别于python，是没有单引号，三引号的

用法：

var s string=`

你好

我好

大家好

`

var b string="你好\n" +

		"我好" +

		"大家好"

2.数字类型

有符号整型（整数含正负）:

int: int 在32位机器上是int32 在64位机器是int64
int8: 表示占一个字节（8个比特位）表示的范围是：正负2的7次方-1
int16: 表示占两个字节（16个比特位）表示的范围是：正负2的15次方-1
int32: 类似int8
int64: 类似int8

无符号整型（正整数）:

uint :uint 在32位机器上是uint32 在64位机器是uint64
uint8 : int8 表示数字范围是正2的8次方-1
uint16
uint32
uint64

浮点型

float32 : 有符号小数,32后7位

float64: 64 有符号小数,32后7位

都是表示小数点后范围不一样（代码里面没有float，只有float64和float32）

complex64: 32 位实数和虚数

complex128: 64 位实数和虚数

别名

rune:rune是int32的别名
byte:byte 是uint8的别名

3.布尔类型(首字母小写)

false 和 true

4.派生类型(简单介绍)

指针类型（Pointer）

数组类型

结构化类型(struct)

Channel 类型

函数类型

切片类型

接口类型（interface）

Map 类型

二.变量的声明

方式一（全定义）

单个变量

var 变量名 变量数据类型=变量值

多个变量

a,b,c都为string必须3个变量类型相同

var a,b,c string="1","2","3"   //注意string必须是双引号

方式二（类型推导）类型可以省略

单个变量

var 变量名 =变量值

多个变量

a,c为string，b为int

a,b,c三个变量类型不同也可以声明

var a,b,c="1",2,"3"

方式三（简略声明）

单个变量

变量名 := 变量值  //注意点:= 必须连着不能有空格

多个变量

a,b,c都为string

a,b,c三个变量类型不同也可以声明

a,b,c :="1",2,"3"

注意点

同一变量名不能重复声明
变量定义和赋初值(int 空值是 0 string空值是 "")
变量要先定义后才可以赋值再使用
变量名定义后必须使用，否则报错
可以声明多个变量(三种方式都可以用)
如果声明后的变量需要修改值用=

var a int

a=100

三.常量的声明

方式一

const 变量名 变量类型 =值

方式二

const 变量名 =值

package main

import "fmt"

//程序运行期间不允许修改

//数据库，redis连接

//const关键字 常量名 =常量值   赋值一次，不允许修改

//const NAME  = "cxk"

//const NAME  string = "cxk"

const sex  = true

func main() {

	//fmt.Println(NAME)

	//fmt.Println(sex)

	//sex=false

	fmt.Println(sex)

}

注意点

常量一旦被定义赋值后将无法第二次修改

四、函数的使用

无参数无返回值

方式一

func 函数名()(){}

方式二

func 函数名(){}

无参数有返回值

方式一

func 函数名()(返回参数1的数据类型1){}

定长参数,有返回值

func 函数名(参数1 类型，参数2 类型)(返回参数1的数据类型1,返回参数2的数据类型){}

//如果参数1与参数2的数据类型相同

func 函数名(参数1，参数2 类型)(返回参数1的数据类型1,返回参数2的数据类型){}

//如果参数1与参数2的数据类型为int,参数3数据类型为uint

func 函数名(参数1，参数2 int,参数3 uint)(返回参数1的数据类型1,返回参数2的数据类型){}

定长参数,无回值

//方式一

func 函数名(参数1 类型，参数2 类型){}

//方式二

func 函数名(参数1 类型，参数2 类型)(){}

不定长参数

//方式一

func 函数名(不定长参数1 ...类型){}

//有定长参数和不定长参数

func 函数名(定长参数 类型,不定长参数1 ... 类型){}

//不定长的参数必须写在定长的参数后面

//不定长参数所有数据类型

func 函数名(不定长参数1... interface{}){}

匿名函数

//定义

func (参数一,参数二)(返回参数1的数据类型1){return 1 }

//定义+调用

func (参数一,参数二)(返回参数1的数据类型1){return 1 }()

命名返回值

package main

import "fmt"

func abc()(a int,b int){

    //var a,b int  相当于默认执行这条

    //但是ab只在函数内生效函数外部生效

    return

    //return 与return a,b是一样的

}

func main() {

    fmt.Println(abc())

}

注意点

由于是编译型语言main 与main里面使用的函数不需要注意先后关系
没有关键字传参
没有默认参数
函数没有缩进的约数,但是为了排版还是要注意缩进不然会看上去非常非常丑

函数使用实例：

//函数

package main

func main() {

	//test()

	//test(3,4,"xxx") //没有关键字参数一说,都按位置传，也没有默认参数

	//test(3,4,"xxx")

    //三种方法调用

	//var a int =test(3,4)   //定义变量a接收返回值

	//var a  =test(3,4)

	//a  :=test(3,4)

	//fmt.Println(a)

	//返回两个值，就要用两个值来接受

	//a,b:=test(3,4)  //这种用的多

	//var a,b int=test(3,4)

	//var a,b =test(3,4)

	//fmt.Println(a,b)

	//如果有个值不想接收

	// _,a,_:=test(3,4)

	//fmt.Println(a)

	// py中 _ 是一个真正的变量，go中，就是没有

	//fmt.Println(_)

	test(1,2,3,4,5,5,6,7)

}

//func关键字  函数名(参数1 参数类型，参数2 参数类型)(){

//函数体的内容

//}

//函数使用1(没有先定义再使用这一说)

//func test()  {

//	fmt.Println("我是test")

//}

//函数使用2 带参数

//func test(a int,b int,c string) {

//	fmt.Println(a+b)

//	fmt.Println(c)

//}

//函数使用3

//func test(a ,b int,c string) {

//	fmt.Println(a+b)

//	fmt.Println(c)

//}

////函数使用 4 规定返回值类型

//func test(a,b int) int {

//	//返回a+b的结果

//	return a+b

//}

//函数使用 5 规定返回值类型,返回多个值

//func test(a,b int) (int,int,string) {

//	//返回a+b的结果

//	return a+b,a*b,"ok"

//}

//函数使用6 不定长参数

//func test(z ...int)  {

//	fmt.Println(z)

//

//}

五、包的使用

包的介绍以及使用

为什么使用包？

为了更加好的维护代码

包的位置？

必须在GOPATH路径的src中

能导入的内容？

导入的内容名称必须是大写字母开头不然无法导入包

src中的一个文件夹为一个包

包内的变量以及函数名

在同一文件夹下,就相当于同一包中,任何变量名不能进行二次定义

在同一包中,可以互相使用其他GO文件下的函数且不需要导入

go 程序中必须有一个main和一个main入口

如果不是package main他就是一个包,他会把里面的函数都进行保存,不能有main函数

main`也是一个特殊的包,其中必须要有main函数,作为程序的入口,也就是执行这个文件的时候其中就是运行`main函数

导入第三方模块

语法:go get 第三方模块路径

文件会被安装在GOPATH路径的src文件夹下