• Go 基础


    变量

    // 变量
    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
    
        */
    
    /*
    byte:int8
    short :int16
    int:int32
    long:int64
    float:float32
    double:float64
    */

    常量

    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)  0
        //fmt.Println(s2)  1
        //fmt.Println(s3)  2
        //fmt.Println(s4)  99
        //fmt.Println(s5)  4
    
    
    
    
    }
    //const 关键字定义,不允许改变

    变量作用域范围

    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)
    
    }
  • 相关阅读:
    hibernate的dialect大全
    jdbc.properties 链接各类数据库的基本配置以及URL写法
    Springboot中redis的学习练习
    博客开通了
    Java String类的hashCode()函数
    Java String类中CaseInsensitiveComparator.compare()方法的实现
    git pull远程所有分支
    Python的权限修饰符
    Tmux快捷键
    __future__模块
  • 原文地址:https://www.cnblogs.com/ZhZhang12138/p/14886661.html
Copyright © 2020-2023  润新知