您好,欢迎访问代理记账网站
移动应用 微信公众号 联系我们

咨询热线 -

电话 15988168888

联系客服
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

Golang 开发 常用的第三方库 没有最全只有更全

所有库名搜集自网络,侵删

golang 用于创建和发送电子邮件的库

douceur - HTML 邮件中的内联 CSS
email - 一个健壮的、灵活的 email 库
Go-dkim - DKIM 库,用于对 email 进行签名和验证
Go-imap - IMAP 库,用于客户端和服务器
Go-message - 用于触雷互联网消息格式和邮件的库
Gomail - Gomail 是一个非常简单且强大的库,用于发送电子邮件
Hectane - 轻量级 SMTP 客户端,提供 HTTP API
hermes - 一个用于生成干净、响应式 HTML e-mail 的包
MailHog - Email 及 SMTP 测试工具,具有 web 及 API 接口
SendGrid - SendGrid 的 Go 语言库,用于发送电子邮件
smtp - SMTP 服务器协议状态机

golang 处理日期和时间的库

carbon - 简单的时间扩展程序,有很多有用的方法,是 PHP Carbon 库的接口
durafmt - 持续时间格式化
feiertage - 一组计算德国公共假期的函数,比如复活节、感恩节等
Go-persian-calendar - 太阳历
Goweek - 处理星期的库
now - Now 是一个 Go 语言的时间工具集
NullTime -时间可以是 NULL 的库
timeutil - 为 Go 语言时间包扩展了有用的功能,例如时间间隔和格式化

数据库迁移

darwin - 数据库模式进化库
Go-fixtures - 类似 DjanGo fixtures,用于 Golang 的內建数据库/sql 库
Goose - 数据库迁移工具。你可以通过编写增量 SQL 或 Go 语言脚本来管理你的数据库
Gormigrate - 数据库模式迁移帮助工具,用于 Gorm ORM.
migrate - 数据库迁移。命令行及 Go 语言库
pravasan - 简单的迁移,目前支持 MySQL 但是近期打算支持 Postgres, SQLite, MonGoDB 等等
soda - 数据库迁移、创建、 ORM 等等,用于 MySQL, PostgreSQL, 以及 SQLite.
sql-migrate - 数据库迁移工具,允许利用 Go-bindata 将数据库迁移嵌入应用程序

Go 语言实现的数据库

BigCache - 为 gigabytes 量级数据设计的高效键/值缓存
bolt - 底层键值数据库
buntdb - 快速,可嵌入的,内存键值数据库,可定义索引及 spatial
cache2Go - 基于内存存储的键值缓存,支持自动基于超时的自动失效
cockroach - 可扩展的、一致的事务型数据库
couchcache - RESTful 缓存微服务,基于 Couchbase
dgraph - 可扩展的、分布式的、低延时、高吞吐的图数据库
diskv - 具有 disk-backed 功能的持久化键值存储
eliasdb - 无依赖、事物型图数据库,支持 REST API、短语搜索以及类 SQL 的查询语言
forestdb - ForestDB 的 Go 语言借口
GCache - 支持缓存过期、 LFU、 LRU 和 ARC 的缓存库
geocache - 基于内存存储的缓存,适用于分布式部署的应用
Go-cache - 内存键值存储/缓存库,适用于单机程序
Goleveldb - 使用 Go 语言实现的 LevelDB
groupcache - Groupcache 是一个缓存及缓存填充库,在很多情况下用于替代 memcached.
influxdb - 用于计量、事件及实时分析的、可扩展的数据库
ledisdb - Ledisdb 是一个高性能 NoSQL 数据库,类似 Redi
leviGo - LeviGo 是 LevelDB 的 Go 语言封装
moss - Moss 是一个简单的 LSM 键值存储引擎,100% Go 语言实现
piladb - 轻量级 RESTful 数据库引擎,基于堆栈结构
prometheus - 监控系统及时间序列数据库
rqlite - 基于 SQLite 的轻量级的、分布式的关系型数据库
Scribble - 小巧的 JSON 文件存储
tempdb - 临时数据的键值对存储
tidb - TiDB 是一个分布式的 SQL 数据库。受到了 Google F1 的启发
tiedot - 基于 Go 语言的 NoSQL 数据库
Tile38 - 地理位置数据库及实时地理围栏

golang 通用数据结构及算法

binpacker - 二进制数据封包拆包工具,帮你构建自定义的二进制数据流
bit - Go 语言集合数据结构。提供了额外的位操作功能
bitset - 实现了 bitset 的 Go 语言包.
bloom - Go 语言实现的布隆过滤器(bloom filter)
bloom - Go 语言实现的布隆过滤器
boomfilters - 概率统计数据结构,用于处理大量连续的数据。
count-min-log - Go 语言实现的 Count-Min-Log sketch 算法(类似 Count-Min sketch 算法,但是使用的内存更少).
cuckoofilter - Cuckoo 过滤器:一个用 go 语言实现的计数布隆过滤器的替代品
encoding - 整型压缩库
Go-adaptive-radix-tree - Go 语言实现的自适应基数树
Go-datastructures - 一组有用的、高性能的、线程安全的数据结构
Go-geoindex - 基于内存存储的地理索引
Go-rquad - 区域四叉树,支持有效点位置和领域发现
Gods - Go 语言数据结构、容器、集合、列表、栈、键值对、 BidiMaps、树、HashSet 等
Golang-set - 线程安全和非线程安全的高性能集合
Goskiplist - Go 语言实现的跳跃表
Gota - 为 go 语言实现了数据帧,序列以及数据噪音的方法
hilbert - 用于映射空间填充曲线(例如希尔伯特曲线和皮亚诺曲线)和数值的库。
hyperloglog - HyperLogLog implementation with Sparse, LogLog-Beta bias correction and TailCut space reduction.
levenshtein - 编辑距离(levenshtein distance)和相似性度量, 可以自定义编辑代价和 and Winkler-like bonus for common prefix.
levenshtein - Go 语言实现计算编辑距离
mafsa - Go 语言实现的 MA-FSA ,包含最小完美哈希
merkletree - 实现了梅克尔树,提供了一种高效、安全的数据结构内容验证方法
roaring - 实现了压缩 bitsets 的 Go 语言库
skiplist - Go 语言实现的跳跃表
trie - Go 语言实现的 Trie 树
ttlcache - In-memory LRU string-interface{} map with expiration for Golang
willf/bloom - 实现了布隆过滤器的库

golang 用于进行配置解析的库

config - JSON 或 YAML 配置的封装,支持环境变量和标记解析
configure - 可以通过多种途径进行配置,包括 JSON, 标记位以及环境变量
env - 解析环境变量为 Go 语言结构体
envcfg - 解析环境变量为 Go 语言结构体
envconf - 通过环境变量来配置
envconfig - 通过环境变量读取配置
gcfg - 读取类 INI 类型的配置文件为 Go 语言结构体,支持自定义变量和节
GoConfig - 通过命令行的输入、环境变量、配置文件来初始化一个结构体兵将一个结构体解析为输入
Godotenv - Ruby 库 dotenv 的 Go 语言接口 (通过 .env 来获取环境变量)
Gofigure - 让 Go 语言应用程序配置变得简单
Gone/jconf - 模块化 JSON 配置工具。允许你将配置参数结构体和使用它的代码放在一起,而不需要让主配置文件了解所有子模块的细节来进行序列化
hjson - 人性化的 JSON,一个便于程序员使用和阅读的配置文件格式。更加轻松的语法,更少的错误和更多的注释
inGo - 将配置标记持久化到一个类似 ini 的文件中
ini - 用于读写 INI 文件的库
joshbetz/config - 消息配置库,可以解析环境变量、JSON 文件并根据 SIGHUP 自动重新载入
mini -用于解析类 ini 文件的库
store - 轻量级配置管理
viper - 这个库名叫毒蛇 ,Go 语言配置工具
xdg -遵守 XDG 标准 的配置工具

golang 认证和授权库

authboss - 用于 web 开发的组件化认证授权系统。它尝试尽可能的移除模板代码以及硬编码,这使你每次新建 web 项目的时候,可以做到即插即用、配置并开始开发你的 web 英语,而不必每次都重新创建一个认证授权系统。
casbin - 一个支持接入控制模型(例如:ACL,RBAC,ABAC)的授权库
Go-AWS-Auth - AWS 请求签名库
Go-jose - Fairly complete implementation of the JOSE working group’s JSON Web Token, JSON Web 签名以及 JSON Web 加密 specs.
Go-oauth2-server - 使用 Go 语言编写的独立、符合标准的 OAuth2 服务器
Go.auth - 为 Go 语言 web 应用提供的授权 API.
Gologin - 可以串连使用 OAuth1 和 OAuth2 认证服务
Gorbac - 一个用 Go 语言实现的轻量级 RBAC
Goth - 提供了一种简洁的、惯用的方式来使用 OAuth 和 OAuth2.
httpauth - HTTP 认证中间件
jwt - 简单易用的一个 JSON Web Tokens (JWT)的实现
jwt-auth - JWT 为 Go 语言 HTTP 服务器编写的 jwt 中间件,有多种配置选项
jwt-Go - Go 语言实现的 JSON Web Tokens (JWT).
loginsrv - JWT 登录微服务,可以继承 OAuth2 (Github), htpasswd, osiam 等后端。
oauth2 - Goauth2 的继承者。 通用 OAuth 2.0 库,集成了对 JWT, Google APIs, Compute Engine 和 App Engine 的支持.
osin - Go 语言 OAuth2 服务器库
permissions2 - 用于追踪用户,登录状态和许可的库。使用安全 cookies 和 bcrypt.
session - Go 语言会话管理(支持 Google App Engine - GAE)
sessions - 为 Go 语言 HTTP 服务器开发的非常简单的、高性能的、高可定制的会话服务
traefik - 反向代理和负载均衡库,支持多种后端
yubiGo - Yubikey 客户端,提供了用于在 Go 语言应用中集成 Yubico Yubikey 的 API

golang 用于操作音频的库

flac - 原生 Go FLAC 解码器
flac - 原生 Go FLAC 解码器
gaad - 原生 Go AAC 比特流解析器
Go-sox - libsox 的 Go 语言接口
Go_mediainfo - libmediainfo 的 Go 语言接口
Gosamplerate - libsamplerate 的 Go 语言接口
id3v2 - 快速且稳定的 ID3 解析及写入库
mix - 基于序列的 Go 语言混音器,可用于音乐 app。
mp3 - 原生 Go MP3 解码器
music-theory - Go 语言编写的音乐理论模型
PortAudio - 音频 I/O 库的 Go 语言接口
portmidi - PortMidi 的 Go 语言接口
taglib - taglib 的 Go 语言接口
vorbis - “原生” Go Vorbis 解码器 (使用 CGo, 但是没有其他依赖).
waveform - 一个可以通过音频流生成波形图像的包

golang 代码中嵌入其他语言的包

aGora - 一种动态类型的可以嵌入 Go 中的编程语言
anko - Go 语言编写的解释器
binder - Lua 接口, 基于 Gopher-lua
gisp - Simple LISP
Go-duktape - Duktape JavaScript 引擎的 Go 语言接口
Go-lua - Lua 5.2 虚拟机的纯 Go 语言接口
Go-php - PHP 的 Go 语言接口
Go-python - CPython C-API 的 Go 语言接口
Golua - Lua C API。的 Go 语言接口
Gopher-lua - Go 语言编写的 Lua 5.1 虚拟机和编译器
ngaro - 可嵌入的 Ngaro 虚拟机实现,支持在 Retro 中使用脚步
otto - Go 编写的 Javascrip 解释器
purl - 嵌入 Go 语言的 Perl 5.18.2

go 日志库

glg - glg 是一个简单、快速、分级的日志库
glog - 分级记录日志的库
Go-cronowriter 对日志文件进行自动循环写入的库基于当前日期和时间,类似 cronolog.
Go-log - 支持多处理器及日志分级的库
Go-log - Go 语言实现的 Log4j
Go-logger - 支持日志分级的简单的日志工具
Gologger - 简单易用的日志库,可以在彩色控制台、简易控制的、文件或 Elasticsearch 中记录
Gomol - 支持多种输出,结构化的日志模块,可以扩展它的输出
Gone/log - 快速、可扩展、全功能、兼容标准库的日志库
log - 结构化日志库
log - 简单、可配置、可扩展的结构化日志库
log-voyage - 全功能日志 saas 使用 Go 语言编写
log15 - 简单强大的日志库
logdump - 支持分级的日志库
logex - Go 语言日志库,支持追踪和分级,基于标准库进行了封装
logger - 一个极简的日志库
logrus - 支持结构化的日志工具.
logrusly - logrus 的插件,用于将错误发送到 Loggly.
logutils - 对 Go 语言标准日志工具进行了扩展,使其更好用
logxi - 十二要素 app 日志工具,非常快速,令你开心
lumberjack - 简单的循环日志工具,实现了 io.WriteCloser.
mlog - 一个简单的日志模块,可以分 5 级并有一个可选的循环日志文件记录功能,支持 stdout/stderr 输出.
ozzo-log - 高性能日志库,支持日志严重级别、分类及过滤。可以将过滤后的信息发送到不同的目的地(例如: 控制台、网络、邮箱).
seelog - 一个灵活的、解耦的、格式化的日志库
slf - 简单日志门面(The Structured Logging Facade (SLF) ) (类似 SLF4J,但是它是结构化的,并且专为 Go 语言设计)
slog - 为 Go 语言实现的结构化日志门面(Structured Logging Facade (SLF) )
spew - 为 Go 语言的数据结构实现了一个整洁的打印功能,有助于调试
stdlog - Stdlog 是一个面向对象的库,提供了分级日志功能,对于定时任务很有用.
tail - 这个 Go 语言软件包力争模拟 BSD tail 的功能
xlog - 插件架构以及灵活的日志系统,具有日志等级控制,多日志目标以及自定义日志格式功能
xlog - 结构化日志 for net/context aware HTTP handlers ,可以灵活的分发
zap - 快速的、结构化的、分级的日志库
zerolog - 零分配 JSON 日志.

golang 操作表单的库

bind - 将表单数据绑定到任意的 Go 变量上
binding - 将来自 net/HTTP 请求的表单、JSON 数据绑定到结构体
conform - 检查用户输入并基于结构标签来清理数据
form - 解码 url 中的数据到 Go 语言变量中以及将 Go 语言变量编码进 url 支持 Dual Array 及 Full map
formam - 将表单数据解码到结构体
forms - 框架无关的表单/JSON 数据解析验证库,支持多部分表单及文件
Gorilla/csrf - 为 Go 语言 web 应用提供 CSRF 防御
nosurf - CSRF 防御中间件

Go 实现消息系统的库

CentrifuGo - 实时消息服务器
dbus - D-Bus 的 Go 语言接口
drone-line - 通过软件包,docker 或是 Drone CI 来发送 Line 通知
emitter - 通过 Go 语言的方式发送事件消息,可以使用通配符,断言,取消发送等优秀特性
EventBus - 轻量级事件库,支持异步
gaurun-client - Go 语言编写的 Gaurun 客户端
Glue - 健壮的 Go 和 Javascript Socket 库 (可以用来替代 Socket.io).
Go-longpoll - 支持长轮询的发布与订阅
Go-notify - 原生实现的桌面通知规范
Go-nsq - NSQ 官方 Go 语言库
Go-socket.io- Go 语言的 socket.io 库 ,一个实时应用框架.
Go-vitotrol - Viessmann Vitotrol 服务的 Go 语言客户端
Gollum - 一个 n:m 的多路复用器,从不同的源汇聚消息并向目标进行广播
Golongpoll - HTTP 长轮询服务器库,让 web 发布与订阅变的更简单.
Goose - Go 语言实现的服务器端事件发送
Gopush-cluster - Gopush-cluster 是一个 Go 语言实现的支持集群的 comet 服务(支持 websocket,和 tcp 协议)
Gorush - 通知推送服务器,使用 APNs2 和 Google GCM.
guble - 一个使用通知推送(Google Firebase Cloud Messaging, Apple Push Notification services, SMS)、websockets 、REST API 的消息服务器。提供了分布式操作和消息持久化特性
machinery - 异步任务队列,基于分布式消息处理
manGos - 纯 Go 语言实现的 Nanomsg (“Scalable Protocols”)
melody - 用于处理 websocket 会话的一个极简框架,包括广播和自动 ping/pong 处理
NATS Go Client - 轻量级高性能发布订阅(publish-subscribe) 以及分布式消息队列系统,这个一个 Go 语言库.
nsq-event-bus - 针对 NSQ 的主题和频道进行了简单的封装
oplog - 原生的 oplog/replication 系统,用于 REST APIs
pubsub - 一个简单的 pubsub 软件包
RapidMQ - RapidMQ 是一个轻量级,可靠的本地消息队列管理库
sarama - 用于 Apache Kafka 的库
Uniqush-Push - 基于 Redis 的统一推服务,用于服务器端向移动客户端推送消息
zmq4 - ZeroMQ version 4 的 GO 语言接口。也有适用于 version 3 及 version 2 的

github.com/Arafatk/DataViz

对于常用数据结构的可视化,使用的graphviz。

github.com/astaxie/beego

beego 是一个快速开发 Go 应用的 HTTP 框架,他可以用来快速开发 API、Web 及后端服务等各种应用,是一个 RESTful 的框架,主要设计灵感来源于 tornado、sinatra 和 flask 这三个框架,但是结合了 Go 本身的一些特性(interface、struct 嵌入等)而设计的一个框架。

github.com/atotto/clipboard

支持剪切板功能。

github.com/awalterschulze/gographviz

使用golang来写dot语言,通过graphviz生成图。

github.com/bitly/go-simplejson

与任何json交互。

github.com/blevesearch/bleve

一个现代文本索引Go库,类似于lucene。

github.com/cayleygraph/cayley

Cayley 是 Google 的一个开源图(Graph)数据库,其灵感来自于 Freebase 和 Google 的 Knowledge Graph 背后的图数据库。

github.com/cjbassi/gotop

golang重写的top工具,界面简洁、功能强大。

github.com/coocood/freecache

FreeCache 是一个 Go 语言的缓存库,无额外的 GC 负荷。数百万对象的垃圾收集延迟仅在数百毫秒。

特性:

* 可存储数以百万计条目

* 零垃圾收集负荷

* 高并发而且线程安全的访问

* 近乎 LRU 的算法

* 严格限制内存使用

github.com/coreos/etcd

高可用的分布式key-value存储,可以用于配置共享和服务发现;类似于zookeeper和consul ;提供restful的http接口,使用简单;基于raft算法的强一致性、高可用的服务存储目录。

github.com/davecheney/httpstat

httpstat是一款可以测试http状态的可视化工具,通过这个工具可以看出来http响应信息。包括dns解析、tcp连接等信息,httpstat一共有golang版本和python版本。

github.com/derekparker/delve

Devle是一个非常棒的golang 调试工具,支持多种调试方式,直接运行调试,或者attach到一个正在运行中的golang程序,进行调试。

github.com/esimov/diagram

将ASCII图转换成手绘图。

github.com/floyernick/Data-Structures-and-Algorithms

基本数据结构与算法的实现。

github.com/garyburd/redigo

golang操作redis。

github.com/gin-gonic/gin

web框架,类似beego,官网:https://gin-gonic.github.io/gin/

github.com/go-vgo/robotgo

模拟鼠标键盘事件、截屏等。

github.com/gobuffalo/packr

github.com/gogits/gogs

git服务器。

github.com/goinbox/color github.com/goinbox/crypto github.com/goinbox/encoding github.com/goinbox/exception github.com/goinbox/go-nsq-mate github.com/goinbox/gobox-demo github.com/goinbox/gohttp github.com/goinbox/golog github.com/goinbox/gomisc github.com/goinbox/inotify github.com/goinbox/levelcache github.com/goinbox/mongo github.com/goinbox/mysql github.com/goinbox/page github.com/goinbox/pidfile github.com/goinbox/pool github.com/goinbox/redis github.com/goinbox/shardmap github.com/goinbox/shell github.com/goinbox/simplecache github.com/golang/dep github.com/golang/lint/golint github.com/golang/protobuf/proto github.com/gonum/plot github.com/google/gopacket github.com/gorilla/mux github.com/grafana/grafana github.com/grant/go-diagram github.com/henrylee2cn/pholcus github.com/hirokidaichi/goviz github.com/huichen/wukong github.com/ilikeorangutans/grails-service-visualizer github.com/influxdata/influxdb github.com/jinzhu/gorm github.com/jmhodges/levigo github.com/jroimartin/gocui github.com/json-iterator/go github.com/julienschmidt/httprouter github.com/knrt10/asciiConvert github.com/larspensjo/config github.com/lukehoban/go-outline github.com/mailru/easyjson github.com/Masterminds/go-in-practice github.com/matryer/try github.com/mattbaird/elastigo github.com/mb-14/gomarkov github.com/mholt/caddy github.com/muesli/gamut github.com/myntra/golimit

github.com/newhook/go-symbols

从源码中提取json结构。

github.com/mdempsky/gocode

go源码编写vim工具。

github.com/nsqio/nsq

消息队列。

github.com/olivere/elastic

golang对于es操作库。

github.com/PuerkitoBio/goquery

支持类似于jQuery的功能。

github.com/robertkrimen/otto

javascript解析器。

github.com/robfig/cron

定时任务。

github.com/rogpeppe/godef

从go源码中查找符号表信息。

github.com/rqlite/rqlite

嵌入式数据库sqlite相关go操作。

github.com/ruben2020/tags2uml

从源码生成uml图,支持C++, Java, Python, Ruby and C#。

github.com/samuel/go-zookeeper

Zookeeper Golang客户端

github.com/sanity-io/litter

golang调试、测试使用,可以用来打印任何结构。

github.com/senorprogrammer/wtf

机器基本信息仪表盘。

github.com/Shopify/sarama

golang操作kafka库。

github.com/Sirupsen/logrus

日志框架。

github.com/spf13/cobra

Cobra既是一个用来创建强大的现代CLI命令行的golang库,也是一个生成程序应用和命令行文件的程序。

github.com/spf13/hugo

Hugo是由Go语言实现的静态网站生成器。简单、易用、高效、易扩展、快速部署。

github.com/spf13/viper

配置文件操作库。

github.com/syncthing/syncthing

多机器之间的同步工具。

github.com/syndtr/goleveldb

golang操作leveldb,一个本地数据库,高效kv。

Leveldb是一个google实现的非常高效的kv数据库,目前的版本1.2能够支持billion级别的数据量了。

LevelDB 只是一个 C/C++ 编程语言的库, 不包含网络服务封装。

github.com/TrueFurby/go-callvis

生成golang调用关系图。

github.com/urfave/negroni

web框架。

github.com/vdobler/chart

生成图表库。

github.com/vmihailenco/msgpack

序列化反序列化工具,类似于pb。

github.com/wcharczuk/go-chart

生成图表库。

github.com/wvanbergen/kazoo-go

access Kafka metadata in Zookeeper

github.com/sqs/goreturns

补充返回值。

Flag

  • c.String(“startDate”):获取startDate这个flag

Go语言命令行库urfave/cli简介
Golang的一个CLI框架介绍,个人学习备忘
cli - 构建强大命令行程序的工具箱 (1)

Excelize

Go语言构建微服务一站式解决方案
Go微服务 - 第一部分 - 介绍及理论基础
Go 微服务实战汇总
Go实践微服务 – go-micro编写微服务
哔哩哔哩-哔哩哔哩的Go微服务实战
04【千锋Go语言】Go语言微服务实践
go-micro电商项目实战简介

mux学习
Golang 第三方库学习 · mux
golang进阶(四)——路由mux的最佳实践
Gorilla学习笔记

golang日志框架logrus
logrus 安装 使用
logrus日志使用详解
golang日志框架之logrus

6.4. validator 请求校验
Golang validator 详解

golang cron 定时任务使用
Gin实践 连载十一 Cron定时任务
github.com/robfig/cron【Golang 常用包推荐】
golang版的crontab
golang crontab的计划任务及定时任务使用
golang cron定时任务
Go cron定时任务的用法

用golang代码统计整个工程的代码行数

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"sync"
)

var (
	linesum int									
	mutex   *sync.Mutex = new(sync.Mutex)		
)

var (
	rootPath string = "/home/cx4gxf/GoEnv/src/go-test"		
	
	nodirs [6]string = [...]string{"/vendor/golang.org", "/bitbucket.org", "/vendor/github.com", "/goplayer", "/uniqush", "/code.google.com"}
	suffixname string = ".go"								
)

func main() {
	
	argsLen := len(os.Args)
	if argsLen == 2 {
		rootPath = os.Args[1]
	} else if argsLen == 3 {
		rootPath = os.Args[1]
		suffixname = os.Args[2]
	}

	done := make(chan bool)						
	go codeLineSum(rootPath, done)
	<-done

	fmt.Println("total line------------------------------------------------------------------------------", linesum)
}

func codeLineSum(root string, done chan bool) {
	var goes int              
	
	godone := make(chan bool) 

	
	isDstDir := checkDir(root)

	defer func() {
		if pan := recover(); pan != nil {
			fmt.Printf("root: %s, panic:%#v\n", root, pan)
		}

		
		for i := 0; i < goes; i++ {
			<- godone
		}

		
		done <- true
	}()

	if !isDstDir {
		return
	}

	
	rootfi, err := os.Lstat(root)
	checkerr(err)

	
	rootdir, err := os.Open(root)
	checkerr(err)
	defer rootdir.Close()

	if rootfi.IsDir() {
		
		fis, err := rootdir.Readdir(0)
		checkerr(err)

		for _, fi := range fis {
			
			if strings.HasPrefix(fi.Name(), ".") {
				continue
			}

			
			goes++

			
			if fi.IsDir() {
				go codeLineSum(root+"/"+fi.Name(), godone)
			} else {
				go readfile(root+"/"+fi.Name(), godone)
			}
		}
	} else {
		
		goes = 1 
		go readfile(root, godone)
	}
}




func readfile(filename string, done chan bool) {
	var line int	

	
	isDstFile := strings.HasSuffix(filename, suffixname)

	defer func() {
		
		if pan := recover(); pan != nil {
			fmt.Printf("filename: %s, panic:%#v\n", filename, pan)
		}

		
		if isDstFile {
			addLineNum(line)
			fmt.Printf("file %s complete, line = %d\n", filename, line)
		}

		
		
		done <- true
	}()

	
	if !isDstFile {
		return
	}

	
	file, err := os.Open(filename)
	checkerr(err)
	defer file.Close()

	
	reader := bufio.NewReader(file)
	for {
		_, isPrefix, err := reader.ReadLine()
		if err != nil {
			break
		}

		
		if !isPrefix {
			line++
		}
	}
}



func checkDir(dirpath string) bool {
	for _, dir := range nodirs {
		if rootPath + dir == dirpath {
			return false
		}
	}
	return true
}

func addLineNum(num int) {
	mutex.Lock()
	defer mutex.Unlock()

	linesum += num
}


func checkerr(err error) {
	if err != nil {
		panic(err.Error())
	}
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177

测试&使用

使用说明

go run count_line.go rootPath suffixName
	- rootPath: 可选参数,要进行代码统计的项目根路径
	- suffixName: 可选参数,要进行代码统计的文件后缀
123

使用示例

直接运行项目,统计默认的项目根路径的代码行数

其中,默认的项目根路径/默认被排除的路径/默认的文件后缀 可在代码中执行配置

var (
	
	rootPath string = "/home/cx4gxf/GoEnv/src/go-test"
	
	nodirs [6]string = [...]string{"/vendor/golang.org", "/bitbucket.org", "/vendor/github.com", "/goplayer", "/uniqush", "/code.google.com"}
	
	suffixname string = ".go"
)
12345678

在这里插入图片描述

运行项目,指定要进行代码统计的项目的根路径

在这里插入图片描述

运行项目,指定要进行代码统计的项目的根路径及文件后缀

在这里插入图片描述

用GO生成和识别二维码

Go语言实现有限状态机(FSM)

golang 命令行相关功能操作cobra 库使用

cobra 是 go 语言的一个库,可以用于编写命令行工具。通常我们可以看到git pulldocker container startapt install 等等这样命令,都可以很容易用corba来实现,另外,go 语言是很容易编译成一个二进制文件,本文将实现一个简单的命令行工具。

具体写一个例子, 设计一个命令叫blog, 有四个子命令

 blog new [post-name] :创建一篇新的blog
 blog list   :列出当前有哪些文章
 blog delete [post-name]: 删除某一篇文章
 blog edit [post-name]:编辑某一篇文章

计划有以下几个步骤

  • 创建模块
  • 用cobra的命令行,创建命令行入口
  • 用cobra的命令行,创建子命令
  • 编写功能逻辑

创建模块

$ go mod init github.com/shalk/blog
go: creating new go.mod: module github.com/shalk/blog

创建命令行入口

说到命令行,可能会想到bash的getopt 或者 java 的jcommand,可以解析各种风格的命令行,但是通常这些命令行都有固定的写法,这个写法一般还记不住要找一个模板参考以下。cobra除了可以解析命令行之外,还提供了命令行,可以生成模板。先安装这个命令行, 并且把库的依赖加到go.mod里

$ go get -u github.com/spf13/cobra/cobra

cobra会安装到$GOPATH\bin 目录下,注意环境变量中把它加入PATH中

$ cobra init 
Your Cobra applicaton is ready at
D:\code\github.com\shalk\blog

目录结构如下:

./cmd
./cmd/root.go
./go.mod
./go.sum
./LICENSE
./main.go

编译一下

go build  -o blog .

执行一下

$blog -h
A longer description that spans multiple lines and likely contains
examples and usage of using your application. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.

命令行就创建好了,看上去一行代码也不用写,由于随着了解的深入,后面需要调整生成的代码,还是要了解一下cobra代码的套路。

cobra代码的套路

有三个概念,command、flag和args ,例如:

go get -u test.com/a/b

这里 get 就是commond(这里比较特殊), -u 就是flag, test.com/a/b 就是args

那么命令行就是有三部分构成,所以需要定义好这个

  • 命令自身的一些基本信息,用command表示,具体对象是 cobra.Command
  • 命令的一些标致或者选项,用flag表示,具体对象是 flag.FlagSet
  • 最后的参数,用args表示,通常是[]string

还有一个概念是子命令,比如get就是go的子命令,这是一个树状结构的关系。

我可以使用go命令,也可以使用 go get命令

例如: root.go,定义了root命令,另外在init里面 定义了flag,如果它本身有具体执行,就填充Run字段。

var rootCmd = &cobra.Command{
	Use:   "blog",
	Short: "A brief description of your application",
	Long: `A longer description that spans multiple lines and likely contains
examples and usage of using your application. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
	
	
	
}



func Execute() {
	if err := rootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

func init() {
	cobra.OnInitialize(initConfig)

	
	
	

	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.blog.yaml)")

	
	
	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")

}

如果需要子命令,就需要在init 里,给 rootCmd.AddCommand() 其他的command,其他的子命令通常也会单独用一个文件编写,并且有一个全局变量,让rootCmd可以add它

创建子命令

D:\code\github.com\shalk\blog>cobra add  new
new created at D:\code\github.com\shalk\blog

D:\code\github.com\shalk\blog>cobra add  delete
delete created at D:\code\github.com\shalk\blog

D:\code\github.com\shalk\blog>cobra add  list
list created at D:\code\github.com\shalk\blog

D:\code\github.com\shalk\blog>cobra add  edit
edit created at D:\code\github.com\shalk\blog

cmd 目录下增加了 new.go, delete.go,list.go,edit.go

增加功能代码

new.go

var newCmd = &cobra.Command{
	Use:   "new",
	Short: "create new post",
	Long:  `create new post `,
	Args: func(cmd *cobra.Command, args []string) error {
		if len(args) != 1 {
			return errors.New("requires a color argument")
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		fileName := "posts/" + args[0]
		err := os.Mkdir("posts", 644)
		if err != nil {
			log.Fatal(err)
		}
		_, err = os.Stat( fileName)
		if os.IsNotExist(err) {
			file, err := os.Create(fileName)
			if err != nil {
				log.Fatal(err)
			}
			log.Printf("create file %s", fileName)
			defer file.Close()
		} else {
		}
	},
}

list.go

var listCmd = &cobra.Command{
	Use:   "list",
	Short: "list all blog in posts",
	Long: `list all blog in posts `,
	Run: func(cmd *cobra.Command, args []string) {
		_, err := os.Stat("posts")
		if os.IsNotExist(err) {
			log.Fatal("posts dir is not exits")
		}
		dirs, err := ioutil.ReadDir("posts")
		if err != nil {
			log.Fatal("read posts dir fail")
		}
		fmt.Println("------------------")
		for _, dir := range dirs {
			fmt.Printf(" %s\n", dir.Name() )
		}
		fmt.Println("------------------")
		fmt.Printf("total: %d blog\n", len(dirs))

	},
}

delete.go

var deleteCmd = &cobra.Command{
	Use:   "delete",
	Short: "delete a post",
	Long: `delete a post`,
	Args: func(cmd *cobra.Command, args []string) error {
		if len(args) != 1 {
			return errors.New("requires a color argument")
		}
		if strings.Contains(args[0],"/") || strings.Contains(args[0],"..") {
			return errors.New("posts name should not contain / or .. ")
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		fileName := "./posts/" +  args[0]
		stat, err := os.Stat(fileName)
		if os.IsNotExist(err) {
			log.Fatalf("post %s is not exist", fileName)
		}
		if stat.IsDir() {
			log.Fatalf("%s is dir ,can not be deleted", fileName)
		}
		err = os.Remove(fileName)
		if err != nil {
			log.Fatalf("delete %s fail, err %v", fileName, err)
		} else {
			log.Printf("delete post %s success", fileName)
		}
	},
}

edit.go 这个有一点麻烦,因为如果调用一个程序比如vim 打开文件,并且golang程序本身要退出,需要detach。暂时放一下(TODO)

编译测试

我是window测试,linux 更简单一点

PS D:\code\github.com\shalk\blog> go build -o blog.exe .
PS D:\code\github.com\shalk\blog> .\blog.exe list
------------------
------------------
total: 0 blog
PS D:\code\github.com\shalk\blog> .\blog.exe new blog1.md
2020/07/26 22:37:15 create file posts/blog1.md
PS D:\code\github.com\shalk\blog> .\blog.exe new blog2.md
2020/07/26 22:37:18 create file posts/blog2.md
PS D:\code\github.com\shalk\blog> .\blog.exe new blog3.md
2020/07/26 22:37:20 create file posts/blog3.md
PS D:\code\github.com\shalk\blog> .\blog list
------------------
 blog1.md
 blog2.md
 blog3.md
------------------
total: 3 blog
PS D:\code\github.com\shalk\blog> .\blog delete blog1.md
2020/07/26 22:37:37 delete post ./posts/blog1.md success
PS D:\code\github.com\shalk\blog> .\blog list
------------------
 blog2.md
 blog3.md
------------------
total: 2 blog
PS D:\code\github.com\shalk\blog> ls .\posts\


    目录: D:\code\github.com\shalk\blog\posts


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        2020/7/26     22:37              0 blog2.md
-a----        2020/7/26     22:37              0 blog3.md


PS D:\code\github.com\shalk\blog>

cobra 是一个高效的命令行解析库,利用cobra的脚手架,可以快速的实现一个命令行工具。如果需要更细致的控制,可以参考cobra的官方文档。


分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进