Python下自带的Socket的模块是阻塞型的,每次只能处理一个连接,给应用造成了极大的不便,幸好有Gevent这个基于 协程的网络库,来使默认的Socket支持并发。

代码如下:

#coding=utf-8
from gevent import monkey; monkey.patch_all() //猴子魔法[1]
import socket
import gevent

def server_req(conn):
        while True:
                data = conn.recv(1024) #等待传入数据
                if not data:
                        conn.close() #关闭连接
                        break
                print('recv:%s'%data)
                conn.send(data) #发送数据

def server_mian(s_addr,s_port):
        s = socket.socket()
        s.bind((s_addr,s_port)) #绑定端口
        s.listen(500) #最大连接数
        while True:
                cli,addr = s.accept() #等待一个客户
                gevent.spawn(server_req,cli) #创建一个协程,将客户传入server_req函数

if __name__ == '__main__':
    server_mian('0.0.0.0',3000)

[1]猴子魔法(Monkey Patch):https://www.gevent.org/api/gevent.monkey.html

条件语句

if 语句

用法

if 条件 {
     //当条件为真时执行
}

if 条件 {
     //当条件为真时执行
} else {
     //当条件为假时执行
}

if 条件 {
     //当条件为真时执行
} else if 条件2 {
     //当条件2为真时执行
} else {
     //全部不满足时执行
}

特点

  1. if后的条件不需要用小括号括起来
  2. {必须放在行末,与if或if else放在一行
  3. if后可带一个简单的初始化语句,并以分号分割,所声明变量的作用域为整个if语句块(包括后面的分支)
  4. Go语言没有条件运算符
  5. 遇到return后直接返回,遇到break则跳过break下方的if语句块

编程哲学

  1. 尽量减少条件语句的复杂度,如果条件语句太多,太复杂,则建议放到函数里封装起来
  2. 尽量减少if语句的嵌套层次,通过重构代码来使代码变得扁平,便于阅读

switch 语句

用法

switch {
     case 条件:
         //执行语句
     case 条件:
         //执行语句
     default:
         //所有条件不满足时执行
}

特点

  1. 同if一样,switch后可带一个简单的初始化语句
  2. switch后的表达式也是可选的,如果没有表达式,则case的子句是一个布尔表达式,而不是一个值,就像多重if...else...语句
  3. switch可以任意支持相等比较运算的类型变量
  4. 通过fallthough来强制执行下一个case子句(不判断下一case分支的条件)
  5. switch支持default语句,当所有条件不支持时执行default中的语句,default的位置不影响switch的判断逻辑
  6. switch和.(type)结合可以进行类型的查询(这个以后会学到)

循环语句

for 语句

Go语言只有一个循环语句——for

用法

//1.类似C中的for语句
for init;condition;post { }
//2.类似C中的while语句
for condition { }
//3.死循环
for { }
//for也可以对数组,切片,字符串,map和通道的访问

标签与跳转

Go使用标签来标识一个语句的位置,用于goto,break,continue语句的跳转。

标签

Lable: Statement

goto

goto用来跳转到函数内指定的标签

goto Lable

特点

  1. 只能在函数内跳转
  2. goto不能跳过内部变量声明语句
  3. goto只能跳转到同级作用域或上层作用域内,不能跳转到内部作用域

break

break用于函数内跳出for,switch,select语句的执行,有两种使用格式:

  1. 单独使用,用于跳出break当前所在的for,switch,select语句的执行
  2. 和标签一起使用,用于跳出标签所标识的for,switch,select语句的执行,可用于跳出多重循环,但标签与break必须在同一个函数内

continue

continue用于跳出for循环的本次迭代,跳到for循环下一次迭代的post语句执行,也有两种使用格式:

  1. 单独使用,用于跳出continue当前所在的for循环的本次迭代
  2. 和标签一起使用,用于跳出标签所标识的for语句的本次迭代,但标签与continue必须在同一个函数内

Nginx做文件服务器时,需要显示目录结构,由于安全性的原因,Nginx默认是不开启的,所以下面来人工打开它。

配置

打开你的站点配置文件加入(一般在/etc/nginx/sites-enabled中):

autoindex on;
autoindex_exact_size off;
autoindex_localtime on;
\autoindex_exact_sizeautoindex_localtime
on显示出文件的确切大小,单位为bytes显示的文件时间为文件的服务器时间
off显示出文件的大概大小,单位为kB或MB或GB显示的文件时间为GMT时间

乱码解决

配置完成后我们打开站点,发现中文显示乱码,在配置文件中加入一行即可:

charset utf-8,gbk;

指定目录显示

很多时候我们只需要某个目录暴露出来,这时我们需要定义一个段,下面以站点目录的video为例:

location /video {
        autoindex on;
        autoindex_exact_size off;
        autoindex_localtime on;
        charset utf-8,gbk;
}

切片

在Go中由于数组的定长性和值拷贝的特性限制了数组的使用场景,使用Go提供了另外一种数据类型slice(切片),这是一种变长数组。

声明

//由make创建
SliceName := make([]Type,Len,Cap)  //可不填写Cap,但会使Cap=Len
//由数组创建
ArrayName := [...]Type{value1,value2,value3}
SliceName := Array[b,e]  //b:开始索引 e:结束索引 都可不指定
//直接声明切片类型变量是没有意义的
var a []int  //打印结果:[]
//此时array=nil,len=0,cap=0

切片的操作

操作

//长度
len(Slice)
//底层数组容量
cap(Slice)
//添加元素
append(Slice,Value)
//复制切片
copy(Slice1,Slice2)

例子

package main
import "fmt"

func PrintSliceInfo(s1,s2 []int){
        fmt.Println("--------------")
        fmt.Println("s1:",s1)
        fmt.Println("s2:",s2)
        fmt.Println("s1 cap:",cap(s1))
        fmt.Println("s2 cap:",cap(s2))
        fmt.Println("s1 len:",len(s1))
        fmt.Println("s2 len:",len(s2))
        fmt.Println("--------------")
}
func main(){
        a := [...]int{0,1,2,3,4,5}
        s1 := make([]int,3,6)
        s2 := a[3:]
        PrintSliceInfo(s1,s2)
        s1 = append(s1,23)
        s2 = append(s2,233)
        PrintSliceInfo(s1,s2)
        s3 := make([]int,3,4)
        copy(s3,s2)
        fmt.Println("--------------")
        fmt.Println("s3:",s3)
        fmt.Println("s3 len:",len(s3))
        fmt.Println("s3 cap:",cap(s3))
        fmt.Println("--------------")
}
//打印结果
--------------
s1: [0 0 0]
s2: [3 4 5]
s1 cap: 6
s2 cap: 3
s1 len: 3
s2 len: 3
--------------
--------------
s1: [0 0 0 23]
s2: [3 4 5 233]
s1 cap: 6
s2 cap: 8
s1 len: 4
s2 len: 4
--------------
--------------
s3: [3 4 5]
s3 len: 3
s3 cap: 4
--------------

字典

声明

//通过字面量创建
MapName := map[Type1]Type2{"key":value,"key2",value2}
//通过Make创建
MapName := make(map[Type1]Type2)

用法

//添加与更新,访问一个键
MapName[key] = value
value := MapName[key]
//删除
delete(MapName,key)
//长度
len(MapName)
//迭代
for key,value := range MapName{
    //code
    fmt.Println("key=",key,"value=",value)
}

注意

  1. Go内置的Map不是并发安全的,并发安全可以使用标准包sync中的map
  2. 不要直接修改map value中的某个元素的的值,如果需要修改,则必须整体重新赋值
  3. 可以使用range迭代,但不保证每次的迭代顺序相同

结构

Go中的struct(结构)与C类似。

声明

//通过字面量,这种方法用的较少
struct{
FeildName  FeildType
FeildName  FeildType
FeildName  FeildType
}
//通过自定义类型
type TypeName struct{
FeildName  FeildType
FeildName  FeildType
FeildName  FeildType
}

示例

type test struct{
Name String
Age int
}
//不推荐下面的方式来初始化
a := test{"test",23}
//建议使用下面的方法,避免新增字段导致报错,没有赋值的字段默认为零值
c := test{
Name:"test",
Age:23,
}

访问

Value := TypeName.FeildName

注意

  1. struct中的类型可以是任意类型
  2. struct的存储空间是连续的,其字段按照声明时的顺序存放(注意字段之间对齐!)

其他要说的

切片的原理

请务必看一下,了解切片的工作原理!
https://www.cnblogs.com/hutusheng/p/5492418.html

变量

声明

在Go中这样来声明变量:

var Name Type [ = value]  //不指定默认值,默认为零值
var Name = [ = value]
var (
a int = 0
b string = "test"
)

或这样简单的声明,这种方法只能用在函数(或方法)中:

Name := value  //自动判断类型
Name1,Name2 := value1,value2

变量类型与命名规则请看上一篇文章。

存储与生存期

Go语言提供自动内存管理,通常不需要特别关注变量的生存期和存放位置。Go使用了栈逃逸技术能为变量自动分配空间:可能在栈上,有可能在堆上。
关于栈逃逸技术:https://studygolang.com/articles/10026

类型转换

在Go中,不同于js之类的语言,不同类型的变量要类型转换:

TypeName(expression)  //expression:表达式或变量名

例:

var a int = 1
var b int8 = 2

a = b  //非法
a = int(b)

常量

常量中的内容不可改变:

const Name [ = value/iota]

例:

const (Name1 = iota  //Name1 = 0
       Name2  //Name2 = 1
)
//关于iota请看上一篇文章

指针

Go支持指针,也支持多级指针,指针的声明类型为T(多级:*T),在变量名前加&来获取地址:

var a = 233
b := &a
println(a)
println(b)
println(*b)
//值打印结果
233
0x11f3bfb4  //内存地址
233

又一个例子:

package main
func test(a,b int) *int {
    c := a * b  //c的作用域在函数内
    println(&c)
    return &c
}
func main() {
    p := test(2,3)
    println(p)
}
//打印结果
0x1233bfb8
0x1233bfb8
//Go编译器使用栈逃逸使这种局部变量空间分配到栈上。

由于Go的垃圾回收机制,所以Go不支持指针运算。

数组

声明

var Name [Size]type

例:

arr := [3]int{1,2,3}
arr2 := []int{1,2,3,4,5,6,7}  //自动判断长度
arr3 := [3]int{1:1,2:3}  //指定默认值,没有指定的使用类型默认值
arr4 := []int{1:2,6:4}  //指定判断长度,由最大决定

特性

  1. 数组一旦创建就固定了,不能再追加元素
  2. 数组是值类型的,数组赋值或做为函数参数都是值拷贝
  3. 数组长度是数组的组成部分,[10]int != [20]int
  4. 可根据数组创建切片

元素访问

a := [...]int{1,2,3}
for index,value := range a {
    fmt.Println(value)
}

数组长度

len(Name)

range

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值,在集合中返回 key-value 对的 key 值。

其他要说的

字符串运算

参考:

  1. https://blog.csdn.net/hatlonely/article/details/79156311
  2. https://www.cnblogs.com/yshyee/p/8810931.html

控制结构

啊?这么快就到for了?

标识符

标识符用来标示变量,类型,常量等语法对象的符号名称,在语法分析的时候作为一个token存在。(token会在文末解释)

Go 的关键字

Go只有25个关键字(当然,Go是一门极简的语言):

break  default  func  interface  select  case  defer  go  map  struch  chan  else  goto
package  switch  const  fallthrough  if  range  type  continue  for  import  return  var

数据类型与常量标识符

这些同样不可用作声明变量等:

数据类型

数值(16):
    整形(12):
        #int与uint的区别是有无符号,int(uint),int8(uint8)等的区别为bit数。
        byte  int  int8  int16  int32  int64
        uint  uint8  uint16  uint32 uint64 uintptr
    浮点(2):
        float32  float64
    复数(2):
        complex64  complex128
字符与字符串(2):
    string rune
接口型(1):
    error
布尔型(1):
    bool

常量

bool型: true false
常量计数器: iota
空: nil

空白标识符

声明匿名变量,占位标识等: _

标识符规则

标识符开头可以为“A-Z”,“a-z”以及“_”,标识符不能为纯数字(或数字开头),如以下例子:

aaaaa  //合法
aaaaa2  //合法
_aaaaa //合法
-aaaaa  //非法标识符
9aaaaa  //非法
_aaaaa2  //非法

运算符

Go语言有47个操作符,同样作为一个token存在:

算数运算符

+  -  *  /

位运算符

&  |  ^  &^  >>  <<

赋值与复核运算符

:=  =  +=  -=  *=  /=  %=  &=  |=  ^=  &^=  >>=  <<=

比较运算符

>  >=  <=  <  ==  !=

括号

(  )  {  }  [  ]

逻辑运算符

&&  ||  !

自增自减操作符

++  --

其他运算符

:  ,  ;  .  ...  <-

token

引用《Go语言核心编程》:

token是构成源程序的基本不可再分割的单元。编译器第一步就是将源程序分割为一个个独立的token,这个过程就是语法分析。Go语言的token可以分为关键字,标识符,操作符,分隔符和字面常量。

如下面个例子:

fmt.Printf("Hello World!\n")
这里有6个token
分别为:
fmt
.
Printf
(
"Hello World!\n"
)

iota

iota只能在常量表达式中使用,在枚举中应用广泛:

const (
a = iota
b
c
)
你可以试着打印这几个常量的值

9_0.png

其他要说的

运算符资料

  1. https://www.jb51.net/article/129776.htm
  2. https://studygolang.com/articles/12463

数据类型

  1. https://blog.csdn.net/qq_31179577/article/details/81486883

环境安装

在一般情况下,可以使用系统自带的包管理器来安装,不过版本肯定会老一些:

sudo apt-get install golang

也可以从 https://golang.google.cn/dl/ 下载最新的二进制包:

//截止目前最新为1.11.2,以Linux amd64为例
wget https://dl.google.com/go/go1.11.2.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.11.2.linux-amd64.tar.gz
//切换到用户目录,设置环境变量
cd && sudo vi .bashrc
//在末尾加入
PATH=$PATH:/usr/local/go/bin
//保存退出,更新环境变量
source .bashrc

Hello World

package main //包名
import "fmt" //标准输入输出包
func main() { //主函数
     fmt.Printf("Hello World!\n"); //这里也可以改成中文的“你好,世界”,因为环境默认utf-8
}

保存,输入go run Filename来运行。

root@ubuntu:~/go# go run t1.go
Hello World!

引用百科来简单介绍一下Go语言:

Go 是一个开源的编程语言,它能让构造简单、可靠且高效的软件变得容易。
Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发,后来还加入了Ian Lance Taylor, Russ Cox等人,并最终于2009年11月开源,在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的,并且拥有一个活跃的社区。

我什么要学习Go语言

  1. 支持编译
  2. 相比C、C++更简单一些
  3. 效率比脚本语言高

Go语言的特性

有一句叫“只做一件事,并且把它做好”

  1. 自动垃圾回收
  2. 更丰富的内置类型
  3. 函数多返回值
  4. 错误处理
  5. 匿名函数和闭包
  6. 类型和接口
  7. 并发编程
  8. 反射
  9. 语言交互性

重新开始

重新开始,从Hello World到应用,一点一点的学。

6_0.jpg