Skip to main content
100%

find string in directory

✓ Published0🌍 Public
Aadkdev
Last edited Aug 23, 2019
Created on Aug 23, 2019

This example demonstrates two command-line methods for searching a directory tree for files containing a specific text pattern. It shows the `find` utility combined with `grep` to locate and print matching lines from `.txt` files, and an alternative `grep` invocation with recursive, line-number, and word-match flags to search the same path. The code uses the POSIX shell commands `find` and `grep`, illustrating their distinct syntaxes for filtering files and matching content. The visualization conveys the practical difference between a file-centric approach and a content-centric approach in text search workflows.

AI-generated description

Similar vizzes

Loading thumbnail…

Finding string in files From http://stackoverflow.com/questions/16956810/finding-all-files-containing-a-text-string-on-linux

The visualization maps the output of a recursive `grep` command, showing which files under a given path contain a specified text pattern. It displays each matching file as a node, with the terminal command and its options (`-rnw`) represented alongside the search results. The rendering uses a custom force-directed layout, likely via `d3.forceSimulation`, to position file nodes and connect them to the central search pattern. The data comes directly from the command’s output, parsed into a hierarchical structure for display.

Aadkdev
76% match
Loading thumbnail…

search and read

This example demonstrates a file-searching utility that locates every `target.txt` file within a directory tree and prints its contents to the console. The code uses the `os.walk` API to traverse directories recursively, collecting paths where the target file exists, then opens and reads each matching file with Python’s built-in `open` function. The rendering approach is purely text-based, with output delivered as sequential lines from each located file. No external visualization libraries are employed; instead, the focus is on demonstrating filesystem traversal and conditional file matching through standard library functions.

CCameron-Grams
59% match
Loading thumbnail…

Displaying directory sizes (e.g. .git, node_modules, etc)

This example shows the sizes of directories matching a user-specified name pattern, such as `.git` or `node_modules`, across a directory tree. It visualizes the disk usage of each matching folder, highlighting how much space different project dependencies or version-control data occupy. The implementation uses a simple shell function that combines `find` with `-prune` to locate matching directories and `du -sh` to report their human-readable sizes. The output is a plain list of sizes and paths, as seen in the included example output, and no external visualization library is required—the result is meant for terminal display or further processing.

AAnsonT
53% match
Loading thumbnail…

Bash one-liners

Two Bash one-liners demonstrate how to process files from the command line. The first uses `find` and `xargs` to locate all `*.aln` files, then pipes each filename into a `sh -c` command that runs `cut` to extract the first column, saving the output as a new file with a `.cut` extension. The second one-liner pipes the output of `file` into a redirect, capturing the file type information for every `*.stderr` file into a text file named `file_types`. The examples use standard Unix tools—`find`, `xargs`, `sh -c`, `cut`, `file`, and shell redirection—to perform file discovery and simple text transformation.

LLeeMendelowitz
50% match
Loading thumbnail…

command line tool for searching notebook code locally and in knowledge repo

This command-line tool searches local IPython notebooks for a text pattern by first using macOS Spotlight’s `mdfind` to locate all `.ipynb` files, then parsing each notebook’s JSON with `jq` to extract code cell sources. It pipes the extracted code through `sed` for string cleanup, `pygmentize` for syntax highlighting, and finally `grep` to match the user-supplied pattern. Matching results are printed with the file path and highlighted code block, enabling fast, targeted code discovery across a project directory.

Aandrewdblevins
48% match
Loading thumbnail…

[check_string_contain_relation]给定 a list of strings，检查哪些字符串元素是其他字符串元素的 substring #string

This example demonstrates a string containment check: given a list of strings, it identifies which elements are substrings of other elements in the list. The code first joins all strings using a separator and then uses recursive string searching to count occurrences. It leverages Python’s built-in `str.find` method within a custom recursive function, `_appear_at_least_n_times`, to efficiently stop searching after finding the required number of matches. The final output is a filtered list containing only those strings that appear at least twice in the combined text, as shown by the example returning `['产科']` for the input `['妇产科', '产科', '儿科']`.

SShawn91
47% match
Loading thumbnail…

Bash tips

This visualization demonstrates an improved command-line technique for processing files with `find` and `xargs`, using `sh -c` to pass the file path as `$0` rather than as a positional argument. The example shows how to pipe a null-delimited list of files from `find -print0` into `xargs -0 -I '{}'`, then execute a shell command that references the file through `sh -c 'echo $0' '{}'`. The rendering displays the raw command syntax as text, highlighting the shell invocation pattern where the `{}` placeholder is substituted directly into the command string. No external data or graphics libraries are involved; the visualization is purely a code snippet.

Aabernier
46% match
Loading thumbnail…

A simple JAVA program for practicing regex.

This Java program provides an interactive way to practice writing regular expressions, with a focus on Latin texts. It offers three practice modes: finding a pattern's index in a user-supplied string, searching a text file for a pattern, and counting the frequency of a pattern in Cicero's First Catilinarian. The program uses Java's Pattern and Matcher classes to handle regex operations, and reads from included Latin text files to provide realistic NLP-style exercises.

TTylerKirby
45% match