go语言值变量命名规范,定义变量,数据类型,常量,函数基础,函数高级

一.昨日回顾

1 redis高级:高可用,集群,过期策略,缓存穿透,击穿,雪崩
2 go语言介绍
3 环境搭建:go的sdk(开发工具包,开发阶段用),IDE:集成开发环境(goland,vscode,txt)
4 go命令
	-go build go源码编译成可执行文件(在什么平台就编译成什么平台)
	-go env   go的环境变量
		-GO111MODULE ：go 1.11以后，包管理使用go module
		-GOPATH：在不使用go module之前，所有，项目，源代码必须放在该路径下的src下
		-GOROOT: go sdk的安装路径：C:\Program Files\Go
	-go fmt     格式化代码
    -go get     等同于pip3 install 获取第三方模块
    	-go没有一个集中的版本管理仓库（大家约定俗成把它放到github上）
    -go run     编译并执行（开发阶段）
5 go语言交叉编译
6 go hello world
	-一个go项目要运行，必须有个包main包，main包下的main函数，是整个项目的入口
    -导入的包，必须使用，如果不使用，编译不通过
    -func  声明函数 main函数
    -fmt.Println("ssss")   等同于python中的print()内置函数

二.今日内容

1.变量命名规范

1 变量命名，推荐用驼峰  AgeOfXX==  （变量，函数，大写字母开头表示导出，外部包可以使用）
2 go文件命名，推荐用下滑线
3 名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线
4 不要用关键字和保留关键字作为变量名
5 大写字母和小写字母是不同的：Name和name是两个不同的变量

6 Go语言中关键字有25个
	break      default       func     interface   select
    case       defer         go       map         struct
    chan       else          goto     package     switch
    const      fallthrough   if       range       type
    continue   for           import   return      var

7 有37个保留字，主要对应内建的常量、类型和函数
	内建常量: true false iota nil
	内建类型:  int int8 int16 int32 int64
          	   uint uint8 uint16 uint32 uint64 uintptr
               float32 float64 complex128 complex64
               bool byte rune string error
    内建函数: make len cap new append copy close delete
              complex real imag
              panic recover

2.变量

# 记住三种
	-var a int =10
    -var a =10
    -a:=10
# 掌握定义多个
	-var a,b int=10,11
    -var a,b =10,11
    -a,b:=10,11
# 了解其它方式
    var (
        name="lqz"
        age int
    )
# 注意点：
	1 变量要先定义再使用
	2 完整定义可以先定义再赋初值，后面两种方式，定义阶段必须赋初值
	3 变量的类型一旦确定，后期不能修改(跟py最大的差距)

代码演示

package main

//变量定义

func main() {
	// 第一种定义方式：完整定义
	//var关键字 变量名  变量类型=变量值
	//var a int =10
	//第二种定义方式：类型推导
	//var a =10
	// 第三种：简略声明  :=  是一起的不能隔开
	//a := 10
	//name := "lqz"
	//var name string="lqz"
	//var name ="lqz"

	//其它变形
	//同时定义多个变量
	//定义阶段初始化
	//var name,age string="lqz","18"

	//先定义在初始化
	//var name,age string
	//name="lqz"
	//age="18"

	//类型推导定义多个
	//var name,age ="lqz",18
	//这种方式不能先定义再初始化(变量再定义阶段就需要确定类型)
	//var name,age
	//name="lqz"
	//age=18


	//简略声明
	//name,age:="lqz",18


	//了解
	//var (
	//	name1 = "lqz"
	//	name2 = "egon"
	//	age int
	//)
	//fmt.Println(name1)
	//fmt.Println(name2)
	//fmt.Println(age)    // 0

	/*
	变量定义注意点：
	1 变量要先定义再使用
	2 完整定义可以先定义再赋初值，后面两种方式，定义阶段必须赋初值
	3 变量的类型一旦确定，后期不能修改(跟py最大的差距)

	 */

	//a:=10
	a=10.01
	//a="lqz"
	//fmt.Println(a)



}

3.类型

# 数字类型
1 int类型（长度不一样）
	- int8（正负，2的7次方-1），int16（正负，2的15次方-1），int32（正负，2的31次方-1），int64
    -int：在32位机器上是int32，在64位机器上是int64
2 uint类型（无符号）
	-uint8（2的8次方，256），uint16，uint32，uint64
    -uint：在32位机器上是uint32，在64位机器上是uint64
3 float类型(表示精度不一样)
	-float32，float64
    
4 complex 复数类型（不知道）：实部和虚部，并返回一个复数类型
	-complex64, complex128
    
5 byte
	-是 uint8 的别名
6 rune（go语言中的编码方式使用unicode编码）
	-是 int32的别名

# 字符串类型
1 string
# 布尔类型
1 bool



# 注意：
强类型语言：不同类型之间不允许直接运算
显示类型转换：手动转换

代码演示

package main

import "fmt"

func main() {
	//var a int8=128  //报错
	//var a int16=128
	//int64
	//var a int = 9223372036854775807
	//var a int64 = 9223372036854775807
	//fmt.Println(a)

	//var a uint8=128
	//fmt.Println(a)

	//var a float32=9.99
	//var a float64=9.999999999

	//c1 := complex(5, 7)
	//c2 := 8 + 27i
	//fmt.Println(c1+c2)
	//fmt.Printf("a的类型是：%T,a的值是%v",c1,c1)

	//打印变量类型
	//fmt.Printf("a的类型是：%T,a的值是%v",a,a)


	//字符串(双引号，和反引号)

	//a:="lqz"
//	a:=`换行
//   换行阿斯顿发射点
//阿斯顿发顺丰`

	//单引号引起来的是一个字符
	//a:='中'  //int32类型
	//a:='中'
	//fmt.Printf("a的类型是：%T,a的值是%v",a,a)
	//
	//var b bool=true
	//fmt.Println(b)
	//b=false
	//fmt.Printf("a的类型是：%T,a的值是%v",b,b)

	var a = 10.01
	var b =10
	//var c int8=9
	//fmt.Println(a+float64(b))
	fmt.Println(int(a)+b)
	//fmt.Println(b+int(c))

}

4.常量

# 恒定不变的量，定义并赋值后，再也不能改了
const name string="lqz"

5.函数基础

package main

//函数
/*
func关键字 函数名(参数1 参数类型，参数2 参数类型)(返回值类型1,返回值类型2){
}
 */


func main(){
	//var a int=add(7,8)
	//a:=add(7,8)

	//有多个返回值，必须用多个值来接收
	//a,b:=add(7,8)
	//有多个返回值，只要第一个
	//a,_:=add(7,8)
	//var a,b=add(7,8)
	//var a int
	//var b string
	//a,b=add(7,8)
	//fmt.Println(a)
	//fmt.Println(b)



}

//1 最简单的函数
//func add(a int,b int)  {
//	fmt.Println(a+b)
//}


//2 有1个返回值
//func add(a int,b int) int {
//func add(a int,b int) (int) {
//	return a+b
//}

//2 有多个返回值
//func add(a int,b int) (int,string) {
//	return a+b,"成功"
//}


//3 多个参数，类型一致,可以省略前面的类型
//func add(a int ,b int){
//func add(a ,b int)int{
func add(a int,b string){
//	return a+b
//}


//4 命名返回值（了解）
//func add(a,b int) (int) {
//	c:=a+b
//	return c
//}

//func add(a,b int) (c int) {
//	//c:=a+b //重复定义
//	c=a+b    //内部不需要定义
//	//return c  //返回的时候，c可以省略
//	return   //返回的时候，c可以省略
//}

//5 空白符  _  忽略掉某个返回值

6.函数高级

package main

import "fmt"

//函数高级(都是按位置传，没有关键字一说)

func main() {
	//test(1,2,5,6,7,8,8)

	//res:=find(10,1,2,43,54,6,7,8,9,10)
	//fmt.Println(res)


	//3 匿名函数 ，定义在函数内部
	//定义一个匿名函数,加括号使用匿名函数
	//func (){
	//	fmt.Println("我是匿名函数")
	//}()
	//把函数赋值给一个变量,并且执行
	//var a func()  //函数类型
	//a = func() {
	//	fmt.Println("aaaaa")
	//}
	//a()
	a是什么类型？定义出a来



	//var a func()=test(10)
	//a()
	//fmt.Println(a)
	var f func(c int)int
	f=test(10,20)
	res:=f(30)
	fmt.Println(res)

}


//1 可变长参数(可以传任意长度的int类型)
//func test(a... int)  {
//	fmt.Println(a)  //切片类型
//	fmt.Println(a[0])
//}

//2 案例：输入一个数字，和一堆数字，判断第一个数字在不在后面一堆中

//func find(a int,b ...int) string {
//	for i:=0;i<len(b);i++ {
//		if a==b[i]{
//			return "在"
//		}
//	}
//	return "不在"
//}


// 3 匿名函数（没有名字的函数）


// 4 闭包函数（定义在函数内部，对外部作用域有引用）
// 函数可以赋值给一个变量：函数是一等公民，头等函数
//func test(c int) func() {
//	a:=func (){
//		fmt.Println(c)
//	}
//	return a
//}


//5 更高级的使用
//func test(a func(func()),b func())(func(a,b int),func())  {
//	return func(a, b int) {
//
//	}, func() {
//
//		}
//}


//函数的参数和返回值都是类型的一部分
//func()
//func(a int)
//func(a int)int
func test(a,b int)func(c int)int{
	f:= func(c int) int{
		return a+b
	}
	return f
}