# go version 查看go的版本

# go env    查看go的环境变量
GO111MODULE= # 没有值或者off，表示没有开启go mode模式，用的就是gopath模式
GOROOT=c:\go  # go开发包的安装路径，确认好是否对
GOPATH=C:\Users\Administrator\go # 代码存放路径，确认好是否对，以后你的go代码都放在这个文件夹下

# 在任意位置敲go，都有这个命令，需要把 c:\go\bin加入环境变量

# go mode模式：代码可以放在任意路径

# 1 不管是用goland还是其他ide，新建项目的路径（代码），必须放在gopath路径下的src文件夹（如果没有手动创建出来）
# 2 gopath路径下会有三个文件夹：src（放代码的），pkg（编译过程产生中间的东西），bin（编译后的可执行文件）

# 3 创建项目，在项目下，创建go文件，起一个名字

# 4 执行代码（编译型语言，先编译再执行）
编译：go build xx.go   -->编译成当前平台下的可执行文件，名字为xx
执行：xx或者./xx    windows：在可执行文件路径下  xx.exe

# 5 go命令
-go build   编译
-go install 安装，把编译好的可执行文件，放到bin路径下
-go fmt ：代码格式化
-go run xx.go  编译并执行

# 6 在golang中执行
右键，选择，run

/*
打印hello world
 */

// go语言中的单行注释使用

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

//ctrl+/ 可以快速注释，解注释（goland）
package main  //表示声明main包，每一个go代码的第一行必须写这个


import "fmt"   //导入fmt包    类比python中import os os.path

func main() {  //声明main函数  函数体的内容，放到大括号中
    //goland提示的a... 形参是a
    fmt.Println("hello world")   //在控制台输出helloworld --->  print("hello world")
    fmt.Println("hello world")

}

// 程序的执行入口，是main包下的main函数
// 编译型语言，都有入口 ----》 对比python中一个py文件就是一个main函数

//一个go项目只能有一个main函数

package main

import "fmt"

func main() {
    // 1.方式一：基本定义
    //var关键字 变量名 变量类型 = 变量值
    //var age int = 18  // 定义并赋值
    //var age int  // 定义
    //age = 18 // 赋值

    // 2.方式二：类型推导(不需要加类型了)
    //var age = 18
    //var age      //错误，变量定义时，就要固定类型
    //age=18


    // 3.方式三：简略声明(冒号和等号是一起的)
    //age := 18

    //Printf，%T表示类型
    //fmt.Printf("age的类型是:%T,值是：%d\n",age,age)
    //fmt.Println(age)

    // 4.方式四、同时定义多个变量
    //var a,b,c int = 1,2,3

    //var a,b,c = 1,2,3

    //变形(能看懂，表示在定义即可)
    //var (
    //    a=19
    //    b="lqz"
    //    c="男"
    //)
    //fmt.Println(a,b,c)

    // 5.变量需要先定义再使用
    //a := 10
    //fmt.Println(a)

    // 6.变量不能重复定义
    var a int= 18
    //var a = 19   // 重复定义 报错

    // 简略声明的小特殊(冒号前，至少有一个未定义的变量不会报错)
    a,b := 17,18
    fmt.Println(a,b)

    // 7.变量类型是固定的

    /*
    注意：
       1. 变量定义后必须使用，否则报错
       2. 包导入了，要使用，不使用就报错
       3 先定义再使用
       4 不能重复定义
       5 类型固定
     */
}

/*
常量：恒定不变的量，建议常量全用大写
程序运行过程中，不会改变的值，如数据库的连接地址，端口号
 */

package main

func main() {
    // 1. const关键字 常量名 常量类型 = 值
    // 2. 常量可以定义了不使用，但不能重复定义，类型不能改
    //const age int = 19

    // 3.类型可以省略
    //const age= 99
    //fmt.Printf("%T",age)

    // 4.可以同时定义多个常量
    //const (
    //    AGE=19
    //    NAME="lqz"
    //    SEX="男"
    //)
    //fmt.Println(AGE,NAME,SEX)

    // 5.不能改变常量
    //const AGE= 99
    //const AGE= 18 报错
}

/*
基本数据类型
*/
package main

func main() {
    /*
        1 数字类型
            有符号整形：（长度不同，表示的数字范围不一样）
                -int:在32位机器上是int32，在64位机器上是int64
                -int8 ：8个bit位，一个字节，正负 2的7次方-1的范围
                -int16: 正负 2的15次方-1的范围
                -int32:
                -int64:
            无符号整数：
                -uint8 ：2的8次方-1
                -uint16：
                -uint32
                -uint64
            浮点型：
                -float32：精度不一样
                -float64：一般用64
            复数：
                -complex类型：（了解，不知道更好）实部和虚部
            其他：
                -byte：uint8的别名
                -rune:int32的别名

        //2 字符串类型:用双引号包裹的内容,反引号 ``
            反引号可以换行


        //3 布尔类型
            true false  (小写)
    */

    //数字类型
    //var a int=200
    //var a uint8=-200
    //fmt.Println(a)

    //浮点型
    //var a float32
    //var b float64

    //复数
    //var a complex64 = 9i+10
    //fmt.Println(a)

    //字符串
    //var name = "lqz"
    //var name2 = `egon
    //    is
    //big`
    //fmt.Println(name)
    //fmt.Println(name2)

    //如果双引号内如果有双引号， 加\转义或者用反引号
    //var name string ="lqz \"dafds\"is "
    //var name1 string =`lqz "dafds"is `
    //var name2 string ="lqz `dafds`is "
    //fmt.Println(name)
    //fmt.Println(name1)
    //fmt.Println(name2)

    //布尔类型
    //var a bool =true
    //var a  =true
    //a  :=true
    //var b bool =false
    //fmt.Println(a)
    //fmt.Println(b)



    //类型转换(强类型:不通类型之间不能做运算)
    //类型转换
    //var a int =19
    //var b float32=18.1
    //float转成int类型，小数点后直接弃用，不是四舍五入
    //fmt.Println(a+int(b))
    //var b float32=18.999
    //fmt.Println(int(b))  // 输出为18

    //(了解)
    //var a int =199
    //var b int64=199
    ////int和int64不是一个类型
    //fmt.Println(a+int(b))

}