Go-数据类型以及变量,常量,函数,包的使用
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文件夹下
