go

一 go 语言介绍

1 认识go 

•  go语言（或 Golang）是Google在 2007 年开发的一种开源编程语言，于2009年11月开源，2012年发布go稳定版
•  go是非常年轻的一门语言，它的主要目标是“兼具Python 等动态语言的开发速度和C/C++等编译型语言的性能与安全性”

2 go 的诞生

l  Robert：曾协助制作Java的HotSport编译器，制作了chrome浏览器的js引擎V8

l  Rob：google首席科学家，与ken共事多年，创出广泛实用的UTF-8编码

l  Ken：1966年加入贝尔实验室，1983年图灵奖和美国国家技术奖得主，是Unix的原创者，发明了衍生出C和B语言。

3 go 的优势

•   做高并发有巨大的优势
•   开发简单，开发效率堪比python
•   运行效率高，很适合用作中央服务器的系统编程语言
•   是项目转型的首选语言，很多公司在用go重构代码
•   提供了海量并行的支持，很适合处理游戏相关数据

4 使用go的公司

    Google
    https://github.com/kubernetes/kubernetes
    Facebook
    https://github.com/facebookgo
    腾讯
    百度
    360开源日志系统
    https://github.com/Qihoo360/poseidon

 5 go适合做什么

•   服务端开发
•   分布式系统
•   网络编程
•   区块链开发
•   内存KV数据库，例如boltDB、levelDB
•   云平台，docker就是用go写的

二、环境安装

1.      下载SDK

•  官网：https://golang.google.cn/
•  go中文在线文档：https://studygolang.com/pkgdoc

2.      安装和配置SDK

•   windows使用.msi一键安装
•   配置环境变量
  •   GOROOT，自动的，默认将go安装到C:/go
  •   GOPATH，自定义的位置，理解为存放go代码的位置

新增系统环境变量

•  创建并配置好GOPATH后，GOPATH目录还要创建3个子目录

3  SDK目录介绍

4  安装开发工具

  安装，双击安装

 

 

破解文件替换---》 将.jar文件复制到工具安装的bin目录下

  用记事本打开“goland.exe.vmoptions”和“goland64.exe.vmoptions”这两个文件，在后面添加破解文件的路径

  打开开发工具

找寻破解码，拷贝进去

三 第一个GO 程序

1 编写go源文件

package main

import "fmt"

func main(){
    fmt.Println("Go Lang，去浪吧，骚年！")
}

结果为

2   代码分析

// go单行注释，与java和C++一样
/*
   多行注释
*/
//每个go源代码开头是package声明，表示所属的包
//main代表可编译成二进制文件
package main

//导入格式化包，不用时会报错
import "fmt"

//main()主函数入口，不能带参数，不能定义返回值
//func声明函数的关键字
//前边大括号不能单起一行
func main() {
   fmt.Println("Go Lang，去浪吧，骚年！")
}

3 IDE 编写

特点：自动导包，没有引用的包，会自动删掉。

四  基础语法

1 命名

•  go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则
•   一个名字必须以一个字母或下划线开头，后面可以跟任意数量的字母、数字或下划线
•  go区分大小写，hello Hello不同
•   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

•   还有30多个预定义的名字，用于内建的常量、类型和函数

内建常量:
    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

2 变量

•   变量声明

•   变量初始化

•   变量赋值

•   匿名变量

　　  _代表特殊的变量名，作用是占位，不用于输出和打印

3   常量与枚举

•  声明常量
•  iota常量生成器
•  枚举类型

package main

import "fmt"

// const：声明常量
const filename = "abcd.txt"

func consts() {
   const (
      filename = "abc.txt"
      a, b     = 3, 4
   )
   //就近原则
   fmt.Println(filename)
}

//定义枚举类
func enums() {
   const (
      python = 0
      golang = 1
      java   = 2
   )
   fmt.Println(python, golang, java)
}

//iota生成器
func enums2() {
   const (
      python = iota
      golang
      java
   )
   fmt.Println(python, golang, java)
}

//iota参与运算
func enums3() {
   const (
      // 1 << 0
      // 1 * 2^0
      b  = 1 << (10 * iota)
      kb
      mb
      gb
      tb
      pb
   )
   fmt.Println(b, kb, mb, gb, tb, pb)
}

func main() {
   enums3()
}

 4 基本数据类型

•  带u是无符号
•  byte short int long

•   整型

• 浮点型

• 布尔型

• byte字符型

• 字符串

 

5   fmt包的使用

•  格式说明

•  输出

• 输入 Scan

 

6  类型别名

7  类型转换

•  go 必须显示转换

8  运算符

•   算术运算符

•   关系运算符

 

•   逻辑运算符（与，或，非）

五 流程控制

1 选择结构

•   if else语句

package main

import (
   "io/ioutil"
   "fmt"
)

func main() {
   const filename = "abc.txt"
   //读文件
   contents, err := ioutil.ReadFile(filename)
   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Printf("%s
", contents)
   }

   // if也支持如下写法
   if contents, err := ioutil.ReadFile(filename); err != nil {
      fmt.Println(err)
   } else {
      fmt.Printf("%s
", contents)
   }
}

• switch 语句
  • 　每一个的等级自动break
  •    如果想要程序执行到下一个等级，使用 ` fallthrough `

package main

import "fmt"

//传入成绩，返回评分等级
func grade(score int) string {
   // 定义字符串
   g := ""
   // go语言switch自动每一句加了break
   switch {
   case score < 0 || score > 100:
      g = "输入错误"
   case score < 60:
      g = "F"
      fallthrough
   case score < 80:
      g = "C"
   case score < 90:
      g = "B"
   case score <= 100:
      g = "A"
   }
default:   XXX
   return g
}
//F F C B A A 输入错误
func main() {
   fmt.Println(
      grade(0),
      grade(59),
      grade(60),
      grade(82),
      grade(99),
      grade(100),
      grade(-3),
   )
}

2 循环结构

• for

package main

import (
   "fmt"
   "time"
)

// 死循环
func for1() {
   //写法简单
   for {
      fmt.Println("日耳曼战车凉凉")
      // 睡1秒
      time.Sleep(1 * time.Second)
   }
}

//有次数的循环
func for2() {
   for i := 1; i < 11; i++ {
      fmt.Println("日耳曼战车凉凉", i)
      //睡500毫秒
      time.Sleep(500 * time.Millisecond)
   }
}

//有次数的循环
func for3() {
   for i := 1; i < 11; i++ {
      if i%5 == 0 {
         fmt.Println("爱阿根廷")
      } else if i%2 == 1 {
         fmt.Println("更爱战车")
      } else {
         fmt.Println("更爱是天台")
      }
      time.Sleep(500 * time.Millisecond)
   }
}

func main() {
   for3()
}

• range
  • 　　用于遍历可迭代对象

package main

import "fmt"

func main() {
   s := "abc"
   //接收下标，通过下标取值
   for i := range s {
      fmt.Printf("下标=%d，值=%c
", i, s[i])
   }
   //直接都接收到
   for i, c := range s {
      fmt.Printf("下标=%d，值=%c
", i, c)
   }

   for _, c := range s {
      fmt.Printf("值=%c
", c)
   }
}

3 调转语句

•   break和continue

 

•    goto  

　　　 跳转到标识符语句位置。

　　　 跳转后不会返回到原语句。

六 函数

1 自定义函数

•   函数声明格式：
•   方法名首字母大写是public，方法名首字母小写是private

func 函数名( [参数列表] ) [返回值列表] {
   函数体
}

•  无参无返回值

• 有参数无返回值

•  有不定参数无返回值

•   无参有返回值

•    有参有返回值

•   练习：分别通过循环和递归函数，计算1+2+3……+100

package main

import "fmt"

// 循环实现1到100累加
func Test01() int {
   sum := 0
   for i := 1; i <= 100; i++ {
      sum += i
   }
   return sum
}

//递归实现
//传100
func Test02(num int) int {
   if num == 1 {
      return 1
   }
   return num + Test02(num-1)
}

func main() {
   fmt.Println(Test01())
   fmt.Println(Test02(100))
}

2   defer关键字

•   defer⽤于延迟一个函数或者方法的执行
•   defer语句经常被用于处理成对的操作，如打开、关闭、连接、断开连接、加锁、释放锁
•   通过defer机制，不论函数逻辑多复杂，都能保证在任何执行路径下，资源被释放
•   释放资源的defer应该直接跟在请求资源的语句后，以免忘记释放资源

3 多个defer 执行顺序（栈）

package main

import "fmt"

func test(x int) {
   fmt.Println(100 / x)
}

func main() {
   //defer是延迟操作
   defer fmt.Println("aaaa")
   defer fmt.Println("bbbb")
   //报错并不影响程序运行
   defer test(0)
   defer fmt.Println("cccc")
}