grep un onglet sous UNIX

Si vous utilisez GNU grep, vous pouvez utiliser le regexp de style Perl:

 $ grep -P '\t' * 

L’astuce consiste à utiliser $ sign avant les guillemets simples . Il fonctionne également pour les outils de coupe et autres.

 $ grep $'\t' sample.txt 

Je n’ai jamais réussi à faire fonctionner le métacaractère ‘\ t’ avec grep. Cependant, j’ai trouvé deux solutions alternatives:

1. Utiliser (en appuyant sur Ctrl-V puis en tapant l’onglet)
2. Utiliser awk: foo | awk '/\t/' foo | awk '/\t/'

De cette réponse sur Ask Ubuntu:

Dites à grep d’utiliser les expressions régulières telles que définies par Perl (Perl a \t tant qu’onglet):

 grep -P "\t"  

Utilisez le caractère de tabulation littérale:

 grep "^V"  

Utilisez printf pour imprimer un caractère de tabulation pour vous:

 grep "$(printf '\t')"  

Une façon est (c’est avec Bash)

 grep -P '\t' 

-P active les expressions régulières Perl, donc \ t fonctionnera.

Comme l’utilisateur le dit, cela peut être spécifique à GNU grep. L’alternative consiste à insérer littéralement un onglet si le shell, l’éditeur ou le terminal le permet.

Ce n’est pas exactement ce que vous recherchez, mais pourrait fonctionner dans votre cas

 grep '[[:blank:]]' 

Équivalent à

 grep -P '[ \t]' 

Donc, il trouvera un espace et une tabulation.

§ Cours de caractères

Note, il n’est pas annoncé dans mon man grep , mais fonctionne toujours

 $ man grep |  grep blank |  canvasttes
       0 0 0

Utilisez echo pour insérer l’onglet pour vous grep "$(echo -e \\t)"

Il y a essentiellement deux façons de le résoudre:

1. ( Recommandé ) Utilisez la syntaxe d’expression régulière prise en charge par grep (1). Le grep moderne (1) prend en charge deux formes de syntaxe d’expression rationnelle POSIX 1003.2: les ER de base (obsolètes) et les ER modernes . La syntaxe est décrite en détail sur les pages de manuel re_format (7) et regex (7) qui font respectivement partie des systèmes BSD et Linux. Le GNU grep (1) prend également en charge les ER compatibles Perl fournies par la bibliothèque pcre (3).

   En langage regex, le symbole de tabulation est généralement codé par \t atom. L’atome est supporté par les expressions régulières étendues BSD ( egrep , grep -E sur un système compatible BSD), ainsi que les RE compatibles Perl ( pcregrep , GNU grep -P ).

   Les expressions rationnelles de base et les ER étendues de Linux n’ont apparemment pas de support pour le \t . Veuillez consulter la page de manuel de l’utilitaire UNIX pour savoir quel langage regex il prend en charge (d’où la différence entre les expressions régulières sed (1), awk (1) et pcregrep (1)).

   Par conséquent, sous Linux:

    $ grep -P '\t' FILE ... 

   Sur le système BSD:

    $ egrep '\t' FILE ... $ grep -E '\t' FILE ... 

2. Transmettez le caractère de tabulation en motif. C’est simple lorsque vous éditez un fichier de script:

    # no tabs for Python please! grep -q ' ' *.py && exit 1 

   Cependant, lorsque vous travaillez dans un shell interactif, vous devrez peut-être vous fier aux capacités du terminal et du shell pour saisir le symbole approprié dans la ligne. Sur la plupart des terminaux, cela peut se faire par la combinaison de touches Ctrl + V qui demande au terminal de traiter littéralement le caractère d’entrée suivant (le V est pour “verbatim”):

    $ grep '+' FILE ... 

   Certains shells peuvent offrir un support avancé pour la composition des commandes. De tels mots de bash (1) de la forme $'ssortingng' sont traités spécialement:

    bash$ grep $'\t' FILE ... 

   S’il vous plaît noter cependant, tout en étant agréable dans une ligne de commande, cela peut produire des problèmes de compatibilité lorsque le script sera déplacé vers une autre plate-forme. Aussi, soyez prudent avec les citations lorsque vous utilisez les offres spéciales, veuillez consulter bash (1) pour plus de détails.

   Pour le shell Bourne (et pas seulement), le même comportement peut être émulé en utilisant une substitution de commande augmentée par printf (1) pour construire une expression régulière appropriée:

    $ grep "`printf '\t'`" FILE ... 

grep "$(printf '\t')" fonctionné pour moi sur Mac OS X

Une autre façon d’insérer littéralement l’onglet dans l’expression consiste à utiliser la citation moins connue de $'\t' dans Bash:

 grep $'foo\tbar' # matches eg. 'foobar' 

(Notez que si vous correspondez à des chaînes fixes, vous pouvez l’utiliser avec le mode «-F».)

Parfois, l’utilisation de variables peut rendre la notation un peu plus lisible et gérable:

 tab=$'\t' # or `tab=$(printf '\t')` in POSIX 'sh' id='[[:digit:]]\+' name='[[:alpha:]_][[:alnum:]_-]*' grep "$name$tab$id" # matches eg. `bob2323` 

Un bon choix consiste à utiliser ‘sed as grep’ (comme expliqué dans ce tutoriel sed classique).

 sed -n 's/pattern/&/p' file 

Exemples (fonctionne en bash, sh, ksh, csh, ..):

 [~]$ cat testfile 12 3 1 4 abc xa c ac\2 1 23 

 [~]$ sed -n 's/\t/&/p' testfile xa c ac\2 

 [~]$ sed -n 's/\ta\t/&/p' testfile ac\2 

+1 manière, qui fonctionne dans ksh, dash, etc.: utilisez printf pour insérer TAB:

 grep "$(printf 'BEGIN\tEND')" testfile.txt 

utilisez gawk, définissez le séparateur de champs sur tab (\ t) et vérifiez le nombre de champs. Si plus de 1, alors il y a / sont des tabs

 awk -F"\t" 'NF>1' file 

La réponse est plus simple. Écrivez votre grep et dans la citation tapez la touche de tabulation, cela fonctionne bien au moins dans ksh

 grep " " * 

Sur ksh j’ai utilisé

 grep "[^I]" testfile 

Utiliser la méthode «sed-as-grep», mais remplacer les tabs par un caractère visible de préférence personnelle est ma méthode préférée, car elle montre clairement à la fois quels fichiers contiennent les informations demandées et où ils sont placés dans les lignes:

 sed -n 's/\t/\*\*\*\*/g' file_name 

Si vous souhaitez utiliser les informations de ligne / fichier ou d’autres options de grep, mais souhaitez également voir le remplacement visible du caractère de tabulation, vous pouvez le faire en

 grep -[options] -P '\t' file_name | sed 's/\t/\*\*\*\*/g' 

Par exemple:

 $ echo "A\tB\nfoo\tbar" > test $ grep -inH -P '\t' test | sed 's/\t/\*\*\*\*/g' test:1:A****B test:2:foo****bar 

EDIT: Évidemment, ce qui précède n’est utile que pour afficher le contenu des fichiers afin de localiser les tabs. Si l’objective est de gérer les tabs dans le cadre d’une session de script plus importante, cela ne sert à rien.

Cela fonctionne bien pour AIX. Je recherche des lignes contenant JOINED<\t>ACTIVE

 voradmin cluster status | grep JOINED$'\t'ACTIVE vorudb201 1 MEMBER(g) JOINED ACTIVE *vorucaf01 2 SECONDARY JOINED ACTIVE 

Vous voudrez peut-être utiliser grep "$(echo -e '\t')"

La seule exigence est que l’ echo soit capable d’interpréter les évasions de backslash.

Ces méthodes d’identification binarys alternatives sont totalement fonctionnelles. Et, j’aime vraiment celui qui utilise awk, car je ne pouvais pas me souvenir de l’utilisation syntaxique avec des caractères binarys simples. Cependant, il devrait également être possible d’affecter une variable shell à une valeur POSIX portable (c.-à-d. TAB = echo "@" | tr "\100" "\011" ), puis de l’utiliser partout, dans un POSIX. mode portable; ainsi (ex: grep “$ TAB” filename). Bien que cette solution fonctionne bien avec TAB, elle fonctionnera également bien avec les autres caractères binarys, lorsqu’une autre valeur binary souhaitée est utilisée dans l’affectation (au lieu de la valeur du caractère TAB à «tr»).

La notation $ ‘\ t’ donnée dans les autres réponses est spécifique au shell – elle semble fonctionner dans bash et zsh mais n’est pas universelle.

REMARQUE: Ce qui suit est pour le fish et ne fonctionne pas dans bash :

Dans le shell de fish , on peut utiliser un \t non cité, par exemple:

 grep \t foo.txt 

Ou on peut utiliser les notations hex ou unicode par exemple:

 grep \X09 foo.txt grep \U0009 foo.txt 

(ces notations sont utiles pour les caractères plus ésotériques)

Comme ces valeurs doivent être non cotées, on peut combiner des valeurs entre guillemets et non cotés par concaténation:

 grep "foo"\t"bar" 

Vous pouvez taper

 grep \ t foo 

ou

 grep '\ t' foo

pour rechercher le caractère de tabulation dans le fichier foo. Vous pouvez probablement aussi faire d’autres codes d’échappement, même si je n’ai fait que tester \ n. Bien que cela prenne beaucoup de temps et que vous ne compreniez pas pourquoi, dans zsh, vous pouvez également taper le caractère de tabulation, revenir au début, grep et joindre l’onglet à des guillemets.

Recherchez des espaces vides plusieurs fois [[: space:]] *

grep [[: space:]] * ‘.’ ‘.’

Va trouver quelque chose comme ça:

‘l’onglet’ ..

Ce sont des guillemets simples (‘), et non doubles (“).
Voici comment vous faites la concaténation dans grep. = -)