grep una pestaña en UNIX

¿Cómo greptabulo (\ t) en archivos en la plataforma Unix?

Si usa GNU grep, puede usar la expresión regular estilo Perl:

grep -P '\t' *

El truco es usar el signo $ antes de las comillas simples . También funciona para cortar y otras herramientas.

grep $'\t' sample.txt

Nunca logré hacer que el metacarácter '\ t' funcione con grep. Sin embargo, encontré dos soluciones alternativas:

1. Usando <Ctrl-V> <TAB>(presionando Ctrl-V y luego escribiendo pestaña)
2. Usando awk: foo | awk '/\t/'

De esta respuesta en Ask Ubuntu:

Dígale a grep que use las expresiones regulares definidas por Perl (Perl tiene \tcomo pestaña):

grep -P "\t" <file name>

Use el carácter de tabulación literal:

grep "^V<tab>" <filename>

Use printfpara imprimir un carácter de tabulación para usted:

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

Una forma es (esto es con Bash)

grep -P '\t'

-P activa las expresiones regulares de Perl para que funcione.

Como dice el usuario desenrollar , puede ser específico de GNU grep. La alternativa es insertar literalmente una pestaña allí si el shell, el editor o la terminal lo permiten.

Otra forma de insertar la pestaña literalmente dentro de la expresión es usar la $'\t'cita menos conocida en Bash:

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

(Tenga en cuenta que si está haciendo coincidir las cadenas fijas, puede usar esto con el modo '-F').

A veces, usar variables puede hacer que la notación sea un poco más legible y manejable:

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

Esto no es exactamente lo que está buscando, pero podría funcionar en su caso

grep '[[:blank:]]'

Equivalente a

grep -P '[ \t]'

Entonces encontrará Space y Tab.

§ Clases de personajes

Tenga en cuenta que no se anuncia en mi man grep, pero aún funciona

$ man grep | grep en blanco | baño
      0 0 0

Use echo para insertar la pestaña por usted grep "$(echo -e \\t)"

Básicamente hay dos formas de abordarlo:

1. ( Recomendado ) Utilice la sintaxis de expresión regular compatible con grep (1). Modern grep (1) admite dos formas de sintaxis de expresiones regulares POSIX 1003.2: RE básicas (obsoletas) y RE modernas . La sintaxis se describe en detalle en las páginas de comando man re_format (7) y regex (7) que forman parte de los sistemas BSD y Linux, respectivamente. GNU grep (1) también es compatible con REs compatibles con Perl según lo provisto por la biblioteca pcre (3).

   En lenguaje regex, el símbolo de tabulación generalmente está codificado por \tátomo. El átomo está soportado por BSD extendió expresiones regulares ( egrep, grep -Een el sistema compatible BSD), así como REs compatibles con Perl ( pcregrep, GNU grep -P).

   Aparentemente, tanto las expresiones regulares básicas como los RE extendidos de Linux no tienen soporte para \t. Consulte la página de manual de la utilidad UNIX para saber qué lenguaje de expresiones regulares admite (de ahí la diferencia entre las expresiones regulares sed (1), awk (1) y pcregrep (1)).

   Por lo tanto, en Linux:

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

   En el sistema BSD por igual:

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

2. Pase el carácter de tabulación al patrón. Esto es sencillo cuando edita un archivo de script:

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

   Sin embargo, cuando trabaje en un shell interactivo, es posible que deba confiar en las capacidades de shell y terminal para escribir el símbolo adecuado en la línea. En la mayoría de los terminales, esto se puede hacer a través de la combinación de teclas Ctrl+ Vque le indica al terminal que trate el siguiente carácter de entrada literalmente ( Ves para "textualmente"):

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

   Algunos shells pueden ofrecer soporte avanzado para la composición tipográfica de comandos. Tal, en bash (1) las palabras del formulario $'string'se tratan especialmente:

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

   Sin embargo, tenga en cuenta que, si bien es agradable en una línea de comandos, esto puede producir problemas de compatibilidad cuando el script se moverá a otra plataforma. Además, tenga cuidado con las citas cuando use las ofertas especiales, consulte bash (1) para obtener más detalles.

   Para el shell Bourne (y no solo) se puede emular el mismo comportamiento utilizando la sustitución de comandos aumentada por printf (1) para construir la expresión regular adecuada:

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

grep "$(printf '\t')" funcionó para mí en Mac OS X

use gawk, establezca el delimitador de campo en tab (\ t) y verifique el número de campos. Si hay más de 1, entonces hay pestañas

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

Una buena opción es usar 'sed as grep' (como se explica en este tutorial clásico de sed ).

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

Ejemplos (funciona en bash, sh, ksh, csh, ..):

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

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

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

+1 forma, que funciona en ksh, dash, etc.: use printf para insertar TAB:

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

La respuesta es más simple. Escriba su grep y dentro de la cita escriba la tecla de tabulación, funciona bien al menos en ksh

grep "  " *

En ksh solía

grep "[^I]" testfile

Usar el método 'sed-as-grep', pero reemplazar las pestañas con un carácter visible de preferencia personal es mi método favorito, ya que muestra claramente qué archivos contienen la información solicitada y también dónde se coloca dentro de las líneas:

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

Si desea hacer uso de la información de línea / archivo u otras opciones grep, pero también quiere ver el reemplazo visible para el carácter de tabulación, puede lograr esto al

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

Como ejemplo:

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

EDITAR: Obviamente, lo anterior solo es útil para ver el contenido del archivo para localizar pestañas --- si el objetivo es manejar pestañas como parte de una sesión de secuencia de comandos más grande, esto no sirve para ningún propósito útil.

Esto funciona bien para AIX. Estoy buscando líneas que contenganJOINED<\t>ACTIVE

voradmin cluster status | grep  JOINED$'\t'ACTIVE

 vorudb201   1       MEMBER(g) JOINED        ACTIVE
*vorucaf01   2       SECONDARY JOINED        ACTIVE

Es posible que desee utilizar grep "$(echo -e '\t')"

El único requisito es echoser capaz de interpretar escapes de barra invertida.

Estos métodos alternativos de identificación binaria son totalmente funcionales. Y, realmente me gusta que alguien esté usando awk, ya que no podía recordar el uso sintáctico con caracteres binarios individuales. Sin embargo, también debería ser posible asignar un valor a una variable de shell de una manera portátil POSIX (es decir, TAB = echo "@" | tr "\100" "\011"), y luego emplearlo desde allí en todas partes, de manera portátil POSIX; también (es decir, nombre de archivo grep "$ TAB"). Si bien esta solución funciona bien con TAB, también funcionará bien con otros caracteres binarios, cuando se utiliza otro valor binario deseado en la asignación (en lugar del valor para el carácter TAB a 'tr').

La notación $ '\ t' dada en otras respuestas es específica de shell: parece funcionar en bash y zsh pero no es universal.

NOTA: Lo siguiente es para el fishshell y no funciona en bash :

En el fishshell, se puede usar un sin comillas \t, por ejemplo:

grep \t foo.txt

O uno puede usar las notaciones hexadecimales o unicode, por ejemplo:

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

(estas anotaciones son útiles para más caracteres esotéricos)

Dado que estos valores deben estar sin comillas, se pueden combinar valores con comillas y sin comillas por concatenación:

grep "foo"\t"bar"

Puedes escribir

grep \ t foo

grep '\ t' foo

para buscar el carácter de tabulación en el archivo foo. Probablemente también pueda hacer otros códigos de escape, aunque solo he probado \ n. Aunque es bastante lento y no está claro por qué querría hacerlo, en zsh también puede escribir el carácter de tabulación, volver al principio, grep y encerrar la tabulación con comillas.

Busque espacios en blanco muchas veces [[: espacio:]] *

grep [[: espacio:]] * '.' '.'

Encontrará algo como esto:

'la tabla' ..

Estas son comillas simples ('), y no dobles (").
Así es como se hace la concatenación en grep. = -)