添加基本功能

想要达到项目目标，需要实现以下功能：

-c, --count
-i, --ignore-case
-n, --line-number
-r, --recursive
-v, --invert-match

main.go:

package main

import (
	"flag"
	"fmt"
	"log"
	"os"

	"github.com/Literank/gorep/pkg/grep"
)

func main() {
	// 设置自定义使用方法信息
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: %s [options] pattern file_path\n", os.Args[0])
		fmt.Println("Options:")
		flag.PrintDefaults()
	}

	// 可选参数
	countFlag := flag.Bool("c", false, "count\nOnly a count of selected lines is written to standard output.")
	ignoreCaseFlag := flag.Bool("i", false, "ignore-case\nPerform case insensitive matching. By default, it is case sensitive.")
	lineNumberFlag := flag.Bool("n", false, "line-number\nEach output line is preceded by its relative line number in the file, starting at line 1. This option is ignored if -count is specified.")
	recursiveFlag := flag.Bool("r", false, "recursive\nRecursively search subdirectories listed.")
	invertMatchFlag := flag.Bool("v", false, "invert-match\nSelected lines are those not matching any of the specified patterns.")

	flag.Parse()

	// 获取位置参数
	// pattern - 要搜索匹配的模式
	// file_path - 要搜索匹配的文件路径
	args := flag.Args()
	if len(args) < 2 {
		fmt.Println("Both pattern and file_path are required.")
		flag.Usage()
		os.Exit(0)
	}
	pattern, filePath := args[0], args[1]

	options := &grep.Options{}
	if *ignoreCaseFlag {
		options.IgnoreCase = true
	}
	if *invertMatchFlag {
		options.InvertMatch = true
	}

	var result grep.MatchResult
	var err error

	if *recursiveFlag {
		result, err = grep.GrepRecursive(pattern, filePath, options)
		if err != nil {
			log.Fatal("Failed to do recursive grep, error:", err)
		}
	} else {
		result, err = grep.Grep(pattern, filePath, options)
		if err != nil {
			log.Fatal("Failed to grep, error:", err)
		}
	}

	if *countFlag {
		fmt.Println(grep.GrepCount(result))
	} else {
		printResult(result, *lineNumberFlag)
	}
}

func printResult(result grep.MatchResult, lineNumberOption bool) {
	currentFile := ""
	fileCount := len(result)

	for filePath, items := range result {
		for _, item := range items {
			if fileCount > 1 && filePath != currentFile {
				currentFile = filePath
				fmt.Printf("\n%s:\n", filePath)
			}
			if lineNumberOption {
				fmt.Printf("%d: %s\n", item.LineNumber, item.Line)
			} else {
				fmt.Println(item.Line)
			}
		}
	}
}

flag 加入所有可选参数。printResult 函数解析 MatchResult 并按需打印 filePath 和 lineNumber。

pkg/grep/search.go:

package grep

import (
	"bufio"
	"os"
	"path/filepath"
	"regexp"
	"strings"
)

// MatchItem 表示 grep 搜索的匹配项
type MatchItem struct {
	LineNumber int
	Line       string
}

// MatchResult 表示 grep 搜索的所有文件的匹配结果
type MatchResult = map[string][]*MatchItem

// Options 结构体表示 grep 搜索的控制选项
type Options struct {
	CountOnly   bool
	IgnoreCase  bool
	InvertMatch bool
}

func Grep(pattern string, filePath string, options *Options) (MatchResult, error) {
	lines, err := readFileLines(filePath)
	if err != nil {
		return nil, err
	}

	var matchingLines []*MatchItem
	patternRegex, err := regexp.Compile(pattern)
	if err != nil {
		return nil, err
	}

	// 常规 grep
	if options == nil {
		matchingLines = filterLines(patternRegex, lines, true)
	} else {
		if options.IgnoreCase {
			patternRegex, err = regexp.Compile("(?i)" + pattern)
			if err != nil {
				return nil, err
			}
		}
		if options.InvertMatch {
			matchingLines = filterLines(patternRegex, lines, false)
		} else {
			matchingLines = filterLines(patternRegex, lines, true)
		}
	}
	return MatchResult{filePath: matchingLines}, nil
}

func GrepCount(result MatchResult) int {
	count := 0
	for _, v := range result {
		count += len(v)
	}
	return count
}

func GrepRecursive(pattern string, directoryPath string, options *Options) (MatchResult, error) {
	results := make(MatchResult)
	filepath.Walk(directoryPath, func(filePath string, info os.FileInfo, err error) error {
		if err != nil {
			return nil
		}

		if !info.IsDir() {
			result, grepErr := Grep(pattern, filePath, options)
			if grepErr != nil {
				return grepErr
			}
			results[filePath] = result[filePath]
		}
		return nil
	})
	return results, nil
}

func readFileLines(filePath string) ([]string, error) {
	// 打开文件
	file, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	// 创建 scanner 来按行读取
	scanner := bufio.NewScanner(file)
	var lines []string
	for scanner.Scan() {
		lines = append(lines, scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		return nil, err
	}
	return lines, nil
}

func filterLines(pattern *regexp.Regexp, lines []string, flag bool) []*MatchItem {
	var filteredLines []*MatchItem
	for lineNumber, line := range lines {
		if flag == pattern.MatchString(line) {
			filteredLines = append(filteredLines, &MatchItem{lineNumber + 1, strings.TrimLeft(line, " \t")})
		}
	}
	return filteredLines
}

Grep 函数添加“不区分大小写匹配”和“反向匹配”逻辑。GrepRecursive 函数递归地列出所有文件，执行 grep 操作，然后输出到 MatchResult 中。

常规用法：

go run main.go result main.go

结果：

var result grep.MatchResult
result, err = grep.GrepRecursive(pattern, filePath, options)
result, err = grep.Grep(pattern, filePath, options)
fmt.Println(grep.GrepCount(result))
printResult(result, *lineNumberFlag)
func printResult(result grep.MatchResult, lineNumberOption bool) {
fileCount := len(result)
for filePath, items := range result {

计数：

go run main.go -c result main.go

结果数字：8。

显示行号：

go run main.go -n result main.go

结果：

48: var result grep.MatchResult
52: result, err = grep.GrepRecursive(pattern, filePath, options)
57: result, err = grep.Grep(pattern, filePath, options)
64: fmt.Println(grep.GrepCount(result))
66: printResult(result, *lineNumberFlag)
70: func printResult(result grep.MatchResult, lineNumberOption bool) {
72: fileCount := len(result)
74: for filePath, items := range result {

使用正则：

go run main.go -n "\br[a-z]+t" main.go

结果：

23: lineNumberFlag := flag.Bool("n", false, "line-number\nEach output line is preceded by its relative line number in the file, starting at line 1. This option is ignored if -count is specified.")
48: var result grep.MatchResult
52: result, err = grep.GrepRecursive(pattern, filePath, options)
57: result, err = grep.Grep(pattern, filePath, options)
64: fmt.Println(grep.GrepCount(result))
66: printResult(result, *lineNumberFlag)
70: func printResult(result grep.MatchResult, lineNumberOption bool) {
72: fileCount := len(result)
74: for filePath, items := range result {

反向匹配：

go run main.go -v -n result main.go

结果：

1: package main
2: 
3: import (
4: "flag"
5: "fmt"
6: "log"
7: "os"

...

19: 
20: // Optional flags
21: countFlag := flag.Bool("c", false, "count\nOnly a count of selected lines is written to standard output.")
22: ignoreCaseFlag := flag.Bool("i", false, "ignore-case\nPerform case insensitive matching. By default, it is case sensitive.")
23: lineNumberFlag := flag.Bool("n", false, "line-number\nEach output line is preceded by its relative line number in the file, starting at line 1. This option is ignored if -count is specified.")
24: recursiveFlag := flag.Bool("r", false, "recursive\nRecursively search subdirectories listed.")
25: invertMatchFlag := flag.Bool("v", false, "invert-match\nSelected lines are those not matching any of the specified patterns.")
...

80: if lineNumberOption {
81: fmt.Printf("%d: %s\n", item.LineNumber, item.Line)
82: } else {
83: fmt.Println(item.Line)

...

不区分大小写匹配：

go run main.go -i only main.go

结果：

countFlag := flag.Bool("c", false, "count\nOnly a count of selected lines is written to standard output.")

递归匹配：

go run main.go -r count .

结果：

main.go:
countFlag := flag.Bool("c", false, "count\nOnly a count of selected lines is written to standard output.")
lineNumberFlag := flag.Bool("n", false, "line-number\nEach output line is preceded by its relative line number in the file, starting at line 1. This option is ignored if -count is specified.")
if *countFlag {

pkg/grep/search.go:
count := 0
count += len(v)
return count