español - grep una pestaña en UNIX




qgis guia (19)

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


Answers

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

grep [[: space:]] * '.' '.'

Encontrará algo como esto:

'la tabla' ..

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


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

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

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

A veces, el uso de 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`

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

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

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 de grep, pero también desea ver el reemplazo visible del carácter de tabulación, puede lograrlo con

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 de los archivos para ubicar las pestañas: si el objetivo es manejar las pestañas como parte de una sesión de secuencias de comandos más amplia, esto no sirve para nada.


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 "  " *

Esto funciona bien para AIX. Estoy buscando líneas que contengan JOINED<\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 echo para poder interpretar escapes de barra invertida.


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

NOTA: Lo siguiente es para la cáscara de fish y no funciona en bash :

En la cáscara de fish , se puede usar un \t comillas, por ejemplo:

grep \t foo.txt

O se puede usar las notaciones hexadecimales o Unicode, por ejemplo:

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

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

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

grep "foo"\t"bar"

grep "$(printf '\t')" me funcionó en Mac OS X


Una buena opción es usar 'sed como 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

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 la pestaña)
  2. Utilizando awk: foo | awk '/\t/' foo | awk '/\t/'

Una forma es (esto es con Bash)

grep -P '\t'

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

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


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


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

grep -P '\t' *

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

grep $'\t' sample.txt

De esta respuesta en Ask Ubuntu:

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

grep -P "\t" <file name>

Utilice el carácter de tabulación literal:

grep "^V<tab>" <filename>

Utilice printf para imprimir un carácter de tabulación para usted:

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

Básicamente hay dos formas de abordarlo:

  1. ( Recomendado ) Use 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ásicos (obsoletos) y RE modernos . La sintaxis se describe en detalle en las páginas de manual de re_format (7) y regex (7) que forman parte de los sistemas BSD y Linux respectivamente. El grep (1) de GNU también admite RE compatibles con Perl según lo proporciona la biblioteca pcre (3).

    En el lenguaje regex, el símbolo de la pestaña generalmente está codificado por \t atom. El átomo es compatible con las expresiones regulares extendidas BSD ( egrep , grep -E en un sistema compatible con BSD), así como con pcregrep compatibles con Perl ( pcregrep , GNU grep -P ).

    Las expresiones regulares básicas y los RE extendidos de Linux aparentemente no tienen soporte para el \t . Consulte la página del manual de utilidades de 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. Pasa la pestaña del personaje al patrón. Esto es sencillo cuando editas 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 del shell y del 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 Ctrl teclas Ctrl + V que le indica al terminal que trate el siguiente carácter de entrada literalmente (la V es para "literalmente"):

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

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

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

    Sin embargo, tenga en cuenta que, aunque 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 utilice las ofertas especiales, consulte a bash (1) para obtener más información.

    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 correcta:

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

En ksh usé

grep "[^I]" testfile

Debajo de la respuesta es buena

grep -r -i --include \*.h --include \*.cpp CP_Image ~/path[12345] | mailx -s GREP [email protected]

Pero se puede actualizar a:

grep -r -i --include \*.{h,cpp} CP_Image ~/path[12345] | mailx -s GREP [email protected]

Lo que puede ser más simple.





unix grep