go之基础语法等相关内容-148

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最大的差距)

 

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
​
​
​
# 注意：
强类型语言：不同类型之间不允许直接运算
显示类型转换：手动转换

 

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
}
​
​
​
​
​
​
​
​
​