Go语言基础(一)

一、Go语言简介

Go即Golang,是Google公司2009年11月正式对外公开的一门语言
Go是静态强类型语言，是区别于解析型语言的编译型语言。
解析型语言--源代码是先翻译为中间代码，然后解析器对代码进行解释执行。
编译型语言--源代码译生成机器语言，然后由机器直接执行机器码即可执行。

二、Go语言特性

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

Go语言用途：区块链(最开始的开源的数字货币是用Go写的)、docker/k8s

三、Go语言目录架构

GOPATH的工作区包含bin、src、pkg
src---源码(包含第三方的和自己项目的)
bin---编译生成的可执行程序
pkg---编译时生成的对象文件

四、Go语言开发环境搭建

IDEs下载地址：https://www.jetbrains.com/go/
安装包下载地址:https://golang.google.cn/dl/
windows和linux环境都可以进行安装，都需要添加环境变量，windows安装包有自动添加功能

了解ide：
-eclipse/myeclipse
-idea:做java开发
-pycharm:python开发
-goland:go语言开发
-vscode:go开发
-androidstudio开发:idea改的
-eclipse+adt

测试Hello World：

package main
import "fmt"

func main() {
    fmt.Println("Hello World")
}

打开cmd,到对应项目的目录下，执行命令
go build s1.go  ---> 可以编译生成出s1.exe,然后执行就可以打印出：helloworld
也可以在IDEs里执行，和命令里执行差不多，只是没有生成s1.exe

并不是所有的go程序都可以编译成可执行文件，要生成可执行文件需要满足2个条件：
  --该go程序需要属于main包
  --在main包中必须还得包含main函数

Go程序的入口就是 main.main
go run可以将go build 2步并成一步且不生成exe文件
C:\代码\代码\src\day01>go run s1.go
hellowrold

五、Go命令介绍

基本命令介绍：
build:编译包和依赖
clean：移除对象文件
doc:显示包或者符号的文档
env:打印go的环境信息
bug:启动错误报告
fix：运行gofmt进行格式化
generate:从processing source生成go文件
get:下载并安装包和依赖
install：编译并安装包依赖
list:列出包
run:编译并运行go程序
test:运行测试
tool:运行go提供的工具
version:显示go的版本
vet:运行go tool vet

get命令：下载并安装第三方包

使用方式：go get 包名

然后我们可以用下面的方式进行使用
package main
improt "github.com/astaxie/beego" # 这里需要使用src下的完整路径
fun main(){
    beego.Run()
}

六、简述hello world程序

//单行注释
/*
多行注释
多行注释
 */
//表示是main包,表示程序入口
//程序执行,会去执行main包下的main函数
package main
//导入fmt包
import "fmt"

//main函数
func main()  {
    //使用fmt包下的Println打印
    //字符串用双引号
    fmt.Println("hellowrold")
}

package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包

func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

/*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。
        多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。
fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。

七、变量定义

# 定义单个变量
package main

func main() {
    //变量定义
    //第一种方式
    //var关键字 变量名 变量类型 = 变量值
    //变量定义了一定要使用,不使用报错
    var a int=10
    fmt.Println(a)
        //第二种方式(类型推导,省略类型)
        var b =10
        fmt.Println(b)
        //第三种(简略赋值) 用的最多
        c:=10
        fmt.Println(c)
}

// 定义多个变量
package main
import "fmt"

func main() {
    var a,b int
    a =10
    b =20
    fmt.Println(a,b)
}
或
func main(){
    //简略赋值声明多个(变量只能定义一次)
    a,b:=10,"lqz"
    fmt.Println(a,b) //10 lqz
}
或
func main(){
    //go是强类型语言(类型一旦确定，不能改变)
    var a int
    a = 11
    a = "test"
    fmt.Println(a)  //报错，int改为了string
}

八、变量类型

package main
import "fmt"

func main() {
    //布尔
    //var a bool =true
    //fmt.Println(a)
    //数字类型
    //var a int8=100
    //范围2的7次方-1
    //计算机最小单位：bit
    //字节：8个比特位
    //fmt.Println(a)
    //类型推导：
    //a:=10     //int  在32位机器上是int32 在64位机器是int64
    //var a uint64=10   //只表示正整数
    //可以表示小数
    //var a float32=19.08
    //fmt.Println(a)
    //byte:uint8的别名
    //var a byte =-10
    //rune: int32的别名
    //字符串(双引号)
    var a string ="lqz"
    fmt.Println(a)
}

九、常量

常量用来表示固定的值，不变的量

// 定义方法
package main

func main() {
    //定义常量
    //const关键字 变量名  = 变量值
    const age  = 10
    const  name = "lqz"
    //name="egon"
    const  name, age = "lqz",18
    //var  a,b  = "lqz",10
}

十、函数

语法：
//func关键字 函数名（变量 变量类型，变量 变量类型）{
// }

// 1)位置传参
package main
import "fmt"

func main() {
    // 没有指定道姓传参，只能按位置传参
    test(1,2)
}

func test(a,b int) {
    fmt.Println(a+b)
}

// 2)返回值
//func关键字 函数名（变量 变量类型，变量 变量类型）返回值类型{}
func main() {
    // 返回值接收
    c :=test(1,2)
    fmt.Println(c)
}

func test(a,b int) int {
    return a+b
}

// 3)多返回值
func main() {
    // 返回值接收，必须是2个接收
    v,k:=test(1,2,"计算")
        // 如果有一个值不需要可以用_ 代替
    fmt.Println(v,k)
}

func test(a,b int,c string) (int,string) {
    return a+b,"计算成功"
}

// 4) 可变长传参
func main() {
    test(1,2,3)   //[1 2 3]  类似python中的列表，可切片

}
// ...可变长类型必须一样
func test(a ...int) {
    fmt.Println(a)
        fmt.Print(a[0])
}

十一、闭包

// 闭包:1.定义在函数内部；2.对外部作用于有引用
// 补充： 匿名函数 func (参数)(返回值){}

// 推导解释
func test()(func()(int,string)){
    a:=10
    // 匿名函数:省略函数名字,变灰的意思是可以省略
       //当成变量返回
    //var b func()(int)=func ()(int){
    //    fmt.Println(a)
    //    return 1
    //}
    b:= func()(int,string) {
        fmt.Println(a)
        return 1,";xxxx"
    }
    return b
}
//
// func(d int)(int) 返回值
func test()(func(d int)(int),int){
    c:=func (d int)(int){
        fmt.Println("xxxx")
        return 1
    }
    return c,1
}

// 整体
func main() {
    k:=test(3)
    k(5)
}

// func(d int)(int) 返回值
func test(c int)(func(d int)()){
    a:=func (d int){
        fmt.Println(d+c)
    }
    return a
}

// 默认返回值
func test()( a,b int)  {
    return a,b
}
// int默认空值是0,string类型默认空值是""一行空

函数格式：func 名字(参数1 类型，参数2 类型)（返回类型，返回类型）{}

十二、包管理

导入别的包：(与自己的包目录级别一样)
有严格的路径模式，如果是下载的模块放到了GoPath路径下

package main
import "mypackage"

func main() {
   mypackage.Test()
}

十三、if...else..

package main
import "fmt"

func main() {
    a:=11;
    //大括号必须和条件在一行
    if a<10{
        fmt.Println("<10");
    }else if a>10{
        fmt.Println(">10");
    }else {
        fmt.Println("10")
    }
}

package main
import "fmt"

func main() {
   a:=11;
   //大括号必须和条件在一行
   if a<10{
      fmt.Println("<10");
   }else if a>10{
      fmt.Println(">10");
   }else {
      fmt.Println("10")
   }
}

注意：条件和{必须在一行

十四、for循环(GO中只有这种)

// 语法
////for 循环
//for 第一部分;第二部分;第三部分{
//}
func main(){
        //基本写法
    for i:=0;i<100;i++{
        fmt.Println(i)
    }

}
//其他用法1 省略第一部分
i:=0
for ;i<100;i++{
    fmt.Println(i)
}
//其他用法二 省略第三部分
i:=0
for ;i<100;{
    i=i+1
    fmt.Println(i)
}
//其他用法三 省略第二部分
for ;;{
    fmt.Println("xxx")
}
//更多使用
//for a<10  表示写在第二个位置
a:=0
for a<10{
    fmt.Println(a)
}
//死循环
for {
    fmt.Println("xxx")
    break //不加这个就不会跳出
}
//break 和continue
for i:=0;i<10 ;  i++{
    if i==5{
        //continue
        break
    }
    fmt.Println(i)
}

十五、switch...case条件语句

package main
import "fmt"
//单条件
func main() {
    a := 5
    switch a {
    case 1:
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    case 4:
        fmt.Println("4")
        default:
                fmt.Println("不匹配")
    }
}
//多条件
    a := 4
    switch a {
    case 1,2:
        fmt.Println("1")
    case 3,6:
        fmt.Println("2")
    default:
        fmt.Println("不匹配")
    case 4:
        fmt.Println("4")
    }

//fallthrough 穿透:直接打印下一条
    a := 4
    switch a {
    case 1, 2:
        fmt.Println("1")
    case 3, 6:
        fmt.Println("2")
    case 4:
        fmt.Println("4")
        fallthrough //穿透
    case 5:
        fmt.Println("5")
        fallthrough
    default:
        fmt.Println("不匹配")
        fmt.Println("xxxxx")

    }
 //fallthrough 结果：
4
5
不匹配
xxxxx

十六、数组

package main
import "fmt"

func main() {
    //基本定义/定义并初始化
    //a[3]int:a数组的长度为3，数组内的类型都为int
    //var a [3]int=[3]int{1,2,3}
    //var a =[3]int{1,2,3}
    a:=[3]int{1,2,3}
    fmt.Println(a)
}
--------------------------------------------------------------------------------
//指定位置初始化
a:=[10]string{9:"lqz",8:"xxx"}
fmt.Println(a)
//结果[        xxx lqz]

//数组使用
var a [3]int=[3]int{1,2,3}
//--修改第0个位置的值
a[0]=100
var b int=a[2]  //赋值成变量
fmt.Println(a)
//结果：[100 2 3]

//数组的长度，开始可以忽略
// ... 的使用(少用)
a :=[...]int{9:1}  // 第九个位置赋值为1
fmt.Println(a)  //[0 0 0 0 0 0 0 0 0 1]
fmt.Println(len(a))   //10

//数组的大小是类型的一部分：参数和返回值都是类型的一部分
a:=[3]int{1,2,3}
b:=[3]int{1,2,3}  //长度必须是一样，类型必须一样
b=a
fmt.Println(b)

//函数
a:=[3]int{1,2,3}
fmt.Println(a)
test(a)
fmt.Println(a)
//test(a)放在main外调用
func test(a [3]int)  {
    a[1]=1000
    fmt.Println(a)
}
//结果：
[1 2 3]
[1 1000 3]
[1 2 3]
-------------------------------------------------------------------------------
//数组迭代
a:=[3]int{1,2,3}
for i:=0;i<len(a);i++{
    fmt.Println(a[i])
}
//第二种方式(常见)
//range :python中range函数
// 关键字
//range 可迭代   如果用一个值接收：就是索引  如果用两个值接收：就是索引和值
for i,v:=range a{
    //fmt.Println(i)
    fmt.Println(a[i])
    fmt.Println(v)
}
--------------------------------------------------------------------------------
//多维数组
//定义一个二位数组
var a [5][3]int=[5][3]int{{1,2,3},{4,4,4}}
fmt.Println(a)
//结果：[[1 2 3] [4 4 4] [0 0 0] [0 0 0] [0 0 0]]
修改：var a [5][3]int=[5][3]int{2:{4,4,4}}
//循环
for i := 0; i < len(a); i++ {
    for j := 0; j < len(a[i]); j++ {
        fmt.Println(a[i][j])
    }
}
for _,v:=range a{
    for _,v1:=range v{
        fmt.Println(v1)
    }
}

十七、切片

解决数组追加值

package main
import "fmt"

func main() {
    //切片定义
    //切片底层基于数组
    a:=[9]int{1,2,43}
    fmt.Println(a) //[1 2 43 0 0 0 0 0 0]
    b:=a[1:3]
    fmt.Println(b)  //[2 43]
    //b[0]=100
    a[1]=999
    fmt.Println(b)   //[999 43]
    fmt.Println(a)   //[1 999 43 0 0 0 0 0 0]
}

package main
import "fmt"

func main(){
    a:=[5]int{1,2,43,0,0}
    b:=a[1:3]
    fmt.Println(b)  //[2 43]
    fmt.Println(len(b)) //2
    //切片追加值
        b=append(b,10)
    b=append(b,11)
    b=append(b,12)
    fmt.Println(b)  //[2 43 10 11 12]

}

# 查看切片容量
//查看切片的容量/长度
a:=[5]int{1,2,43,0,0}
b:=a[1:3]
fmt.Println(len(b))   //2
////查看容量
fmt.Println(cap(b))   //4
b=append(b,10)
b=append(b,11)
b=append(b,12)
fmt.Println(len(b))  //5
//查看容量（容量如果不够了，每次都会翻倍）
fmt.Println(cap(b)) //8

//切片第二种定义方式 中括号内不写东西，就是切片类型
//切片的空是nil
//通过make函数来完成初始化  第一个5是长度，第二个5是容量
func main(){
    var a []int=make([]int,5,5)
    if a==nil{
    fmt.Println("xxxx")
    }
    fmt.Println(len(a))  //5
    fmt.Println(cap(a)) //5
}

//切片是什么类型  是引用类型
    var a []int=make([]int,5,5)
    fmt.Println(a)  //[0 0 0 0 0]
    test(a)  //[999 0 0 0 0]
    fmt.Println(a)  //[999 0 0 0 0]

# test()
func test(a []int)  {
    a[0]=999
    fmt.Println(a)
}

//内存优化，copy函数
a:=[10000]int{1,2,3,4,5,}
b:=a[0:3]
fmt.Println(b)  //[1 2 3]
var c []int=make([]int,2,2)
copy(c,b)
fmt.Println(c)  //[1 2]

https://www.cnblogs.com/xiaoyuanqujing/p/11681169.html