Provided by: manpages-es_4.18.1-1_all bug

NOMBRE

       grep, egrep, fgrep - rgrep - muestran líneas que concuerdan con un patrón

SINOPSIS

       grep [OPCIÓN...] PATRONES [ARCHIVO...]
       grep [OPCIÓN...] -e PATRONES ... [ARCHIVO...]
       grep [OPCIÓN...] -f ARCHIVO_PATRÓN ... [ARCHIVO...]

DESCRIPCIÓN

       grep  busca  PATRONES en cada ARCHIVO. PATRONES consistirá en uno o más patrones separados
       entre sí por un salto de línea; grep mostrará cada línea donde encuentre una  concordancia
       con  dicho patrón. En general, deben entrecomillarse los patrones si se ejecut grep dentro
       de otra orden de la shell.

       Si definimos ARCHIVO como '-', se considerará la entrada estándar. Si nose  define  ningún
       valor para ARCHIVO, se hará una búsqueda recursiva del directorio actual y no recursiva de
       la entrada estándar.

       Debian also includes the variant programs egrep, fgrep and rgrep.  These programs are  the
       same  as  grep -E,  grep -F,  and  grep -r,  respectively.   These variants are deprecated
       upstream, but Debian provides for backward compatibility. For portability reasons,  it  is
       recommended to avoid the variant programs, and use grep with the related option instead.

OPCIONES

   Información genérica de la aplicación
       --help Muestra una breve instrucción de uso y finaliza.

       -V, --version
              Muestra la versión de grep y termina.

   Sintaxis del patrón
       -E, --extended-regexp
              Interpreta PATRONES como una expresión regular extendida (vea más adelante).

       -F, --fixed-strings
              Interpreta PATRONES como una cadena de texto, no como expresiones regulares.

       -G, --basic-regexp
              Interpreta  PATRONES  como una expresión regular básica (vea más abajo). Éste es el
              comportamiento predeterminado.

       -P, --perl-regexp
              Interpreta PATRONES como un expresión regular de Perl (PCRE). Esta  opción  aún  es
              experimental  si se combina con -z (--vacío), grep -P puede emitir avisos acerca de
              funciones no implementadas.

   Gestión de las concordancias
       -e PATRONES, --regexp=PATRONES
              Emplea PATRONES como patrones. Si se usa varias veces o se combina con la opción -f
              (--file)  la búsqueda se realizará con todos los patrones dado. Esta opción es útil
              para proteger un patrón que comience por '-'.

       -f ARCHIVO, --file=ARCHIVO
              Obtiene el patrón de ARCHIVO, uno de cada línea. Si se emplea  esta  opción  varias
              veces o se combina con -e (--regexp) realiza la búsqueda con todos los patrones que
              se indiquen. Un archivo vacío contiene cero patrones y no concordará con nada.

       -i, --ignore-case
              No distingue entre mayúsculas y minúsculas tanto en los patrones como en los  datos
              de  entrada, así que los caracteres que sólo difieran en este aspecto resultarán en
              una coincidencia.

       --no-ignore-case
              Distingue entre mayúsculas y minúsculas tanto en los patrones como en los datos  de
              entrada  (comportamiento  por defecto). Esta opción es útil en el caso de emplearse
              en scripts de shell donde se haya definido previamente la opción -i  ya  que  ambas
              opciones se anulan entre sí.

       -v, --invert-match
              Invierte el sentido de la concordancia, seleccionando las líneas que no concuerden.

       -w, --word-regexp
              Selecciona  solamente  aquellas  líneas  que  contienen  concordancias  que  forman
              palabras completas. La  comprobación  consiste  en  que  la  cadena  de  caracteres
              concordante  debe estar al principio de la línea o precedida por un carácter que no
              forme parte de una palabra. De forma similar, debe estar o al final de la  línea  o
              ser  seguida  por  un  carácter  no constituyente de palabra. Los caracteres que se
              consideran como parte de palabras son letras, dígitos  y  el  subrayado.  No  tiene
              efecto si también de define la opción -x.

       -x, --line-regexp
              Selecciona  únicamente  las  línea  que  concuerden  completa  y  exactamente en su
              totalidad con el patrón. Equivaldría, en  el  caso  de  una  expresión  regular,  a
              definir el patrón entre paréntesis comenzando con ^ y finalizando con $.

   Gestión general de la salida
       -c, --count
              Suprime  la  salida  normal; en su lugar muestra el número de líneas que concuerdan
              con el patrón para cada archivo de entrada.   Con  la  opción  -v,  --invert-match,
              contabiliza el número de líneas que no concuerdan.

       --color[=CUANDO], --colour[=CUANDO]
              Rodea  las  cadenas  concordantes  (que  no  estén en blanco), líneas concordantes,
              nombres de archivo, números de línea, bytes de compensación y separadores (para los
              campos y grupos de líneas contextuales) con secuencias de escape para mostrarlas en
              distintos colores a través del terminal. Dichos colores se definen a través  de  la
              variable  de  entorno GREP_COLORS. Los colores se definen mediante las variables de
              entorno . CUANDO  puede  tener  tres  valores  diferentes:  never  (nunca),  always
              (siempre) o auto.

       -L, --files-without-match
              Suprime  la salida normal; en su lugar muestra el nombre de cada archivo de entrada
              donde no se encuentre ninguna concordancia y por lo tanto de cada  fichero  que  no
              produciría ninguna salida.

       -l, --files-with-matches
              Suprime  la salida normal; en su lugar muestra el nombre de cada fichero de entrada
              que produciría alguna salida. La búsqueda de cada entrada se detendrá en la primera
              concordancia.

       -m NÚM, --max-count=NÚM
              Stop  reading  a  file  after NUM matching lines.  If NUM is zero, grep stops right
              away without reading input.  A NUM of -1 is treated as infinity and grep  does  not
              stop; this is the default.  If the input is standard input from a regular file, and
              NUM matching lines are output, grep ensures that the standard input  is  positioned
              to  just after the last matching line before exiting, regardless of the presence of
              trailing context lines.  This enables a calling process to resume a  search.   When
              grep  stops  after NUM matching lines, it outputs any trailing context lines.  When
              the -c or --count option is also used, grep does not output a  count  greater  than
              NUM.   When  the  -v  or  --invert-match  option  is  also  used,  grep stops after
              outputting NUM non-matching lines.

       -o, --only-matching
              Muestra sólo la parte coincidente con el patrón de una línea  concordante,  siempre
              que no sea una cadena vacía y poniendo cada parte en una línea diferente.

       -q, --quiet, --silent
              Mínima  salida.  No  muestra nada en la salida estándar. Termina con estado cero si
              encuentra alguna concordancia aunque  detecte  algún  error.  Consulte  también  la
              opción -s o --no-messages.

       -s, --no-messages
              Suprime los mensajes de error sobre archivos que no existen o no se pueden leer.

   Muestra un prefijo de control en cada línea
       -b, --byte-offset
              Muestra  el  desplazamiento  de  bytes,  comenzando  en cero, dentro del archivo de
              entrada antes de cada línea mostrada. Si se define -o (-only-matching), muestra  el
              desplazamiento de la parte concordante.

       -H, --with-filename
              Muestra  el  nombre  del archivo donde se produjo la concordancia. Esto se hará por
              defecto cuando se busque en más de un archivo. Es una extensión de GNU.

       -h, --no-filename
              No muestra los nombres de archivo antes de cada línea.  Es  el  comportamiento  por
              defecto cuando se realiza la búsqueda en un solo archivo o en la entrada estandar.

       --label=ETIQUETA
              Muestra  la entrada provienente de la entrada estándar como entrada proveniente del
              archivo LABEL. Esto puede ser útil para las órdenes que transforman el contenido de
              un  archivo  antes  de  realizar  la  búsqueda. Por ejemplo: gzip -cd foo.gz | grep
              --label=foo -H 'algún patrón'. Consulte también la opción -H.

       -n, --line-number
              Antepone a cada línea mostrada  el  número  de  línea  de  su  archivo  de  entrada
              correspondiente comenzando por el 1.

       -T, --initial-tab
              Se  asegura  que  el  primer caracter de la línea actual esté en una tabulación, de
              modo que la alineación de las tabulaciones parezca normal. Esto  es  útil  con  las
              opciones  que  anteponen su salida al contenido real: -H, -n y -b. Para incrementar
              la probabilidad de que todas las líneas de un mismo archivo comiencen en  la  misma
              columna,  también  hace  que  el  número  de línea y el desplazamiento de bytes (si
              existe) se impriman en un ancho de campo mínimo.

       -Z, --null
              Muestra  un  byte  cero  (el  carácter  ASCII  NUL)  en  lugar  del  carácter   que
              habitualmente  seguiría  al  nombre  de un archivo. Por ejemplo: grep -lZ genera un
              byte cero después de cada nombre de archivo en lugar del salto de  línea  habitual.
              Esta  opción  hace que la salida no sea ambigua, incluso con nombres de archivo que
              contengan caracteres poco usuales como saltos de línea. Esta opción se  puede  usar
              con órdenes como find -print0, perl -0, sort -z y xargs -0 para procesar nombres de
              archivos arbitrarios, incluso aquellos que contienen saltos de línea en su nombre.

   Gestión de Líneas Contextuales
       -A NÚM, --after-context=NÚM
              Imprime NUM líneas de contexto posterior después de las líneas concordantes. Coloca
              una  línea  que  contiene  un  separador  de  grupo  (--) entre grupos contiguos de
              coincordancias. Con la opción -o  o  --only-matching,  se  emitirá  un  mensaje  de
              advertencia y no tendrá ningún efecto.

       -B NÚM, --before-context=NÚM
              Imprime  NUM  cantidad  de  líneas de contexto respecto de la concordante. Añade un
              separador (--) entre grupos de concordancias. Si se  emplea  con  la  opción  -o  o
              --only-matching, no tendrá ningún efecto y se emitirá un aviso.

       -C NÚM, -NÚM, --context=NÚM
              Muestra  NUM  líneas  contextuales.  Inserta  una línea con un separador (--) entre
              grupos contiguos de concordancias. Si se usa la opción  -o  o  --only-matching,  se
              emite un mensaje de advertencia y no tendrá ningún efecto.

       --group-separator=SEP
              Cuando  se  usen  las  opciones  -A,  -B  o -C, emplea SEP en lugar de -- entre los
              distintos grupos de líneas.

       --no-group-separator
              Cuando se usen las opciones -A, -B o -C, no  me  mostrará  ningún  separador  entre
              líneas.

   Selección de archivos y directorios
       -a, --text
              Procesa  un  archivo  binario  como  si  se  tratase de texto. Equivale a la opción
              --binary-files=text.

       --binary-files=TIPO
              Si los datos o metadatos de un archivo indican que su contenido es  binario,  asume
              que  dicho  archivo es del tipo TIPO. Los bytes que no codifican texto, indican que
              el contenido es binario; estos podrán ser bytes incorrectamente codificados para la
              localización en uso o bytes nulos si no se indicó la opción -z.

              Por defecto, TIPO se considera binary, con lo cual grep elimina cualquier salida si
              se encuentra con datos binarios o datos incorrectamente codificados. Cada  vez  que
              se  elimina  algo  en  la  salida,  grep  mostrará un mensaje en la salida de error
              estándar informando de la concordancia con un archivo binario.

              Si TIPO es without-match, grep asumirá que no hay concordancia alguna en  el  resto
              del archivo si se encuentra contenido nulo binarios. Esto equivale a la opción -I.

              Si  TIPO  es  texto, grep procesará un archivo binario como si se tratase de texto.
              Equivale a la opción -a.

              When type is binary, grep may treat non-text bytes as line terminators even without
              the -z option.  This means choosing binary versus text can affect whether a pattern
              matches a file.  For example, when type is binary the  pattern  q$  might  match  q
              immediately  followed  by a null byte, even though this is not matched when type is
              text.  Conversely, when type is binary the pattern . (period)  might  not  match  a
              null byte.

              Warning:  The  -a  option  might  output  binary garbage, which can have nasty side
              effects if the output is a terminal and if the terminal driver interprets  some  of
              it  as  commands.   On  the other hand, when reading files whose text encodings are
              unknown, it can be helpful to use -a or to set LC_ALL='C' in  the  environment,  in
              order to find more matches even if the matches are unsafe for direct display.

       -D ACCIÓN, --devices=ACCIÓN
              If  an  input  file  is  a  device,  FIFO  or socket, use ACTION to process it.  By
              default, ACTION is read, which means that devices are read just  as  if  they  were
              ordinary files.  If ACTION is skip, devices are silently skipped.

       -d ACCIÓN, --directories=ACCIÓN
              Emplea  ACCIÓN  para  procesar  el archivo de entrada si éste es un directorio. Por
              defecto, esta ACCIÓN es read (leer), esto es que  leerá  directorios  tal  como  si
              fuesen  archivos.  Si  ACCIÓN es skip, se saltará los directorios sin emitir ningún
              mensaje. Por último, si ACCIÓN es  recurse,  leerá  de  forma  recusiva  todos  los
              archivos  que  se  encuentren  dentro  de  cada  directorio  siguiendo  los enlaces
              simbólicos sólo si se indican en la línea de órdenes. Esto equivaldría a definir la
              opción -r.

       --exclude=GLOB
              Skip  any command-line file with a name suffix that matches the pattern GLOB, using
              wildcard matching; a name suffix is either the whole name, or a trailing part  that
              starts with a non-slash character immediately after a slash (/)  in the name.  When
              searching recursively, skip any subfile whose base name matches GLOB; the base name
              is  the part after the last slash.  A pattern can use *, ?, and [...] as wildcards,
              and \ to quote a wildcard or backslash character literally.

       --exclude-from=ARCHIVO
              Ignora archivos cuya base  del  nombre  coincida  con  alguna  de  las  expresiones
              contenidas en ARCHIVO (empleando concordancias tal como se describió en --exclude).

       --exclude-dir=GLOB
              Skip  any  command-line directory with a name suffix that matches the pattern GLOB.
              When searching recursively, skip any subdirectory whose  base  name  matches  GLOB.
              Ignore any redundant trailing slashes in GLOB.

       -I     Procesa  un  archivo binario como si no contuviese ninguna concordancia. Equivale a
              la opción --binary-files=without-match.

       --include=GLOB
              Search only files  whose  base  name  matches  GLOB  (using  wildcard  matching  as
              described  under  --exclude).  If contradictory --include and --exclude options are
              given, the last matching one wins.  If no --include or --exclude options  match,  a
              file is included unless the first such option is --include.

       -r, --recursive
              Read  all files under each directory, recursively, following symbolic links only if
              they are on the command line.  Note that if no file operand is given, grep searches
              the working directory.  This is equivalent to the -d recurse option.

       -R, --dereference-recursive
              Lee  recursivamente  todos  los archivos dentro de cada directorio. Sigue todos los
              enlaces simbólicos a diferencia de -r.

   Otras opciones
       --line-buffered
              Emplea  el  bufer  de  línea  para  la  salida.  Puede  provocar  un  descenso  del
              rendimiento.

       -U, --binary
              Treat the file(s) as binary.  By default, under MS-DOS and MS-Windows, grep guesses
              whether a file is text or binary as described for the  --binary-files  option.   If
              grep decides the file is a text file, it strips the CR characters from the original
              file  contents  (to  make  regular  expressions  with  ^  and  $  work  correctly).
              Specifying  -U overrules this guesswork, causing all files to be read and passed to
              the matching mechanism verbatim; if the file is a text file with CR/LF pairs at the
              end  of  each  line, this will cause some regular expressions to fail.  This option
              has no effect on platforms other than MS-DOS and MS-Windows.

       -z, --null-data
              Treat input and output data as sequences of lines, each terminated by a  zero  byte
              (the ASCII NUL character) instead of a newline.  Like the -Z or --null option, this
              option can be used with commands like sort -z to process arbitrary file names.

EXPRESIONES REGULARES

       Una expresión regular es un patrón que describe un conjunto de cadenas de caracteres.  Las
       expresiones  regulares  se  construyen  de  forma  análoga  a las expresiones aritméticas,
       combinando expresiones más pequeñas mediante ciertos operadores  para  formar  expresiones
       complejas.

       grep  understands  three  different  versions of regular expression syntax: “basic” (BRE),
       “extended” (ERE) and “perl” (PCRE).  In GNU grep  there  is  no  difference  in  available
       functionality  between basic and extended syntax.  In other implementations, basic regular
       expressions are less powerful.  The following  description  applies  to  extended  regular
       expressions;   differences  for  basic  regular  expressions  are  summarized  afterwards.
       Perl-compatible regular expressions give additional functionality, and are  documented  in
       pcre2syntax(3)  and pcre2pattern(3), but work only if PCRE support is enabled.

       Los bloques de construcción fundamentales son las expresiones regulares que concuerdan con
       un solo carácter. La mayoría de los caracteres, incluyendo todas las letras y dígitos, son
       expresiones  regulares  que  concuerdan  consigo  mismos.  Cualquier  meta-carácter con un
       significado especial debe ser protegido precediéndolo con una barra inclinada inversa.

       El punto . concuerda con un único carácter,  cualquiera  que  sea.  No  está  definido  el
       comportamiento si se topa con un error de codificación.

   Grupos de caracters y Expresiones entre Corchetes
       A  bracket  expression is a list of characters enclosed by [ and ].  It matches any single
       character in that list.  If the first character of the list is the caret ^ then it matches
       any  character  not  in  the list; it is unspecified whether it matches an encoding error.
       For example, the regular expression [0123456789] matches any single digit.

       Within a bracket expression, a range expression consists of two characters separated by  a
       hyphen.  It matches any single character that sorts between the two characters, inclusive,
       using the locale's collating sequence and character set.  For example, in  the  default  C
       locale,  [a-d] is equivalent to [abcd].  Many locales sort characters in dictionary order,
       and in these locales [a-d] is typically not equivalent to [abcd]; it might  be  equivalent
       to   [aBbCcDd],  for  example.   To  obtain  the  traditional  interpretation  of  bracket
       expressions, you can use the C locale by setting the LC_ALL environment  variable  to  the
       value C.

       Finally, certain named classes of characters are predefined within bracket expressions, as
       follows.  Their names are self explanatory, and they are [:alnum:], [:alpha:],  [:blank:],
       [:cntrl:],  [:digit:],  [:graph:],  [:lower:], [:print:], [:punct:], [:space:], [:upper:],
       and [:xdigit:].  For example, [[:alnum:]] means the character class of numbers and letters
       in the current locale.  In the C locale and ASCII character set encoding, this is the same
       as [0-9A-Za-z].  (Note that the brackets in these class names are  part  of  the  symbolic
       names,  and  must  be  included  in  addition  to  the  brackets  delimiting  the  bracket
       expression.)  Most meta-characters lose their special meaning inside bracket  expressions.
       To  include  a  literal  ]  place it first in the list.  Similarly, to include a literal ^
       place it anywhere but first.  Finally, to include a literal - place it last.

   Anclado
       El símbolo de intercalación (caret en inglés) ^  y  el  dólar  $  son  metacaracteres  que
       concuerdan respectivamente con una cadena vacía al inicio y al final de una línea.

   La Barra Invertida y otras Expresiones Especiales
       Los  símbolos  \< y \> concuerdan con una cadena vacía al inicio y al fina de una palabra,
       respetivamente. El símbolo \b concuerda con una  cadena  vacía  en  los  extremos  de  una
       palabra y 0hará lo propio si dicha cadena vacío NO está en los extremos de una palabra. El
       símbolo \w es sinómino de [_[:alnum:]] y \W lo es de [^_[:alnum:]].

   Repetición
       Una expresión regular que concuerde con un solo carácter puede  ser  seguida  por  uno  de
       estos varios operadores de repetición:
       ?      El elemento precedente es opcional y concuerda como mucho una vez.
       *      El elemento precedente concordará cero o más veces.
       +      El elemento precedente concordará una o más veces.
       {n}    El elemento precedente concuerda exactamente n veces.
       {n,}   El elemento precedente concuerda n o más veces.
       {,m}   El elemento precedente concuerda un máximo de m veces. Es una extensión de GNU.
       {n,m}  El elemento precedente concuerda como poco n veces, pero no más de m veces.

   Concatenación
       Dos  expresiones  regulares pueden concatenarse; la expresión regular resultante concuerda
       con cualquier cadena formada mediante la concatenación de dos  subcadenas  que  concuerdan
       respectivamente con las expresiones concatenadas.

   Alternancia
       Dos  expresiones  regulares  pueden  juntarse mediante el operador |; la expresión regular
       resultante concuerda con cualquier cadena que concuerde con cualquiera de las expresiones.

   Precedencia
       La repetición tiene precedencia sobre la concatenación, la cual a su vez tiene precedencia
       sobre  la  alternancia.  Una  expresión  entera  puede ser encerrada entre paréntesis para
       subvertir estas reglas de precedencia.

   Retroreferencias y Subexpresiones
       La retrorreferencia \n, donde n es un  dígito  simple,  concuerda  con  la  subcadena  que
       previamente concordó con la n-sima subexpresión entre paréntesis de la expresión regular.

   Expresiones Regulares Básicas y Ampliadas
       En  las  expresiones  regulares  básicas, los metacaracteres ?, +, {, |, (, y ) pierden su
       significado especial; en su lugar  emplee  las  versiones  protegidas  mediante  la  barra
       inversa \?, \+, \{, \|, \(, y \).

ESTADO DE SALIDA

       El  estado  de  salida  suele  ser  0  si  se  ha  seleccinado alguna línea, 1 si no se ha
       seleccionado ninguna y 2 si ha ocurrido algún error. Sin embargo, si se indicó  la  opción
       -q o --quiet o --silent el estado de salida será cero aunque ocurriese algún error.

ENTORNO

       El comportamiento de grep está influido por las siguientes variables de entorno.

       The  locale  for category LC_foo is specified by examining the three environment variables
       LC_ALL, LC_foo, LANG, in that order.  The first of these variables that is  set  specifies
       the  locale.  For example, if LC_ALL is not set, but LC_MESSAGES is set to pt_BR, then the
       Brazilian Portuguese locale is used for the LC_MESSAGES category.  The C locale is used if
       none of these environment variables are set, if the locale catalog is not installed, or if
       grep was not compiled with national language support (NLS).  The shell command  locale  -a
       lists locales that are currently available.

       GREP_COLORS
              Controls  how the --color option highlights output.  Its value is a colon-separated
              list          of          capabilities          that          defaults           to
              ms=01;31:mc=01;31:sl=:cx=:fn=35:ln=32:bn=32:se=36   with  the  rv  and  ne  boolean
              capabilities omitted (i.e., false).  Supported capabilities are as follows.

              sl=    SGR substring for whole selected lines (i.e., matching  lines  when  the  -v
                     command-line option is omitted, or non-matching lines when -v is specified).
                     If however the boolean rv capability and the -v command-line option are both
                     specified,  it  applies  to  context matching lines instead.  The default is
                     empty (i.e., the terminal's default color pair).

              cx=    SGR substring for whole context lines (i.e., non-matching lines when the  -v
                     command-line option is omitted, or matching lines when -v is specified).  If
                     however the boolean rv capability and the -v command-line  option  are  both
                     specified,  it  applies to selected non-matching lines instead.  The default
                     is empty (i.e., the terminal's default color pair).

              rv     Valor booleano  que  invierte  el  significado  de  las  capacidades  sl=  y
                     cx=cuando  se  define  la  opción  -v. Por defecto es falso, es decir que se
                     omite la capacidad.

              mt=01;31
                     SGR substring for matching non-empty text in  any  matching  line  (i.e.,  a
                     selected  line when the -v command-line option is omitted, or a context line
                     when -v is specified).  Setting this is equivalent to setting both  ms=  and
                     mc=  at  once  to the same value.  The default is a bold red text foreground
                     over the current line background.

              ms=01;31
                     SGR substring for matching non-empty text in a selected line.  (This is only
                     used when the -v command-line option is omitted.)  The effect of the sl= (or
                     cx= if rv)  capability remains active when this kicks in.  The default is  a
                     bold red text foreground over the current line background.

              mc=01;31
                     SGR  substring for matching non-empty text in a context line.  (This is only
                     used when the -v command-line option is specified.)  The effect of  the  cx=
                     (or  sl=  if rv)  capability remains active when this kicks in.  The default
                     is a bold red text foreground over the current line background.

              fn=35  SGR substring for file names prefixing any content line.  The default  is  a
                     magenta text foreground over the terminal's default background.

              ln=32  SGR substring for line numbers prefixing any content line.  The default is a
                     green text foreground over the terminal's default background.

              bn=32  SGR substring for byte offsets prefixing any content line.  The default is a
                     green text foreground over the terminal's default background.

              se=36  SGR  substring for separators that are inserted between selected line fields
                     (:), between context line fields, (-), and between groups of adjacent  lines
                     when  nonzero  context  is  specified  (--).   The  default  is  a cyan text
                     foreground over the terminal's default background.

              ne     Boolean value that prevents clearing to the end of line using Erase in  Line
                     (EL)  to  Right (\33[K)  each time a colorized item ends.  This is needed on
                     terminals on which EL is not supported.  It is otherwise useful on terminals
                     for  which  the back_color_erase (bce)  boolean terminfo capability does not
                     apply, when the chosen highlight colors do not  affect  the  background,  or
                     when EL is too slow or causes too much flicker.  The default is false (i.e.,
                     the capability is omitted).

              Note that boolean capabilities have no =... part.  They are omitted  (i.e.,  false)
              by default and become true when specified.

              See  the  Select  Graphic  Rendition (SGR) section in the documentation of the text
              terminal that  is  used  for  permitted  values  and  their  meaning  as  character
              attributes.   These substring values are integers in decimal representation and can
              be concatenated with semicolons.  grep takes care of assembling the result  into  a
              complete SGR sequence (\33[...m).  Common values to concatenate include 1 for bold,
              4 for underline, 5 for blink, 7 for inverse, 39 for default foreground color, 30 to
              37  for  foreground colors, 90 to 97 for 16-color mode foreground colors, 38;5;0 to
              38;5;255 for 88-color  and  256-color  modes  foreground  colors,  49  for  default
              background  color,  40  to  47  for background colors, 100 to 107 for 16-color mode
              background colors,  and  48;5;0  to  48;5;255  for  88-color  and  256-color  modes
              background colors.

       LC_ALL, LC_COLLATE, LANG
              These  variables  specify  the locale for the LC_COLLATE category, which determines
              the collating sequence used to interpret range expressions like [a-z].

       LC_ALL, LC_CTYPE, LANG
              These variables specify the locale for the LC_CTYPE category, which determines  the
              type  of  characters,  e.g.,  which  characters are whitespace.  This category also
              determines the character encoding, that is,  whether  text  is  encoded  in  UTF-8,
              ASCII,  or  some  other  encoding.   In  the  C or POSIX locale, all characters are
              encoded as a single byte and every byte is a valid character.

       LC_ALL, LC_MESSAGES, LANG
              These variables specify the locale for the LC_MESSAGES category,  which  determines
              the  language  that  grep  uses  for  messages.  The default C locale uses American
              English messages.

       POSIXLY_CORRECT
              If set, grep behaves as POSIX requires; otherwise, grep behaves more like other GNU
              programs.   POSIX  requires  that options that follow file names must be treated as
              file names; by default, such options are permuted to the front of the operand  list
              and  are  treated  as  options.   Also, POSIX requires that unrecognized options be
              diagnosed as “illegal”, but since they are not really against the law  the  default
              is    to    diagnose    them   as   “invalid”.    POSIXLY_CORRECT   also   disables
              _N_GNU_nonoption_argv_flags_, described below.

       _N_GNU_nonoption_argv_flags_
              (Here N is grep's numeric process ID.)  If the ith character  of  this  environment
              variable's  value  is  1,  do not consider the ith operand of grep to be an option,
              even if it appears to be one.  A shell can put this variable in the environment for
              each  command  it  runs,  specifying  which  operands  are the results of file name
              wildcard expansion and therefore should not be treated as options.   This  behavior
              is available only with the GNU C library, and only when POSIXLY_CORRECT is not set.

NOTAS

       Esta  página  de  manual  no se mantienede forma rigurosa. La documentación completa suele
       estar más actualizada.

COPYRIGHT

       Copyright 1998-2000, 2002, 2005-2022 Free Software Foundation, Inc.

       Esto es software libre;  consulte  el  código  fuente  para  concoer  las  condiciones  de
       distribución.  NO  existe  garantía alguna; ni siquiera acerca de la COMERCIALIZACIÓN o la
       IDONEIDAD DE SU USO PARA UN FIN CONCRETO.

ERRORES

   Informar de Errores
       Email bug reports to the  bug-reporting  address  ⟨bug-grep@gnu.org⟩.   An  email  archive
       ⟨https://lists.gnu.org/mailman/listinfo/bug-grep⟩       and       a       bug      tracker
       ⟨https://debbugs.gnu.org/cgi/pkgreport.cgi?package=grep⟩ are available.

   Errores Conocidos
       Números de repetición grandes en la  construcción  {n,m}  pueden  hacer  que  grep  emplee
       grandes  cantidades  de  memoria.   En  adición a esto, ciertas otras obscuras expresiones
       regulares requieren tiempo y espacio exponenciales, y pueden hacer que grep se  quede  sin
       memoria.

       Las retrorreferencias son muy lentas, y pueden requerir un tiempo exponencial.

EJEMPLO

       The  following  example  outputs  the location and contents of any line containing “f” and
       ending in “.c”, within all files in the current directory whose names contain “g” and  end
       in “.h”.  The -n option outputs line numbers, the -- argument treats expansions of “*g*.h”
       starting with “-” as file names not options, and the  empty  file  /dev/null  causes  file
       names to be output even if only one file name happens to be of the form “*g*.h”.

         $ grep -n -- 'f.*\.c$' *g*.h /dev/null
         argmatch.h:1:/* definiciones y prototipos para argmatch.c

       The  only  line  that  matches  is line 1 of argmatch.h.  Note that the regular expression
       syntax used in the pattern differs from the globbing syntax that the shell uses  to  match
       file names.

VÉASE TAMBIÉN

   Páginas de Manual Genéricas
       awk(1),  cmp(1),  diff(1), find(1), perl(1), sed(1), sort(1), xargs(1), read(2), pcre2(3),
       pcre2syntax(3), pcre2pattern(3), terminfo(5), glob(7), regex(7)

   Documentación Completa
       A complete manual ⟨https://www.gnu.org/software/grep/manual/⟩ is available.  If  the  info
       and grep programs are properly installed at your site, the command

              info grep

       debería acceder al manual completo.

TRADUCCIÓN

       La  traducción  al  español  de  esta  página del manual fue creada por Gerardo Aburruzaga
       García <gerardo.aburruzaga@uca.es> y Marcos Fouces <marcos@debian.org>

       Esta traducción es documentación libre; lea  la  GNU  General  Public  License  Version  3
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  o posterior con respecto a las condiciones de
       copyright.  No existe NINGUNA RESPONSABILIDAD.

       Si encuentra algún error en la traducción de esta  página  del  manual,  envíe  un  correo
       electrónico a ⟨debian-l10n-spanish@lists.debian.org⟩.