GO_学习

Beego是一个完全的MVC框架，你可以使用你的Go语言专业技术构建你的web应用程序。Beego框架下，你可以
自动化地实现测试、打包和部署。
Revel能让Go语言的web开发如虎添翼，大大提高你的开发效率。
Martini是一个受到Sinatra (一个Ruby 框架)启发而开发的Go语言web框架。使用Martini，你可以快速写你的模块化应用或者服务。

JetBrains 的 Go 开发工具 Gogland
内网穿透工具 frp
极易搭建的自助 Git 服务 Gogs
实时消息通信平台 Centrifugo
Go Web API 利器 Faygo
分布式RPC服务框架 rpcx

 

Go下载安装
下载Go语言
配置6项环境变量：GOROOT/ Go的安装位置，如E:\Go
GOBIN/ 表示编译器和链接器的安装位置
GOARCH/ 表示目标机器的处理器架构
GOOS/ 表示目标机器操作系统
GOMAXPROCS/ 设置应用程序可使用的处理器个数与核数
GOPATH 设置GO项目源代码和二进制文件的目录
cmd go 测试是否安装成功
GoLand idea

go语言目录结构介绍
src:存放源代码
pkg:编译后生成的文件
bin:编译后生成的可执行文件

Go基础语法
关键字-标识符-注解-基础结构
Go中保留关键字只有25个如下：
break、 default、 func interface select
case、 defer、 go、 map、 struc
chan、 else、 goto、 package、 switch
const、 fallthrough、 if、 range、 type
continue、 for、 import、 return、 var

Go中36个预定标识符，包括了基础数据类型和系统内嵌函数如下：
append、 bool、 byte、 cap、 close、 complex
complex64、 complex128、 uint16、 copy、 false、 float32
float64、 imag、 int、 int8、 int16、 uint32
int32、 int64、 iota、 len、 make、 new
nil、 panic、 uint46、 print、 println、 real
recover、 string、 TRUE、 uint、 uint8、 uintprt
//
/* */

//基础结构：1
package main

import (
"fmt" //知道函数名就行，会自动引入
)

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

//基础结构：2
package main

import (
"fmt"
)

const name string ="凯哥"//main外全局变量
var age float32= 24

func main() {
var a,b,c= 1,2,3//多变量
var ( //多变量
aa int =3
aaa string="qq"
)
//全局变量的声明必须使用var关键词
gg:= "邯郸" //:=定义变量，并给变量赋值，可以省略 var 关键字
var gao = 174 //Go 会自动检测变量的类型

fmt.Println("Hello World"+"王路凯")
fmt.Println(age)
fmt.Println(name)
fmt.Println(a,b,c)
fmt.Println(aa,aaa)
fmt.Println(gg)
fmt.Println(gao)
}

//基础结构：3
package main
import "fmt"
//常量
const Name string = ""
//变量
var imooc string =""
//一般类型声明
type imoocInt int
//结构声明
type L struct{

}
//接口声明
type J interface{

}
//函数声明
func H(){
fmt.Println("嗨：")
}
//程序入口
func main(){
H()
fmt.Println("小凯")
}
package要生成GO语言可执行程序，必须要有main的package包，必须在该包下有main()函数
import不得导入代码中没用到的package,否则会报错,
import两种引用方式
import别名,".","_"

Go数据类型:Go中只有UTF-8
数值类型，字符串类型和布尔型
uint8 无符号整型
float32
type
boolean 常量：true/false
int32占4个字节，一个字节8位，计算机最小存储单位是位, win32是4个字节，win64是8个字节
unsefe.Sizeof():数据类型所占大小，
reflect.TypoOf():变量是什么类型
len()：长度
派生类型
Pointer 指针类型
数组类型
struct 结构化类型
chan Channel类型
func 函数类型
slice 切片类型
interface 接口类型
map Map类型
类型零值和类型别名
类型零值：是某个变量声明后的默认值,
值类型默认值是:0
布尔型默认值是:false
string默认值是:空字符串
类型别名：可以对类型设置别名
类型多占存储大小
int32占4个字节，一个字节占8位，计算机最小存储单位是位, win32是4个字节，win64是8个字节
Go变量与常量
变量声明，初始化与赋值
声明：var <变量名称> [变量类型]
赋值：<变量名称> = <值，表达式，函数等>
同时声明和赋值 var <变量名称> [变量类型] = <值，表达式，函数等>
分组声明
var(
i int
j float32
name string
)
var a,b,c int = 1,2,3
全局变量的声明必须使用var关键词
特殊变量下划线 “_”
变量的类型转换
Go中不存在隐式转换，类型转化必须是显示的
类型转换只能发生在两种兼容类型之间
//冒号可有可无
类型转换格式：<变量名称> [:]= <目标类型> (<需要转换的变量>)
变量可见性规则
大写字母开头的变量是可导出的，就是其他包可以读取的，是公用变量；
小写字母开头的就是不可导出的，是私有变量；
常量，常量声明和iota的使用
const a int = 1 显式
const a = 1 隐式
常量可以使用内置表达式定义，如：len(),unsafe.Sizeof等
常量支持范围：布尔、整型、浮点型、复数、字符串，
不支持派生类型!

iota在const关键字出现时将被重置为0
const中每新增一行常量声明将使iota计数一次
使用发：跳值、插队、表达式隐式、单行
Go运算符
算数运算符
+、-、*、/、%、++、--
关系运算符
==、 !=、 >、 <、 >=、 <=
逻辑运算符
&&、 ||、 !
按位运算符
&、 |、 ^、 <<、 >>
赋值运算符
=、 +=、 -=、 *=、 /=、 %=、 <<=、 >>=、 &=、 ^=、 |=

Go控制语句
条件语句if、if_else、嵌套if_else_if

选择语句switch、select
switch 3{
case 1:
fmt.Println(1)
case 2:
fmt.Println(2)
default:
fmt.Println("以上都不满足")
}

var a interface{}
a = ""
switch a.(type){
case int:
fmt.Println("类型为整型")
case string:
fmt.Println("类型为字符串")
default:
fmt.Println("以上都不满足")
}

循环语句for
for{
fmt.Println("慕课网")
}

for i:=1;i<10;i++{
fmt.Println("慕课网")
time.Sleep(1*time.Second)//1秒停止一次

}

//for的foreach效果
a:= []string{"香蕉","苹果","雪梨"}
for key,value:=range a{//key可替换为_,因为如果key不调用的话会报错，
fmt.Println("key的值为：",key)
fmt.Println("value的值为：",value)
}

控制语句中使用到的关键字goto、break、continue

goto:跳到指定代码块
goto a
fmt.Println("0")
a:
fmt.Println("1")

fmt.Println("0")
e:
fmt.Println("1")
goto e

break:跳出当前代码块
for i:=1;i<=3;i++{
for j:=1;j<=2 ;j++ {
fmt.Println("慕课网")
time.Sleep(1*time.Second)
break
}
}
continue:跳出、继续
for i:=1;i<=3 ;i++ {
if i>=3{
fmt.Println(i)
continue
}
fmt.Println(i)
fmt.Println("慕课网")
}

只是大致认知，还不算入门！！！

 ------------------------------------------

 

 

函数

  函数构成代码执行的逻辑结构。在Go语言中，函数的基本组成为：关键字func、函数 名、参数列表、返回值、函数体和返回语句。

 

  

 

工程管理

  Go代码必须放在工作区中。工作区其实就是一个对应于特定工程的目录，它应包含3个子目录：src目录、pkg目录和bin目录。

 

 

 

复合类型（派生类型）

指针pointer

 

数组array

 

切片slice: 引用类型

 

map： 引用类型

 

结构体struct

 

 

面向对象编程

对于面向对象编程的支持Go 语言设计得非常简洁而优雅。因为， Go语言并没有沿袭传统面向对象编程中的诸多概念，比如继承(不支持继承，尽管匿名字段的内存布局和行为类似继承，但它并不是继承)、虚函数、构造函数和析构函数、隐藏的this指针等。

 

尽管Go语言中没有封装、继承、多态这些概念，但同样通过别的方式实现这些特性：

l  封装：通过方法实现

l  继承：通过匿名字段实现

l  多态：通过接口实现

 

 

并发编程

 并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。

 

 

有人把Go比作21世纪的C语言，第一是因为Go语言设计简单，第二，21世纪最重要的就是并行程序设计，而Go从语言层面就支持了并行。同时，并发程序的内存管理有时候是非常复杂的，而Go语言提供了自动垃圾回收机制。

 

Go语言为并发编程而内置的上层API基于CSP(communicating sequential processes, 顺序通信进程)模型。这就意味着显式锁都是可以避免的，因为Go语言通过相册安全的通道发送和接受数据以实现同步，这大大地简化了并发程序的编写。

 

 

网络编程

  网络协议

分层模型

Socket编程

HTTP编程