Go语言的简介和基本使用

Go的简介

Go 即Golang,Go是静态 强类型语言(不能做类型间的运算),是区别于解析型语言的编译型语言。

Go语言特性

跨平台的编译型语言

语法接近C语言

管道(channel),切片(slice),并发(routine)

有垃圾回收的机制

支持面向对象和面向过程的编程模式

go语言环境搭建

一 下载地址

安装包下载地址为:https://golang.org/dl/。安装包(类似于python解释器)

如果打不开可以使用这个地址:https://golang.google.cn/dl/

# 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

 

Go的基本使用

基本语法(打印hello world)

/*
打印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))

}

思考:如何把go程序跨平台编译诚linux下可执行文件

 

 

posted @ 2020-04-20 21:45  Hank·Paul  阅读(434)  评论(0编辑  收藏  举报