golang

简介 hflag 是被设计用来替代标准的 flag 库，提供更强大更灵活的命令行解析功能，相比标准库， hflag 有如下特点 支持可选参数和必选参数 支持参数缩写 支持位置参数，位置参数可以出现在任意位置 支持 bool 参数简写 ( -aux 和 -a -u -x 等效) 支持值参数缩写 ( -p123456 和 -p 123456 等效) 更多类型的支持，支持 net.IP ， time.Time ， time.Duration ， []int , []string 的解析 更友好的用法帮助 提供一套更简洁的 api 完全兼容 flag 接口 用法 hflag 提供两套 api ，一套完全兼容标准库的 flag 接口，另一套类似 python 的 argparse 先定义 flag ，在使用时从 flag 中获取 新接口 package main import ( "fmt" "github.com/hpifu/go-kit/hflag" ) func main() { hflag.AddFlag("int", "int flag", hflag.Required(), hflag.Shorthand("i"), hflag.Type("int"), hflag.DefaultValue("123")) hflag.AddFlag("str", "str flag",

flag 库实现了对命令行参数的解析 基本用法 package main import ( "fmt" "flag" ) func main() { b := flag.Bool("b", false, "bool flag") s := flag.String("s", "hello golang", "string flag") flag.Parse() fmt.Println("b is", *b) fmt.Println("s is", *s) } 上面代码指定了两个选项: bool 类型的 b 选项，默认值为 false ，帮助信息 bool flag string 类型的 s 选项，默认值为 hello golang ，帮助信息 string flag 执行 go run main.go 将输出 b 和 s 的值 b is false s is hello golang 执行 go run main.go -b -s "hello world" 将修改 b 和 s 的值 b is true s is hello world 执行 go run main.go -h 可以打印帮助信息 Usage of main: -b bool flag -s string string flag (default "hello golang") 命令行语法 -b -i 100 -f

1.编译main文件 　　因为开发环境是windows, 服务器是centOS, 交叉编译 　　SET CGO_ENABLED=0 　　SET GOOS=linux 　　SET GOARCH=amd64 　　go build 　　 2. Dockerfile以及构建镜像 　　 　　go-web是main文件编译后的二进制文件 　　　Dockerfile文件内容: 　　 　　构建镜像 　　 3. 运行 　　 　　 　　 　　运行成功 　　 　　 　　 来源： https://www.cnblogs.com/-xuzhankun/p/11951202.html

Import Advanced Go Programming 1.5 面向并发的内存模型 在早期，CPU都是以单核的形式顺序执行机器指令。Go语言的祖先C语言正是这种顺序编程语言的代表。顺序编程语言中的顺序是指：所有的指令都是以串行的方式执行，在相同的时刻有且仅有一个CPU在顺序执行程序的指令。 随着处理器技术的发展，单核时代以提升处理器频率来提高运行效率的方式遇到了瓶颈，目前各种主流的CPU频率基本被锁定在了3GHZ附近。单核CPU的发展的停滞，给多核CPU的发展带来了机遇。相应地，编程语言也开始逐步向并行化的方向发展。Go语言正是在多核和网络化的时代背景下诞生的原生支持并发的编程语言。 常见的并行编程有多种模型，主要有多线程、消息传递等。从理论上来看，多线程和基于消息的并发编程是等价的。由于多线程并发模型可以自然对应到多核的处理器，主流的操作系统因此也都提供了系统级的多线程支持，同时从概念上讲多线程似乎也更直观，因此多线程编程模型逐步被吸纳到主流的编程语言特性或语言扩展库中。而主流编程语言对基于消息的并发编程模型支持则相比较少，Erlang语言是支持基于消息传递并发编程模型的代表者，它的并发体之间不共享内存。Go语言是基于消息并发模型的集大成者，它将基于CSP模型的并发编程内置到了语言中，通过一个go关键字就可以轻易地启动一个Goroutine

package main import ( "os" "strings" "time" "fmt" "strconv" ) //耗时统计函数 func timeCost() func() { start := time.Now() return func() { tc := time.Since(start) fmt.Printf("time cost = %v\n", tc) } } func sum(n int, fd *os.File) { defer timeCost()() //注意，是对 timeCost()返回的函数进行调用，因此需要加两对小括号 for i:=1; i <= n; i++ { stri := strconv.Itoa(i) content := "写入的文件内容" + stri fd_time := time.Now().Format("2006-01-02 15:04:05") fd_content := strings.Join([]string{"======",fd_time,"=====",content,"\n"},"") buf := []byte(fd_content) fd.Write(buf) } } func main() { fd , _ := os.OpenFile("xyz2.txt",os.O_RDWR|os.O

1. 判断匹配和转义 // 判断在 b（s、r）中能否找到 pattern 所匹配的字符串 func Match(pattern string, b []byte) (matched bool, err error) func MatchString(pattern string, s string) (matched bool, err error) func MatchReader(pattern string, r io.RuneReader) (matched bool, err error) // 将 s 中的正则表达式元字符转义成普通字符。 func QuoteMeta(s string) string // 示例：MatchString、QuoteMeta func main() { pat := `(((abc.)def.)ghi)` src := `abc-def-ghi abc+def+ghi` fmt.Println(regexp.MatchString(pat, src)) // true <nil> fmt.Println(regexp.QuoteMeta(pat)) // \(\(\(abc\.\)def\.\)ghi\) } 　2. 编译 // Regexp 代表一个编译好的正则表达式，我们这里称之为正则对象。正则对象可以 // 在文本中查找匹配的内容

前言 在 Goroutines 并发模式（一） 中，我们简单地通过boring函数的例子来粗略地阐述了通过channels来和goroutines交流的方法。在本篇中，我将从pattern的方向出发，通过对boring函数的例子进行各种改写，来讲解几种常见了goroutines的并发模式。 并发模式 让我们先来回顾一下boring函数的例子。 func boring(msg string, c chan string) { for i := 0; ; i++ { c <- fmt.Sprintf("%s %d", msg, i) time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond) } } func main() { c := make(chan string) go boring("boring!", c) for i := 0; i < 5; i++ { fmt.Printf("You say: %q\n", <-c) } fmt.Println("You're boring; I'm leaving.") } 接下来，我会base于上面的这个例子，来介绍各种patterns。 生成器(Generator) 由于go中的channel也是一种变量，所以我们可以通过返回channel的方式来传递结果 func

Go 使用 channel 实现 CSP 模型。处理双方仅关注通道和数据本身，无需理会对方身份和数量，以此实现结构性解耦。在各文宣中都有 “Don't communicate by sharing memory, share memory by communicating.” 这类说法。但这并非鼓励我们不分场合，教条地使用 channel。 在我看来，channel 多数时候适用于结构层面，而非单个区域的数据处理。原话中 “communicate” 本就表明一种 “message-passing”，而非 “lock-free”。所以，它并非用来取代 mutex，各自有不同的使用场景。 有关 channel 实现方式，可参考《Go 学习笔记》第五版，下卷《源码剖析》。 从实现角度看，channel 算是一种很 “重” 的实现。在小粒度层面，其性能真算不得好。我们可用一个常见示例测试一下：用 channel 实现并发安全的计数器，或序号生成器。 性能测试结果表明，差异远比想的要大得多。单就此例而言，还可以用原子操作（atomic）进一步优化。 如果说 channel 适用于结构层面解耦，那么 mutex 则适合保护语句级别的数据安全。至于 atomic，虽然也可实现 lock-free 结构，但处理起来要复杂得多（比如 ABA 等问题），也未必就比 mutex 快很多。还有，sync

struct interface 就可以实现面向对象中的继承，封装，多态 继承的演示： Tsh类型继承People类型，并且使用People类型的方法 多态的演示 Tsh类型实现了接口Student，实现了接口定义的方法 完整代码： package main import "fmt" //父类型 type People struct { } func (p *People) echo() { fmt.Println("taoshihan") } //接口 type Student interface { Do() } //子类型，实现了接口，继承了父类型 type Tsh struct { People } func (t Tsh) Do() { fmt.Println("taoshihan do") } func main() { //继承的演示 t := Tsh{People{}} t.echo() //多态的演示 var student Student student = t student.Do() } 来源： https://www.cnblogs.com/taoshihan/p/11945876.html

go 很早就考虑了依赖管理的问题，内置 go get 命令，可以直接获取对应的依赖，非常方便，但是有一个巨大的缺陷，没有版本的维护和管理，而版本不一致可能会导致各种兼容性问题，因此出现了很多第三方依赖管理工具， dep 和 glide 就是其中的佼佼者，到了 go 1.11 官方终于推出了自己的依赖管理工具 mod ，并内置在 go 版本中， go mod 使用简单，功能强大，并且能自动兼容大多数之前的第三方工具，大量优秀的开源库都已经切换到了 go mod ，大有一统江湖之势 GO111MODULE 一个最大的变化是 golang 的项目终于不再依赖 $GOPATH 目录了，之前的项目由于 import 机制问题，所有项目都位于 $GOPATH/src 目录下，虽然也没有太大的问题，但总是让人感觉很怪，go 1.11 终于调整了这个问题，将代码从 $GOPATH 中迁出了，为了兼容之前研发模式，也仍然支持放到 $GOPATH 下，通过 GO111MODULE 环境变量控制 GO111MODULE=off : 关闭 mod，查找 vendor 目录和 $GOPATH 路径下的依赖 GO111MODULE=on : 开启 mod, 仅根据 go.mod 下载和查找依赖 GO111MODULE=auto : 默认值，在非 $GOPATH 路径并且包含 go.mod 的项目中才开启