grep a tab dans UNIX

si vous utilisez GNU grep, vous pouvez utiliser le perl-style regexp:

$ grep -P '\t' *

le truc est d'utiliser $ sign avant single guillemets. Il fonctionne également pour couper et d'autres outils.

$ grep $'\t' sample.txt

Je n'ai jamais réussi à faire fonctionner le '\t' metacharacter avec grep. Cependant, j'ai trouvé deux solutions de rechange:

1. utilisant <Ctrl-V> <TAB> (tapant Ctrl-V puis tapant tab)
2. utilisant awk: foo | awk '/\t/'

à Partir de cette réponse sur Ask Ubuntu:

dire au grep d'utiliser les expressions régulières telles que définies par Perl (Perl a \t , comme tab):

grep -P "\t" <file name>

utilisez le caractère littéral tab:

grep "^V<tab>" <filename>

utilisez printf pour imprimer un caractère d'onglet pour vous:

grep "$(printf '\t')" <filename>

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

grep -P '\t'

-P active les expressions régulières de Perl pour que \t fonctionne.

en tant Qu'utilisateur détendez-vous dit, il peut être spécifique à GNU grep. L'alternative est, littéralement, insérer un onglet si la coquille, l'éditeur ou le terminal le permet.

Ce n'est pas exactement ce que vous cherchez, mais pourrait fonctionner dans votre cas

grep '[[:blank:]]'

équivalent à

grep -P '[ \t]'

donc il trouvera L'espace et L'étiquette.

§ classes de caractères

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

$ man grep | grep blank | wc
      0       0       0

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

Il y a essentiellement deux façons de l'aborder:

1. ( recommandé ) utilisez la syntaxe d'expression régulière supportée par grep(1). Modern grep (1) supporte deux formes de syntaxe regex POSIX 1003.2: basic (obsolete) REs, et modern REs. La syntaxe est décrite en détail sur les pages de manuel de 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 REs compatibles Perl telles que fournies par la bibliothèque pcre (3).

   en langage regex le symbole de l'onglet est habituellement encodé par \t atome. L'atome est supporté par des expressions régulières étendues BSD ( egrep , grep -E sur un système compatible BSD), ainsi que par des REs compatibles Perl ( pcregrep , GNU grep -P ).

   les expressions régulières de base et les REs étendues de Linux n'ont apparemment aucun support pour les \t . Veuillez consulter la page de manuel de L'utilitaire UNIX pour savoir quel langage regex il supporte (d'où la différence entre les expressions régulières sed(1), awk(1) et pcregrep(1)).

   donc, sur Linux:

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

   sur le système BSD alike:

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

2. passez le caractère de l'onglet dans le modèle. Ceci 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 interpréteur de commandes interactif, vous devrez peut-être vous fier aux capacités de l'interpréteur de commandes et du terminal pour taper le symbole approprié dans la ligne. Sur la plupart des terminaux, cela peut être fait par le biais de la combinaison de touches Ctrl + V qui indique au terminal de traiter le prochain caractère d'entrée de manière littérale (le V est pour "verbatim"):

   $ grep '<Ctrl>+<V><TAB>' FILE ...
   

   certains shells peuvent offrir un support avancé pour la commande de composition. Tel, en bash (1) mots de la forme $'string' 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. En outre, soyez prudent avec les citations lors de l'utilisation des specials, s'il vous plaît consulter bash(1) pour plus de détails.

   Pour le Bourne shell (et pas seulement) le même comportement peut être émulées à l'aide de la substitution de commande augmentée par printf(1) pour construire la bonne regex:

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

une autre façon d'insérer l'onglet littéralement à l'intérieur de l'expression est d'utiliser la moins connue $'\t' citation dans Bash:

grep $'foo\tbar'        # matches eg. 'foo<tab>bar'

(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. `bob2<tab>323`

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

utilisez gawk, définissez le délimiteur de champ À tab (\t) et vérifiez le nombre de champs. Si plus de 1, alors il y a les onglets

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

Un bon choix est d'utiliser sed comme grep' (comme expliqué dans ce classique sed tutoriel ).

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

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

[~]$ cat testfile
12 3
1 4 abc
xa      c
        a       c
1 23

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

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

+1 façon, qui fonctionne en ksh, dash, etc: utiliser printf pour insérer TAB:

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

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

grep "  " *

sur ksh j'ai utilisé

grep "[^I]" testfile

utilisant la méthode 'sed-as-grep', mais remplacer les onglets avec un caractère visible de préférence personnelle est ma méthode préférée, car il montre clairement à la fois les deux fichiers qui contiennent l'information demandée, et aussi où il est placé dans les lignes:

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

si vous souhaitez utiliser les informations de ligne/fichier, ou d'autres options grep, mais aussi de voir le remplacement visible du caractère de l'onglet, vous pouvez y parvenir par

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

en tant que 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: de toute évidence, ce qui précède n'est utile que pour visualiser le contenu du fichier afin de localiser les onglets --- si l'objectif est de gérer les onglets dans le cadre d'une session de script plus grande, cela ne sert à rien.

cela fonctionne bien pour AIX. Je cherche 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 pourriez vouloir utiliser grep "$(echo -e '\t')"

Seule exigence est echo pour être capable de l'interprétation des séquences d'échappement.

ces méthodes binaires alternatives d'identification sont totalement fonctionnelles. Et, j'aime vraiment l'un utilise awk, car je ne pouvais pas tout à fait me souvenir de l'utilisation syntaxique avec des caractères binaires simples. Cependant, il devrait également être possible d'assigner à une variable shell une valeur de façon portable POSIX (i.e. TAB= echo "@" | tr "0" "1" ), puis de l'employer de là partout, de façon portable POSIX; ainsi (I. e grep" $ TAB " filename). Bien que cette solution fonctionne bien avec TAB, elle fonctionnera aussi bien autres caractères binaires, lorsqu'une autre valeur binaire désirée est utilisée dans l'affectation (au lieu de la valeur pour le caractère de L'onglet "tr").

la notation $'\t' donnée dans les autres réponses est spécifique à l'interpréteur de commandes -- elle semble fonctionner dans bash et zsh mais n'est pas universelle.

NOTE: ce qui suit est pour le fish shell et ne fonctionne pas en bash :

dans le shell fish , on peut utiliser un \t , par exemple:

grep \t foo.txt

ou on peut utiliser les notations hex ou unicode p.ex.:

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

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

puisque ces valeurs doivent être non cotées, on peut combiner les valeurs cotées et non cotées par concaténation:

grep "foo"\t"bar"

vous pouvez taper

grep \t foo

grep '\t' foo

pour rechercher le caractère de l'onglet dans le fichier foo. Vous pouvez probablement aussi faire d'autres codes de fuite, bien que je n'ai testé \n. Bien que cela demande beaucoup de temps, et que vous ne sachiez pas pourquoi vous voulez le faire, en zsh vous pouvez aussi taper le caractère de l'onglet, retour au début, grep et entourer l'onglet de guillemets.

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

grep [: space:]*"."."

trouvera quelque chose comme ceci:

'l'onglet' ..

ce sont de simples citations ('), et pas de double (").

C'est comme ça qu'on fait la concaténation en grep. = - )