find

> $ tldr find

  Trouve récursivement des fichiers ou des dossiers dans l'arborescence spécifiée.
  Plus d'informations : <https://manned.org/find>.

  Trouve des fichiers par extension :

      find racine -name '*.ext'

  Trouve des fichiers correspondant à plusieurs chemins ou motifs :

      find racine -path '**/chemin/**/*.ext' -or -name '*motif*'

  Trouve des dossiers correspondant à un nom donné sans vérifier la casse :

      find racine -type d -iname '*lib*'

  Trouve des fichiers correspondant à un motif donné en excluant certains chemins de la recherche :

      find racine -name '*.py' -not -path '*/site-packages/*'

  Trouve des fichiers dans une fourchette de tailles et limite la profondeur récursive à "1" :

      find racine -maxdepth 1 -size +500k -size -10M

  Exécute une commande pour chaque fichier (utiliser `{}` dans la commande pour utiliser le nom des fichiers) :

      find racine -name '*.ext' -exec wc -l {} \;

  Trouve les fichiers modifiés dans les 7 derniers jours :

      find racine -daystart -mtime -7

  Trouve les fichiers vides (de taille nulle) et les supprimer :

      find racine -type f -empty -delete

  tldr perso

  négation

      find  /tmp \! -type d
      find  /tmp -not -type d

  ALIAS :

  find from name in current directory

      function ff() { find . -type f -iname '*'$*'*' -ls ; }
      function ff() { find . -type f -iname '*'$*'*' -exec exa -l {} \; }

grep

> $ tldr grep
  Recherche des motifs dans un texte.
  Supporte des motifs simples et des expressions régulières.
  Plus d'informations : <https://www.gnu.org/software/grep/manual/grep.html>.

  Recherche une chaîne de caractères précise :

      grep "chaîne_recherchée" chemin/vers/fichier

  Recherche en ignorant la casse :

      grep [-F|--fixed-strings] "chaîne_recherchée" chemin/vers/fichier

  Recherche récursivement (en ignorant les fichiers non-texte) dans le dossier courant une chaîne de caractères précise :

      grep [-r|--recursive] [-n|--line-number] "chaîne_recherchée" .

  Utilise des expressions régulières étendues (supporte `?`, `+`, `{}`, `()` et `|`) :

      grep [-Ei|--extended-regexp --ignore-case] expression_régulière chemin/vers/fichier

  Affiche 3 lignes de [C]ontexte, avant ([B]efore), ou [A]près chaque concordance :

      grep --context|--before-context|--after-context 3 "chaîne_recherchée" chemin/vers/fichier

  Affiche le nom du fichier avec la ligne correspondante pour chaque concordance :

      grep [-Hn|--with-filename --line-number] --color=always "chaîne_recherchée" chemin/vers/fichier

  Utilise l'entrée standard au lieu d'un fichier :

      cat chemin/vers/fichier | grep "chaîne_recherchée"

fd

> $ tldr fd

  An alternative to `find`.
  Aims to be faster and easier to use than `find`.
  More information: <https://github.com/sharkdp/fd#how-to-use>.

  Recursively find files matching a specific pattern in the current directory:

      fd "string|regex"

  Find files that begin with a specific string:

      fd "^string"

  Find files with a specific extension:

      fd [-e|--extension] txt

  Find files in a specific directory:

      fd "string|regex" path/to/directory

  Include ignored and hidden files in the search:

      fd [-H|--hidden] [-I|--no-ignore] "string|regex"

  Execute a command on each search result returned:

      fd "string|regex" [-x|--exec] command

rg

> $ tldr rg

  Ripgrep, a recursive line-oriented search tool.
  Aims to be a faster alternative to `grep`.
  More information: <https://github.com/BurntSushi/ripgrep/blob/master/GUIDE.md>.

  Recursively search current directory for a pattern (regular expression):

      rg pattern

  Recursively search for a pattern in a file or directory:

      rg pattern path/to/file_or_directory

  Include hidden files and entries listed in `.gitignore`:

      rg [-.|--hidden] --no-ignore pattern

  Only search the files whose names match the glob pattern(s) (e.g. `README.*`):

      rg pattern [-g|--glob] filename_glob_pattern

  Recursively list filenames in the current directory that match a pattern:

      rg --files | rg pattern

  Only list matched files (useful when piping to other commands):

      rg [-l|--files-with-matches] pattern

  Show lines that do not match the pattern:

      rg [-v|--invert-match] pattern

  Search for a literal string pattern:

      rg [-F|--fixed-strings] -- string