go-基础语法

注释

//单行注释
/*
多行注释
多行注释
*/

执行

go（所有编译型语言）项目要运行，必须有一个入口
go的入口是main包下的main函数

// main包下可不可以有多个main函数：不可以

package main //声明包名，包名是main，每一个go文件都属于某个包

import "fmt" //导入包，内置包

func main() { //定义了一个main函数，大括号包裹是函数体的内容
fmt.Println("hello world") //打印函数等同与print()
}

 
go文件执行前要先进行编译后才能执行
第一种方法 命令编译后执行
// 编译
go build s1.go
// 执行
s1.exe

第二种方法 编译并执行，两步并一步
// 编译并执行
go run s1.go

第三种方法 右键运行
// 在goland中，右键，运行即可

变量

package main

func main() {
    //1 定义变量的第一种方式：全定义
    //var关键字 变量名 变量类型 = 变量值
    var age int =10   //在go中，变量定义了就必须使用，如果不使用就报错
    fmt.Println(age)

    //2 定义变量的第二种方式：类型推导（类型不需要写了）
    var age =10
    age=100
    var name ="lqz"
    fmt.Println(age)  //打印并换行
    fmt.Print(name)   //打印不换行
    fmt.Printf("%T
",age)  //查看变量类型
    fmt.Printf("%T",name)
    fmt.Printf("%p",&name)

    //3 定义变量的第三种方式：简略声明（类型和var关键字都不写）这种用的多,冒号和等号是一家
    a:=10
    var a int =100  //重复定义
    var a =99    //重复定义
    a:=99        //重复定义
    a=99
    fmt.Println(a)

    //4 其他变形方式
    //4.1  只定义不赋值
    var age int   //定义变量    //如果是只定义，不赋值，只能用这种
    var age      //只定义，不赋值，不行

    //4.2 声明多个变量
    var width, height int = 100, 50 // 声明多个变量
    var width,height =100,50      // 声明多个变量
    var width,height =100,"lqz"      // 声明多个变量
    width,height :=100,";qz"           // 声明多个变量

    //4.3 声明多个变量,并赋初值
    var (
        name   = "naveen"
        age  int  = 29
        height int
    )
    fmt.Println(name,age,height)


    //4.4 小坑（两个参数要有一个没有被定义过）
    var a int =10
    //var b =99
    b,a:=99,100    //这个不报错，我们觉得是重复定义，冒号左侧，只要有一个没有定义过的变量，就可以
    fmt.Println(b)
    fmt.Print(a)


    /*
    总结：
        1 变量类型在定义阶段就确定了，一旦确定，不允许改变
        2 变量不可以重复定义
        3 变量要先定义再使用
     */
}

变量定义规范

/*
变量命名规范
    -变量命令建议用驼峰，（大小写有特殊意义）
    -go文件命名建议用 下划线
    - 一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线
    -大写字母和小写字母是不同的：Name和name是两个不同的变量
    -关键字和保留字都不建议用作变量名
 */

/*
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

go语言中有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
 */

数据类型

基础数据类型
数字：
有符号整形
    -int：在32位机器是int32，在64位机器是int64
    -int8：表示整数范围是：8个比特位，8个bit是1byte ，负数和0， 2的7次方-1 的范围
    -int16 2的15次方减一
    -int32
    -int64

无符号整型
    -uint8   2的8次方减一  定义一个人的年龄
    -uint16
    -uint32
    -uint64

浮点型（小数），表示小数点后长度多少位
    -float32
    -float64

复数
    -complex64
    -complex128
    byte：是int8的别名  单引号包裹
    rune：是int32的别名  单引号包裹

字符串
    双引号包裹
    反引号包裹  ` `


布尔
    bool true 和 false

数据类型默认值：
    数字类型是 0
    字符串类型是 空字符串
    布尔类型   false

常量

package main

func main() {
    //常量的定义，第一种
    //const  变量名  变量类型 = 变量值
    const  age int8 = 99
    //常量定义了就不能修改就报错
    age=199
    fmt.Println(age)

    //第二种方式类型推导
    const age = 99
    age=88
    fmt.Println(age)

    //其他定义方式
    const name,age = "zhangsan",99
    const (
        name string ="lqz"
        age =99
    )
    const (
        s1  =iota
        s2 =iota
        s3
        s4 =99
        s5 =iota
    )
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
    fmt.Println(s4)
    fmt.Println(s5)
}
//const 关键字定义，不允许改变

函数基础

package main

import "fmt"

//给类型命别名
type MyFunc func(a,b int)(int,string)

type Myint  int

//函数
func main() {
　　　//　类型不同相加不了
    var a int =10 
    var b Myint=9
    fmt.Println(a+int(b)) // 必须要强制转换为相同类型


    //定义方式
    /*
        func 名字(参数名 类型，参数名 类型)(返回值类型，返回值类型){
            函数体内容
            return 返回值1，返回值2
        }
    */
    //1 调用函数
    add(2,3,"xxx")
    var a int =add(2,3)
    a := add(2, 3)
    fmt.Println(a)

    //多返回值就需要用多变量接收
    a,b:=add(3,4)
    fmt.Println(a,b)

    //多返回值，忽略一个返回值
    a,_:=add(3,4)
    fmt.Println(a)
    fmt.Println(_)

    //匿名函数(定义在函数内部的函数，不能是有名函数)，头等函数
    var a func()
    a = func (){
    fmt.Println("我是匿名函数")
    }
    a()

    //函数返回值是函数
    a:=test()
    fmt.Println(a)  // 函数内存地址
    a()

    //8 函数返回值为函数,返回的函数带参数
    a:=test()
    a("xxx")

    //9 函数返回值为函数,返回的函数带参数,带返回值
    var a func(a,b int)int
    a=test()
    fmt.Println(a(2,3))

    //10 函数参数为函数类型，返回值为带参数，带返回值的函数类型
    a,b:=test(func() {
    fmt.Println("我是函数参数")
    })(3,4)
    f:= func() {
    fmt.Println("我是函数参数")
   }
   
    f1:=test(f)
    a,b:=f1(3,4)
    fmt.Println(a,b)

    //闭包函数的使用
    a:=test(19)
   //a是闭包函数
    a()

    //装饰器是闭包函数的典型应用（go中没有装饰器的语法糖），通过闭包实现装饰器

    //类型重命名
    var a MyFunc =test()
    c,d:=a(1,2)
    fmt.Println(c,d)


}

//1 有参数无返回值(定义函数)
func add(a int,b int)  {
fmt.Println(a+b)
}

//2 有参数无返回值,有多个相同类型参数
func add(a ,b int)  {
fmt.Println(a+b)
}

//3 有参数无返回值,有多个相同类型参数，也有不同类型
func add(a ,b int,msg string)  {
    fmt.Println(a+b)
    fmt.Print(msg)
}

//4 多个参数，一个返回值
func add(a, b int) int {
    return a + b
}


//4 多个参数，多个返回值
func add(a, b int) (int,int) {
    return a + b,a*b
}

//5 命名返回值
func add(a, b int) (c int,d int) {
    c=a+b
    d=a*b
    //return时，不需要再写c,d了
    return
}


//6  函数是一等公民，函数可以赋值给变量

//7 函数返回值为函数
func test() func() {
    return func() {
    fmt.Println("我是返回函数")
    }
}

//8 函数返回值为函数,返回的函数带参数
// 类型只要有不一样的地方，就不是一个类型
func test() func(msg string) {
    return func(msg string) {
        fmt.Println(msg)
    }
}

//9 函数返回值为函数,返回的函数带参数,带返回值
func test() func(a,b int) int{
    return func(a,b int) int {
        return a+b
    }
}

//10 函数参数为函数类型，返回值为带参数，带返回值的函数类型
func test(f func()) func(a,b int) (int,int){
    return func(a,b int) (int,int) {
        f()
        return a+b,a*b
    }
}

//11 闭包函数：1 定义在函数内部  2对外部作用域有引用
// 闭包函数就是多了一种函数传参的方法，包进去了
func test(age int) func()  {
    a:= func() {
        fmt.Println(age)
    }
    return a
}

//12 自定义函数名
func test()MyFunc  {
    return func(a,b int)(int,string) {
        fmt.Println("xxx")
        return 10,"ok"
    }

}

变量作用域范围

package main

import "fmt"

//在同一个包下，函数名不能重名
var a int   //全局变量，全局有效，只要改了，就是改了
func main() {
    fmt.Println(a)  //0
    a=19
    fmt.Println(a) //19
    test1()  //99
    fmt.Println(a) //99
}

func test1()  {
    a=99
    fmt.Println(a)

}


//变量的作用域范围
var a int   //全局变量，全局有效，只要改了，就是改了
func main() {
    var a int
    fmt.Println(a)  //0
    a=19  //局部变量
    fmt.Println(a) //19
    test1()  // 0
    fmt.Println(a) //19
}

func test1()  {
    fmt.Println(a)

}