Golang实现的实时更新版wc命令替代工具lwc

lwc是一个用Golang实现的实时更新的wc命令替代工具，它不仅提供传统wc的计数功能，还能实时监控文件变化并更新统计结果。

功能特点

1. 实时监控文件变化并更新统计
2. 支持传统wc的所有计数功能（行数、单词数、字符数、字节数）
3. 支持彩色输出
4. 支持多文件处理

安装方法

go install github.com/tj/go-lwc@latest

基本使用示例

package main

import (
	"fmt"
	"os"
	"github.com/tj/go-lwc"
)

func main() {
	// 创建lwc实例
	counter := lwc.New()

	// 监控单个文件
	if err := counter.Watch("example.txt"); err != nil {
		fmt.Fprintf(os.Stderr, "error: %s\n", err)
		os.Exit(1)
	}

	// 开始实时监控
	counter.Start()
}

完整功能示例

package main

import (
	"flag"
	"fmt"
	"os"
	"time"

	"github.com/fatih/color"
	"github.com/tj/go-lwc"
)

func main() {
	// 解析命令行参数
	var (
		lines      = flag.Bool("l", false, "count lines")
		words      = flag.Bool("w", false, "count words")
		chars      = flag.Bool("m", false, "count characters")
		bytes      = flag.Bool("c", false, "count bytes")
		interval   = flag.Duration("i", 500*time.Millisecond, "poll interval")
		noColor    = flag.Bool("no-color", false, "disable color")
		all        = flag.Bool("a", false, "count all (lines, words, bytes)")
	)
	flag.Parse()

	// 如果没有指定任何计数选项，默认显示全部
	if !*lines && !*words && !*chars && !*bytes && !*all {
		*all = true
	}

	// 初始化颜色
	if *noColor {
		color.NoColor = true
	}

	// 创建计数器
	counter := lwc.New()
	counter.Interval = *interval

	// 添加要监控的文件
	for _, path := range flag.Args() {
		if err := counter.Watch(path); err != nil {
			fmt.Fprintf(os.Stderr, "error watching %q: %s\n", path, err)
			os.Exit(1)
		}
	}

	// 如果没有指定文件，从stdin读取
	if len(flag.Args()) == 0 {
		if err := counter.WatchFile(os.Stdin); err != nil {
			fmt.Fprintf(os.Stderr, "error: %s\n", err)
			os.Exit(1)
		}
	}

	// 设置输出处理函数
	counter.Handler = func(path string, counts lwc.Counts) {
		output := []interface{}{}

		// 添加文件名（如果有）
		if path != "" {
			output = append(output, color.BlueString("%s", path))
		}

		// 添加计数结果
		if *all || *lines {
			output = append(output, color.GreenString("%d", counts.Lines))
		}
		if *all || *words {
			output = append(output, color.YellowString("%d", counts.Words))
		}
		if *all || *chars {
			output = append(output, color.MagentaString("%d", counts.Chars))
		}
		if *all || *bytes {
			output = append(output, color.CyanString("%d", counts.Bytes))
		}

		// 打印结果
		fmt.Println(output...)
	}

	// 开始监控
	if err := counter.Start(); err != nil {
		fmt.Fprintf(os.Stderr, "error: %s\n", err)
		os.Exit(1)
	}
}

自定义实现简化版lwc

如果你想了解原理，这里是一个简化版的实现：

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"time"
)

type Counts struct {
	Lines int
	Words int
	Chars int
	Bytes int
}

func count(r io.Reader) (Counts, error) {
	var c Counts
	scanner := bufio.NewScanner(r)
	for scanner.Scan() {
		c.Lines++
		line := scanner.Text()
		c.Words += len(bufio.ScanWords([]byte(line), true)
		c.Chars += len([]rune(line)) + 1 // +1 for newline
		c.Bytes += len(scanner.Bytes()) + 1
	}
	return c, scanner.Err()
}

func watchFile(path string, interval time.Duration, handler func(Counts)) error {
	lastMod := time.Time{}
	for {
		stat, err := os.Stat(path)
		if err != nil {
			return err
		}

		if stat.ModTime().After(lastMod) {
			file, err := os.Open(path)
			if err != nil {
				return err
			}

			counts, err := count(file)
			file.Close()
			if err != nil {
				return err
			}

			handler(counts)
			lastMod = stat.ModTime()
		}

		time.Sleep(interval)
	}
}

func main() {
	if len(os.Args) < 2 {
		fmt.Println("Usage: lwc <file>")
		os.Exit(1)
	}

	handler := func(c Counts) {
		fmt.Printf("\rLines: %d, Words: %d, Chars: %d, Bytes: %d", 
			c.Lines, c.Words, c.Chars, c.Bytes)
	}

	if err := watchFile(os.Args[1], 500*time.Millisecond, handler); err != nil {
		fmt.Printf("\nError: %v\n", err)
		os.Exit(1)
	}
}

使用建议

1. 对于大文件，适当增加轮询间隔以减少系统负载
2. 可以使用管道将其他命令的输出传递给lwc：tail -f logfile | lwc
3. 结合-a参数可以查看所有统计信息
4. 在脚本中使用时，可以添加--no-color参数禁用彩色输出

lwc是一个简单但强大的工具，特别适合在开发过程中实时监控日志文件或输出变化的统计信息。