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文件夹下