go语言

1.go语言介绍

2.开发环境搭建

3.我的第一个hello world

4.变量的定义

5.变量类型

6.常量

7.函数基础

8.函数一定是公民（先了解一下的）

 

 

一.go语言介绍

go是什么：

Go 即Golang，是Google公司2009年11月正式对外公开的一门编程语言。
Go是静态强类型语言，是区别于解析型语言的编译型语言。

解析型语言——源代码是先翻译为中间代码，然后由解析器对代码进行解释执行。
编译型语言——源代码编译生成机器语言，然后由机器直接执行机器码即可执行。

go语言的特性：

跨平台的编译型语言
语法接近C语言
管道（channel），切片（slice），并发（routine）
有垃圾回收的机制
支持面向对象和面向过程的编程模式

 

go语言介绍：
python，php，js
c，c+，c#：微软，java：sun公司，后来被甲骨文收购了，go：谷歌
go语言发展：Google
2019年11月出的，python：1989年   java：1990
Go是静态强类型语言：强类型：类型固定
那么go语言为什么这么火？
　　　　docker容器化  devops比较火
　　　　k8s go写的：容器编排
　　　　区块链：第一个开源的区块链项目是用go写的
　　　　性能高，特别适合服务端开发
　　　　部署容易

补充跨平台的编译型语言：
c开发：在windows上开发，编译好的只能在windows上用
java横空出世：跨平台，一处编码到处运行
　　　　运行在java虚拟机之上
　　　　编译成字节码文件：中间态
go：跨平台编译
　　　　在windows平台可以编译出linux下的可执行文件

以下是补充内容：
        1.定义在函数内部，对外部作用域有引用
        2.编译型：
        不依赖语言环境运行

        解释型：
        需要解释器，缺点是执行速度慢
        python，js
        c，java，go
    
         3.比特位：
         8bit = 1bytes（ b）
         1024b = 1kb
         1024b = 1m
         1024m = 1g          

 

二.开发环境搭建

开发环境搭建：
go开发环境：gol.13.5.windows-amd64
下载地址：https://golang.google.cn/dl/
安装完以后可以在cmd里面输入go version 查看go版本
环境变量会自动配置的
go env 配置得到环境变量代表着什么意思：
　　GOPATH = C:\User\oldboy\go   go的代码必须放这个路径下，你要是不放的话需要改路径
　　GOROOT = c:\go   go的安装路径
　　

go  ide: goland-2019.3.exe

补充：
　　主流的ide（集成开发工具）
　　　　pycharm
　　　　idea/my eclipse：java web，收费  /eclipse：免费
　　　　goland
　　　　vs code：开发java，微软出的
　　　　datagrip:数据库操作相关
　　　　jetbrains 全家桶，他把市面上所有的编程语言的开发工具都写了一遍 （推荐都是用这个，因为开发工具都是用一套的，使用起来差不多）

 

三.我的第一个hello world

因为goland是编译型语言，如果先编译在执行，该怎么写，如果想把代码给别人的话，可以直接把编译好得到可执行文件给别人
在黑终端上：
    go build 文件名     这是编译
    文件名执行
编译并执行：因为开开发阶段，不需要生成文件给别人
go run s1.go

在go的开发者工具上就不需要了，可以直接鼠标右键run执行

// 单行注释
/*
多行注释
多行注释
    */
package main // 表示当前go文件属于main包
import "fmt" // 导入fmt包

// 编译型语言需要有一个入口文件，main包下的main函数
func main(){ // 定义了一个main函数
    fmt.Println("hello word") // 打印hello word
}

 

 

四.变量的定义

总结：

// 定义变量 有三种方式
    // 注意：在go语言中定义的变量必须使用，不然会报错
        //var关键字 变量名 变量类型 = 值
    //方式一：全名称
        var a int=10
    
        // 方式二：类型推导，就是会自动预判你的变量类型
        var a = 10

        // 方式三:简易方式
        a：=10   比较常用的

注意：
1.变量一定不能重复定义
2.值的类型固定住了，就不能改了比如说我 var a = 10  这就是int类型，就不能用 a= "zy"字符串了。
3.定义不赋初值 :int 类型默认值是0  string类型默认值是空字符串
4.同时定义多个变量可以这样写：var a,b = 10,"zy"  记住要用双引号

 

// 变量
package main // 表示是main包
import "fmt"

func main() {
    // 定义变量 有三种方式
    // 注意：在go语言中定义的变量必须使用，不然会报错
    //方式一：全名称
    //var关键字 变量名 变量类型 = 值
    var a int=10  //定义一个init类型的变量a，把10赋值给他
    fmt.Println(a)
    // 方式二：类型推导，就是会自动预判你的变量类型
    var a = 10
    fmt.Println(a)
    // 方式三:简易方式
    a:= 10
    fmt.Println(a)
    // 变量不能重复定义
    var a int = 10
    a:= 10  // 变量重复了
    fmt.Println(a)
    fmt.Println(a)
    // 强类型语言 ，就是类型固定就不能改了
    var a = 10
    a = 100
    //a = "zy" // 因为在初始阶段已经推导为int类型，所以就不能改变了
    b:="zy" // 可以这么写，重新定义一个变量
    fmt.Println(a)
    fmt.Println(b)
    // 定义不赋初值 :int 类型默认值是0  string类型默认值是空字符串
    var a int
    fmt.Println(a)
    var b string
    b = "zy"
    fmt.Println(b)
    // 同时定义多个变量
    var a = 10
    var b = 100 // 这样写太麻烦了
    var a,b int=10,20
    fmt.Println(a)
    fmt.Println(b)
    var a,b =10,"zy" // 注意这里必须使用双引号
    fmt.Println(a)
    fmt.Println(b)
    // 这种了解就可以了
    var(
        name = "zy"
        age = 29
        height int
    )
    fmt.Println(name)
    fmt.Println(age)
    fmt.Println(height)


}

 

五.变量类型

补充：

    /*
        int类型：表示整数,int8   int16  int32  int64
        计算机最小计量单位：bit位  int8 是 8个比特位=1个字节，表示的范围是：正负2的7次方减1
        在32位机器上int 就是int32 ，在64位机器上int就是int64
        uint类型：表示正整数 uint8 uint16...
        float类型：表示小数只有float32和float64
        complex64类型：复数
        byte: uint8的别名
        rune:int32的别名
    *

 

//变量类型
package main

import "fmt"

func main() {
    // bool类型 0值是false
    var b bool = true
    var b = true
    b:=true
    var b bool  // 0值就是false
    fmt.Println(b)

    // int 类型
    var a int = -10
    fmt.Println(a)
    var a int = 100000
    fmt.Println(a)
    var a uint8 = 100
    fmt.Println(a)
    //浮点型
    var a float32 = 2.33
    fmt.Println(a)
    // 字符串(必须用双引号)，反引号是python中的三引号,可以换行
    //b:='a'
    //fmt.Println("%T",b)
    //var a string = "zy"
//    var c string=`dsjasld
//adasdasdasd
//
//dasdddewed
//sdasd`
//fmt.Println(c)
var c string = "dasd" + // 看着像是换行了，实际上并没有换行
    "dasd" +
    "ad" +
    "ad" +
    "as" +
    "d"
fmt.Println(c)
}

 

 

六.常量

//常量：恒定不变的量
// const 就是定义常量的关键字
package main
import "fmt"
func main() {
    //var a int=10
    //定义了一个常量a
    //const a int=10
    const a =10
    //a=100
    fmt.Println(a)
    const b ="192.168.1.1"

}
那么有什么用了，比如说用在数据库当中，声明

 

七.函数基础

// 函数
package main

import "fmt"

//func main() {
    //test()
    //test(1,2,"dja")
    //var a int = test(1,2) // 太麻烦了
    //a:= test(1,2) //这种方式用的比较多一点
    //fmt.Println(a)
    //a:= test("1","1")
    //fmt.Println(a)

    //a,_:=test(1,2)
    //// 不要第二个返回值了
    //fmt.Println(a)
    ////fmt.Println(b)

    //a:=test()
    //fmt.Println(a)
    //a:=test(
    //test(1,1,2,"dasdsd",2,3,2)



//}

// 函数定义，语法
// func关键字 函数名(参数1 类型，参数2 类型) (返回值类型){}
// 1.无参函数，无返回值
//func test(){
//    fmt.Println("zy")
//}
//2.有两个int类型的参数
//func test(a int,b int){
//func test(a ,b int){
//func test(a ,b int,c string){
//
//    fmt.Println(a+b,c)
//}
//3.有一个数字类型返回值，一定要指定返回值类型
//func test(a ,b int) int {
//    return a+b
//}
// 返回一个字符串类型
//func test(a ,b string) string {
//    return "sadas"
//}
// 4.返回多个值
//func test(a,b int)(int,string){
//    return a+b,"成功"
//}
//5.命名返回值(了解，就用没有命名也可以)
//func test(a,b int)(c int,d string){
//    c = 10
//    d="成功"
//    return
//}

//6.在go当中没有位置参数和关键字参数，都是位置参数，也没有默认值参数
//func test(a,b int) int {
//    return a+b
//}

// 不定长参数 interface:接受任意类型
//func test(a ...interface{}){
//    fmt.Println(a)
//}

 

 

八.函数一定是公民（先了解一下的）

// 先了解一下
// 闭包函数
// 定义在函数内部，对外部作用域有引用
// go语言中，函数是一等公民，可以把函数赋值给一个变量，函数就是一等公民

func test(a int) (int,int) {
    fmt.Println("xxx")
    return 1,2

}

func main() {
    var a func(a int) (int,int)
    //var a = test
    //a:=test
    a = test
    a(1)
}