unix - guia - qgis manual

grep una pestaña en UNIX (22)

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

Básicamente hay dos formas de abordarlo:

( 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 ...
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 ...

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. = -)

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>

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

grep $''/t'' sample.txt

En ksh usé

grep "[^I]" testfile

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

El único requisito es echo para poder interpretar escapes de barra invertida.

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

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

grep ''[[:blank:]]''

Equivalente a

grep -P ''[ /t]''

Así encontrará Espacio y Tab.

§ Clases de personajes.

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

$ man grep | grep blank | wc 0 0 0

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

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"

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

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

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

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

Usando <Ctrl-V> <TAB> (presionando Ctrl-V y luego escribiendo la pestaña)
Utilizando awk: foo | awk ''//t/'' foo | awk ''//t/''

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`

Puede escribir

grep /t foo
o

grep ''/t'' foo

para buscar el caracter de la pestaña en el archivo foo. Probablemente también puede hacer otros códigos de escape, aunque solo lo he probado / n. Aunque consume bastante tiempo y no está claro por qué lo desea, en zsh también puede escribir el carácter de la pestaña, volver al principio, grep y encerrar la pestaña con comillas.

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

grep -P ''/t'' *

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

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.

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.

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

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

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

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