Comment puis-je convertir des tabulations en espaces dans chaque fichier d'un répertoire?

Comment puis-je convertir des tabulations en espaces dans chaque fichier d'un répertoire (éventuellement récursivement)?

Existe-t-il également un moyen de définir le nombre d'espaces par onglet?

Avertissement: cela cassera votre repo.

Ce sera des fichiers binaires corrompus , y compris ceux sous svn, .git! Lisez les commentaires avant d'utiliser!

find . -iname '*.java' -type f -exec sed -i.orig 's/\t/ /g' {} +

Le fichier d'origine est enregistré sous [filename].orig.

Remplacez '* .java' par la fin de fichier du type de fichier que vous recherchez. De cette façon, vous pouvez empêcher la corruption accidentelle des fichiers binaires.

Inconvénients:

• Remplacera les onglets partout dans un fichier.
• Cela prendra du temps si vous avez un vidage SQL de 5 Go dans ce répertoire.

Le remplacement simple avec sedest correct mais n'est pas la meilleure solution possible. S'il y a des espaces "supplémentaires" entre les onglets, ils seront toujours là après la substitution, donc les marges seront irrégulières. Les onglets développés au milieu des lignes ne fonctionneront pas non plus correctement. Dans bash, on peut dire à la place

find . -name '*.java' ! -type d -exec bash -c 'expand -t 4 "$0" > /tmp/e && mv /tmp/e "$0"' {} \;

à appliquer expandà chaque fichier Java dans l'arborescence de répertoires actuelle. Supprimez / remplacez l' -nameargument si vous ciblez d'autres types de fichiers. Comme l'un des commentaires le mentionne, soyez très prudent lorsque vous supprimez -nameou utilisez un caractère générique faible. Vous pouvez facilement assommer le référentiel et d'autres fichiers cachés sans intention. C'est pourquoi la réponse originale incluait ceci:

Vous devez toujours faire une copie de sauvegarde de l'arborescence avant d'essayer quelque chose comme ça au cas où quelque chose se passe mal.

Essayez l'outil de ligne de commande expand.

expand -i -t 4 input | sponge output

où

• -i est utilisé pour développer uniquement les onglets de tête sur chaque ligne;
• -t 4 signifie que chaque onglet sera converti en 4 caractères d'espaces (8 par défaut).
• spongeprovient du moreutilspackage et évite d' effacer le fichier d'entrée .

Enfin, vous pouvez utiliser gexpandsur OSX, après l'installation coreutilsavec Homebrew ( brew install coreutils).

La collecte des meilleurs commentaires de la réponse de Gene , la meilleure solution de loin, consiste à utiliser spongede moreutils .

sudo apt-get install moreutils
# The complete one-liner:
find ./ -iname '*.java' -type f -exec bash -c 'expand -t 4 "$0" | sponge "$0"' {} \;

Explication:

• ./ recherche récursivement à partir du répertoire courant
• -inameest une correspondance insensible à la casse (pour les deux *.javaet les *.JAVAlikes)
• type -f ne trouve que des fichiers normaux (pas de répertoires, binaires ou liens symboliques)
• -exec bash -c exécuter les commandes suivantes dans un sous-shell pour chaque nom de fichier, {}
• expand -t 4 étend tous les TAB à 4 espaces
• spongeabsorber l'entrée standard (de expand) et écrire dans un fichier (le même) *.

REMARQUE : * Une simple redirection de fichier ( > "$0") ne fonctionnera pas ici car elle écraserait le fichier trop tôt .

Avantage : toutes les autorisations de fichiers d'origine sont conservées et aucun tmpfichier intermédiaire n'est utilisé.

Utilisez une barre oblique inversée sed.

Sous Linux:

• Remplacez tous les onglets par 1 tiret en place, dans tous les fichiers * .txt:

  sed -i $'s/\t/-/g' *.txt

• Remplacez tous les onglets par 1 espace en place, dans tous les fichiers * .txt:

  sed -i $'s/\t/ /g' *.txt

• Remplacez tous les onglets par 4 espaces en place, dans tous les fichiers * .txt:

  sed -i $'s/\t/    /g' *.txt

Sur un mac:

• Remplacez tous les onglets par 4 espaces en place, dans tous les fichiers * .txt:

  sed -i '' $'s/\t/    /g' *.txt

Vous pouvez utiliser la prcommande généralement disponible (page de manuel ici ). Par exemple, pour convertir des tabulations en quatre espaces, procédez comme suit:

pr -t -e=4 file > file.expanded

• -t supprime les en-têtes
• -e=numélargit les tabulations en numespaces

Pour convertir tous les fichiers d'une arborescence de répertoires de manière récursive, tout en ignorant les fichiers binaires:

#!/bin/bash
num=4
shopt -s globstar nullglob
for f in **/*; do
  [[ -f "$f" ]]   || continue # skip if not a regular file
  ! grep -qI "$f" && continue # skip binary files
  pr -t -e=$num "$f" > "$f.expanded.$$" && mv "$f.expanded.$$" "$f"
done

La logique pour ignorer les fichiers binaires provient de ce post .

REMARQUE:

1. Cela pourrait être dangereux dans un dépôt git ou svn
2. Ce n'est pas la bonne solution si vous avez des fichiers de code qui ont des onglets intégrés dans des littéraux de chaîne

Comment puis-je convertir des tabulations en espaces dans chaque fichier d'un répertoire (éventuellement récursivement)?

Ce n'est généralement pas ce que vous voulez.

Voulez-vous le faire pour les images png? Fichiers PDF? Le répertoire .git? Votre Makefile(qui nécessite des onglets)? Un vidage SQL de 5 Go?

Vous pourriez, en théorie, passer un grand nombre d'options d'exclusion vers findou tout ce que vous utilisez; mais cela est fragile et se cassera dès que vous ajouterez d'autres fichiers binaires.

Ce que vous voulez, c'est au moins:

1. Ignorez les fichiers d'une certaine taille.
2. Détectez si un fichier est binaire en vérifiant la présence d'un octet NULL.
3. Ne remplacez les onglets qu'au début d'un fichier ( expandfait cela, sed pas).

Pour autant que je sache, il n'y a pas d'utilitaire Unix "standard" qui puisse faire cela, et ce n'est pas très facile à faire avec un shell one-liner, donc un script est nécessaire.

Il y a quelque temps, j'ai créé un petit script appelé sanitize_files qui fait exactement cela. Il corrige également quelques autres trucs communs comme le remplacement \r\npar \n, l'ajout d'une fin\n , etc.

Vous pouvez trouver un script simplifié sans les fonctionnalités supplémentaires et les arguments de ligne de commande ci-dessous, mais je vous recommande d'utiliser le script ci-dessus car il est plus susceptible de recevoir des corrections de bugs et d'autres mises à jour que ce post.

Je voudrais également souligner, en réponse à certaines des autres réponses ici, que l'utilisation de la globalisation du shell n'est pas un moyen robuste de le faire, car tôt ou tard, vous vous retrouverez avec plus de fichiers que ce qui peut en contenir ARG_MAX(sur les modernes Les systèmes Linux, c'est 128k, ce qui peut sembler beaucoup, mais tôt ou tard ce n'est pas suffisant).

#!/usr/bin/env python
#
# http://code.arp242.net/sanitize_files
#

import os, re, sys


def is_binary(data):
    return data.find(b'\000') >= 0


def should_ignore(path):
    keep = [
        # VCS systems
        '.git/', '.hg/' '.svn/' 'CVS/',

        # These files have significant whitespace/tabs, and cannot be edited
        # safely
        # TODO: there are probably more of these files..
        'Makefile', 'BSDmakefile', 'GNUmakefile', 'Gemfile.lock'
    ]

    for k in keep:
        if '/%s' % k in path:
            return True
    return False


def run(files):
    indent_find = b'\t'
    indent_replace = b'    ' * indent_width

    for f in files:
        if should_ignore(f):
            print('Ignoring %s' % f)
            continue

        try:
            size = os.stat(f).st_size
        # Unresolvable symlink, just ignore those
        except FileNotFoundError as exc:
            print('%s is unresolvable, skipping (%s)' % (f, exc))
            continue

        if size == 0: continue
        if size > 1024 ** 2:
            print("Skipping `%s' because it's over 1MiB" % f)
            continue

        try:
            data = open(f, 'rb').read()
        except (OSError, PermissionError) as exc:
            print("Error: Unable to read `%s': %s" % (f, exc))
            continue

        if is_binary(data):
            print("Skipping `%s' because it looks binary" % f)
            continue

        data = data.split(b'\n')

        fixed_indent = False
        for i, line in enumerate(data):
            # Fix indentation
            repl_count = 0
            while line.startswith(indent_find):
                fixed_indent = True
                repl_count += 1
                line = line.replace(indent_find, b'', 1)

            if repl_count > 0:
                line = indent_replace * repl_count + line

        data = list(filter(lambda x: x is not None, data))

        try:
            open(f, 'wb').write(b'\n'.join(data))
        except (OSError, PermissionError) as exc:
            print("Error: Unable to write to `%s': %s" % (f, exc))


if __name__ == '__main__':
    allfiles = []
    for root, dirs, files in os.walk(os.getcwd()):
        for f in files:
            p = '%s/%s' % (root, f)
            if do_add:
                allfiles.append(p)

    run(allfiles)

J'aime l'exemple "trouver" ci-dessus pour l'application récursive. Pour l'adapter pour qu'il soit non récursif, ne modifiant que les fichiers du répertoire en cours qui correspondent à un caractère générique, l'expansion du shell glob peut être suffisante pour de petites quantités de fichiers:

ls *.java | awk '{print "expand -t 4 ", $0, " > /tmp/e; mv /tmp/e ", $0}' | sh -v

Si vous voulez qu'il soit silencieux après avoir vérifié qu'il fonctionne, déposez simplement -vla shcommande à la fin.

Bien sûr, vous pouvez choisir n'importe quel ensemble de fichiers dans la première commande. Par exemple, répertoriez uniquement un sous-répertoire particulier (ou des répertoires) de manière contrôlée comme ceci:

ls mod/*/*.php | awk '{print "expand -t 4 ", $0, " > /tmp/e; mv /tmp/e ", $0}' | sh

Ou, à son tour, exécutez find (1) avec une combinaison de paramètres de profondeur, etc.:

find mod/ -name '*.php' -mindepth 1 -maxdepth 2 | awk '{print "expand -t 4 ", $0, " > /tmp/e; mv /tmp/e ", $0}' | sh

J'avais l'habitude astylede ré-indenter tout mon code C / C ++ après avoir trouvé des tabulations et des espaces mixtes. Il a également des options pour forcer un style d'accolade particulier si vous le souhaitez.

On peut utiliser vimpour cela:

find -type f \( -name '*.css' -o -name '*.html' -o -name '*.js' -o -name '*.php' \) -execdir vim -c retab -c wq {} \;

Comme l'a déclaré Carpetsmoker, il sera retab en fonction de vos vimparamètres. Et les modelines dans les fichiers, le cas échéant. De plus, il remplacera les tabulations non seulement au début des lignes. Ce n'est pas ce que vous voulez généralement. Par exemple, vous pourriez avoir des littéraux contenant des tabulations.

Ma recommandation est d'utiliser:

find . -name '*.lua' -exec ex '+%s/\t/  /g' -cwq {} \;

Commentaires:

1. Utilisez l'édition sur place. Conservez les sauvegardes dans un VCS. Pas besoin de produire des fichiers * .orig. Il est recommandé de comparer le résultat à votre dernier commit pour vous assurer que cela fonctionne comme prévu, dans tous les cas.
2. sedest un éditeur de flux. Utiliser expour l'édition sur place. Cela évite de créer des fichiers temporaires supplémentaires et des coquilles d'apparition pour chaque remplacement, comme dans la première réponse .
3. AVERTISSEMENT: cela dérange tous les onglets, pas seulement ceux utilisés pour l'indentation. De plus, il ne remplace pas les onglets en fonction du contexte. C'était suffisant pour mon cas d'utilisation. Mais cela pourrait ne pas être acceptable pour vous.
4. EDIT: Une version antérieure de cette réponse a été utilisée à la find|xargsplace de find -exec. Comme indiqué par @ gniourf-gniourf, cela entraîne des problèmes avec les espaces, les guillemets et les caractères de contrôle dans les noms de fichiers cf. Wheeler .

Pour convertir récursivement tous les fichiers Java dans un répertoire pour utiliser 4 espaces au lieu d'un onglet:

find . -type f -name *.java -exec bash -c 'expand -t 4 {} > /tmp/stuff;mv /tmp/stuff {}' \;

Vous pouvez utiliser findavectabs-to-spaces package pour cela.

Tout d'abord, installez tabs-to-spaces

npm install -g tabs-to-spaces

ensuite, exécutez cette commande à partir du répertoire racine de votre projet;

find . -name '*' -exec t2s --spaces 2 {} \;

Cela remplacera chaque tabcaractère par 2 spacesdans chaque fichier.

Aucun organisme mentionné rpl? En utilisant rpl, vous pouvez remplacer n'importe quelle chaîne. Pour convertir des tabulations en espaces,

rpl -R -e "\t" "    "  .

très simple.

L'utilisation de expandcomme suggéré dans d'autres réponses semble l'approche la plus logique pour cette seule tâche.

Cela dit, cela peut également être fait avec Bash et Awk au cas où vous souhaiteriez apporter d'autres modifications en même temps.

Si vous utilisez Bash 4.0 ou une version supérieure, la fonction intégrée shopt globstar peut être utilisée pour effectuer une recherche récursive avec **.

Avec GNU Awk version 4.1 ou supérieure, des modifications de fichiers sed comme "inplace" peuvent être effectuées:

shopt -s globstar
gawk -i inplace '{gsub("\t","    ")}1' **/*.ext

Si vous souhaitez définir le nombre d'espaces par tabulation:

gawk -i inplace -v n=4 'BEGIN{for(i=1;i<=n;i++) c=c" "}{gsub("\t",c)}1' **/*.ext

Téléchargez et exécutez le script suivant pour convertir récursivement les onglets matériels en onglets logiciels dans des fichiers en texte brut.

Exécutez le script à l'intérieur du dossier qui contient les fichiers de texte brut.

#!/bin/bash

find . -type f -and -not -path './.git/*' -exec grep -Iq . {} \; -and -print | while read -r file; do {
    echo "Converting... "$file"";
    data=$(expand --initial -t 4 "$file");
    rm "$file";
    echo "$data" > "$file";
}; done;

Méthode conviviale pour le référentiel Git

git-tab-to-space() (
  d="$(mktemp -d)"
  git grep --cached -Il '' | grep -E "${1:-.}" | \
    xargs -I'{}' bash -c '\
    f="${1}/f" \
    && expand -t 4 "$0" > "$f" && \
    chmod --reference="$0" "$f" && \
    mv "$f" "$0"' \
    '{}' "$d" \
  ;
  rmdir "$d"
)

Agissez sur tous les fichiers du répertoire courant:

git-tab-to-space

Agir uniquement sur les fichiers C ou C ++:

git-tab-to-space '\.(c|h)(|pp)$'

Vous le voulez probablement, notamment à cause de ces Makefiles ennuyeux qui nécessitent des onglets.

La commande git grep --cached -Il '':

• répertorie uniquement les fichiers suivis, donc rien à l'intérieur .git
• exclut les répertoires, les fichiers binaires (seraient corrompus) et les liens symboliques (seraient convertis en fichiers normaux)

comme expliqué à: Comment lister tous les fichiers texte (non binaires) dans un dépôt git?

chmod --referenceconserve les autorisations de fichier inchangées: /unix/20645/clone-ownership-and-permissions-from-another-file Malheureusement, je ne trouve pas d'alternative POSIX succincte .

Si votre base de code a eu l'idée folle d'autoriser les onglets bruts fonctionnels dans les chaînes, utilisez:

expand -i

puis amusez-vous à parcourir tous les onglets non en début de ligne un par un, que vous pouvez lister avec: Est-il possible de git grep pour les onglets?

Testé sur Ubuntu 18.04.

Conversion des tabulations en espace en seulement dans des fichiers ".lua" [tabulations -> 2 espaces]

find . -iname "*.lua" -exec sed -i "s#\t#  #g" '{}' \;

Utilisez le vim-way:

$ ex +'bufdo retab' -cxa **/*.*

• ^{Faites la sauvegarde! avant d'exécuter la commande ci-dessus, car cela peut corrompre vos fichiers binaires.}
• ^{Pour utiliser globstar( **) pour la récursivité, activez par shopt -s globstar.}
• ^{Pour spécifier le type de fichier spécifique, utilisez par exemple: **/*.c.}

Pour modifier la tabulation, ajoutez +'set ts=2'.

Cependant, l'inconvénient est qu'il peut remplacer les onglets à l'intérieur des chaînes .

Donc, pour une solution légèrement meilleure (en utilisant la substitution), essayez:

$ ex -s +'bufdo %s/^\t\+/  /ge' -cxa **/*.*

Ou en utilisant exéditeur + expandutilitaire:

$ ex -s +'bufdo!%!expand -t2' -cxa **/*.*

Pour les espaces de fin, voir: Comment supprimer les espaces de fin pour plusieurs fichiers?

Vous pouvez ajouter la fonction suivante dans votre .bash_profile:

# Convert tabs to spaces.
# Usage: retab *.*
# See: https://stackoverflow.com/q/11094383/55075
retab() {
  ex +'set ts=2' +'bufdo retab' -cxa $*
}