1k实现全磁盘扫描搜索——仙盟创梦IDE-智能编程 编程工具设计

牛马的痛苦------身兼数职

在多项目开发场景下，项目数量众多、文件繁杂，导致文件查找困难重重。不同项目架构各异，文件命名缺乏统一规范，相似功能文件分散在不同项目目录，开发人员往往花费大量时间在文件夹层级间反复切换、搜索，却难以精准定位所需文件。

关键代码查找也面临极大挑战，项目迭代频繁，代码逻辑愈发复杂，核心功能代码被大量业务代码淹没。加之部分项目缺乏清晰的模块划分，代码结构混乱，开发人员只能逐行阅读大量无关代码，效率低下。

牛马的痛苦------代码注释找不到

多项目代码库庞大，注释分散在海量文件中。在缺乏高效搜索工具或索引机制时，要从众多注释里精准找到相关代码如同大海捞针。而且跨项目查找时，不同项目的注释存储和组织方式不同，进一步加大了查找难度，极大降低了开发效率

IDE 搜索功能

• 提高代码复用率：在多项目开发中，常常会有一些通用的代码模块、函数或类需要在不同项目中重复使用。通过文件搜索功能，开发人员可以快速定位到之前项目中已经实现的相关代码文件，直接复用这些代码，避免重复开发，从而节省开发时间和精力，提高开发效率。
• 方便进行代码审查：在多项目开发中，代码审查是确保代码质量的重要环节。文件搜索功能可以帮助审查人员快速定位到需要审查的代码文件，方便他们对代码进行逐行检查，查看代码是否符合规范、是否存在潜在的漏洞或风险等。
• 便于项目维护和升级：随着项目的发展，可能需要对已有的功能进行修改、扩展或升级。文件搜索功能可以帮助开发人员快速找到与特定功能相关的所有代码文件，了解代码的上下文和逻辑关系，从而更准确地进行修改和升级，减少对其他部分的影响，降低维护成本。
• 快速整合项目：多项目开发中可能涉及多种类型的文件，如代码文件、配置文件、文档文件等。文件搜索功能可以让开发人员迅速找到所需的各种资源文件，方便进行项目的部署。

无所不能的文件搜索

文件搜索代码

public static List<仙盟Result> 未来之窗仙盟SearchInFiles(string directory, string pattern, string[] fileExtensions)
        {
            var results = new List<仙盟Result>();
            var regex = new Regex(pattern);

            var files = Directory.GetFiles(directory, "*.*", SearchOption.AllDirectories);

            if (regex.IsMatch(directory))
            {
                //2025-05-08 未来之窗增加文件名
                results.Add(new FileSearchResult { FilePath = directory, LineNumber = 0, 类型 = "folder" });
            }


            foreach (var file in files)
            {
                string extension = Path.GetExtension(file);
                if (Array.IndexOf(fileExtensions, extension) >= 0)
                {
                    if (regex.IsMatch(file))
                    {
                        //2025-05-08 未来之窗增加文件名
                        results.Add(new FileSearchResult { FilePath = file, LineNumber = 0 , 类型 ="file"});
                    }

                    string[] lines = File.ReadAllLines(file);
                    for (int i = 0; i < lines.Length; i++)
                    {
                        if (regex.IsMatch(lines[i]))
                        {
                            results.Add(new FileSearchResult { FilePath = file, LineNumber = i + 1, 类型 = "file" });
                        }
                    }
                }
            }

            return results;
        }

php 实现

// 定义仙盟Result类
class 仙盟Result {
    public $FilePath;
    public $LineNumber;
    public $类型;

    public function __construct($filePath, $lineNumber, $类型) {
        $this->FilePath = $filePath;
        $this->LineNumber = $lineNumber;
        $this->类型 = $类型;
    }
}

function 未来之窗仙盟SearchInFiles($directory, $pattern, $fileExtensions) {
    $results = [];
    $regex = '/' . preg_quote($pattern, '/') . '/';

    // 检查目录名是否匹配
    if (preg_match($regex, $directory)) {
        $results[] = new 仙盟Result($directory, 0, "folder");
    }

    // 获取目录下所有文件
    $iterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory));
    foreach ($iterator as $file) {
        if ($file->isFile()) {
            $filePath = $file->getPathname();
            $extension = pathinfo($filePath, PATHINFO_EXTENSION);
            if (in_array('.' . $extension, $fileExtensions)) {
                // 检查文件名是否匹配
                if (preg_match($regex, $filePath)) {
                    $results[] = new 仙盟Result($filePath, 0, "file");
                }

                // 读取文件内容并逐行检查
                $lines = file($filePath, FILE_IGNORE_NEW_LINES);
                foreach ($lines as $lineNumber => $line) {
                    if (preg_match($regex, $line)) {
                        $results[] = new 仙盟Result($filePath, $lineNumber + 1, "file");
                    }
                }
            }
        }
    }

    return $results;
}

python 实现

import os
import re

class 仙盟Result:
    def __init__(self, file_path, line_number, 类型):
        self.FilePath = file_path
        self.LineNumber = line_number
        self.类型 = 类型

def 未来之窗仙盟SearchInFiles(directory, pattern, file_extensions):
    results = []
    regex = re.compile(pattern)

    # 检查目录名是否匹配
    if regex.search(directory):
        results.append(仙盟Result(directory, 0, "folder"))

    # 遍历目录下的所有文件
    for root, _, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(root, file)
            file_extension = os.path.splitext(file_path)[1]
            if file_extension in file_extensions:
                # 检查文件名是否匹配
                if regex.search(file_path):
                    results.append(仙盟Result(file_path, 0, "file"))

                # 读取文件内容并逐行检查
                try:
                    with open(file_path, 'r', encoding='utf-8') as f:
                        lines = f.readlines()
                        for i, line in enumerate(lines, start=1):
                            if regex.search(line):
                                results.append(仙盟Result(file_path, i, "file"))
                except Exception as e:
                    print(f"读取文件 {file_path} 时出错: {e}")

    return results
    

asp实现

<%
' 定义仙盟Result类
Class 仙盟Result
    Public FilePath
    Public LineNumber
    Public 类型
End Class

Function 未来之窗仙盟SearchInFiles(directory, pattern, fileExtensions)
    Dim results
    Set results = CreateObject("System.Collections.ArrayList")
    Dim regex
    Set regex = New RegExp
    regex.Pattern = pattern
    regex.IgnoreCase = True
    
    ' 检查目录名是否匹配
    If regex.Test(directory) Then
        Dim folderResult
        Set folderResult = New 仙盟Result
        folderResult.FilePath = directory
        folderResult.LineNumber = 0
        folderResult.类型 = "folder"
        results.Add folderResult
    End If
    
    Dim fso
    Set fso = CreateObject("Scripting.FileSystemObject")
    Dim folder
    Set folder = fso.GetFolder(directory)
    Dim fileCollection
    Set fileCollection = folder.Files
    
    Dim subFolder
    For Each subFolder In folder.SubFolders
        Dim subFiles
        Set subFiles = subFolder.Files
        For Each file In subFiles
            Dim fileExt
            fileExt = fso.GetExtensionName(file.Path)
            If IsInArray("." & fileExt, fileExtensions) Then
                ' 检查文件名是否匹配
                If regex.Test(file.Path) Then
                    Dim fileResult
                    Set fileResult = New 仙盟Result
                    fileResult.FilePath = file.Path
                    fileResult.LineNumber = 0
                    fileResult.类型 = "file"
                    results.Add fileResult
                End If
                
                ' 读取文件内容并逐行检查
                Dim fileStream
                Set fileStream = file.OpenAsTextStream(1, -2)
                Dim lineNumber
                lineNumber = 1
                Do Until fileStream.AtEndOfStream
                    Dim line
                    line = fileStream.ReadLine
                    If regex.Test(line) Then
                        Dim lineResult
                        Set lineResult = New 仙盟Result
                        lineResult.FilePath = file.Path
                        lineResult.LineNumber = lineNumber
                        lineResult.类型 = "file"
                        results.Add lineResult
                    End If
                    lineNumber = lineNumber + 1
                Loop
                fileStream.Close
            End If
        Next
    Next
    
    Set 未来之窗仙盟SearchInFiles = results
End Function

Function IsInArray(valToFind, arr)
    Dim i
    For i = LBound(arr) To UBound(arr)
        If arr(i) = valToFind Then
            IsInArray = True
            Exit Function
        End If
    Next
    IsInArray = False
End Function
%>    

鸿蒙系统

import ohos.data.orm.OrmContext;
import ohos.data.rdb.RdbStore;
import ohos.data.rdb.StoreConfig;
import ohos.data.rdb.RdbStore;
import ohos.data.rdb.RdbStoreConfig;
import ohos.data.rdb.RdbStore.OpenCallback;
import ohos.data.rdb.RdbStore.OpenCallback;

java实现

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

// 定义仙盟Result类
class 仙盟Result {
    String FilePath;
    int LineNumber;
    String 类型;

    public 仙盟Result(String filePath, int lineNumber, String type) {
        this.FilePath = filePath;
        this.LineNumber = lineNumber;
        this.类型 = type;
    }
}

public class FileSearcher {
    public static List<仙盟Result> 未来之窗仙盟SearchInFiles(String directory, String pattern, String[] fileExtensions) {
        List<仙盟Result> results = new ArrayList<>();
        Pattern regex = Pattern.compile(pattern);

        File rootDir = new File(directory);
        if (regex.matcher(directory).find()) {
            results.add(new 仙盟Result(directory, 0, "folder"));
        }

        searchFiles(rootDir, regex, fileExtensions, results);
        return results;
    }

    private static void searchFiles(File dir, Pattern regex, String[] fileExtensions, List<仙盟Result> results) {
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    if (regex.matcher(file.getAbsolutePath()).find()) {
                        results.add(new 仙盟Result(file.getAbsolutePath(), 0, "folder"));
                    }
                    searchFiles(file, regex, fileExtensions, results);
                } else {
                    String extension = getFileExtension(file.getName());
                    if (isValidExtension(extension, fileExtensions)) {
                        if (regex.matcher(file.getAbsolutePath()).find()) {
                            results.add(new 仙盟Result(file.getAbsolutePath(), 0, "file"));
                        }
                        searchInFile(file, regex, results);
                    }
                }
            }
        }
    }

    private static void searchInFile(File file, Pattern regex, List<仙盟Result> results) {
        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            String line;
            int lineNumber = 1;
            while ((line = reader.readLine()) != null) {
                if (regex.matcher(line).find()) {
                    results.add(new 仙盟Result(file.getAbsolutePath(), lineNumber, "file"));
                }
                lineNumber++;
            }
        } catch (IOException e) {
            System.err.println("Error reading file: " + file.getAbsolutePath() + " - " + e.getMessage());
        }
    }

    private static String getFileExtension(String fileName) {
        int lastIndex = fileName.lastIndexOf('.');
        return lastIndex != -1 ? fileName.substring(lastIndex) : "";
    }

    private static boolean isValidExtension(String extension, String[] fileExtensions) {
        for (String ext : fileExtensions) {
            if (ext.equals(extension)) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        String directory = "your_directory_path";
        String pattern = "your_search_pattern";
        String[] fileExtensions = {".txt", ".java"};
        List<仙盟Result> searchResults = 未来之窗仙盟SearchInFiles(directory, pattern, fileExtensions);
        for (仙盟Result result : searchResults) {
            System.out.println("FilePath: " + result.FilePath + ", LineNumber: " + result.LineNumber + ", 类型: " + result.类型);
        }
    }
}