Cosa fa il comando 'grep'?

Vorrei imparare come usarlo in modo da poter iniziare a utilizzare di più il terminale.

grepviene utilizzato per cercare testo da un file o dall'output di un altro comando. Può restituire le linee in cui trova una corrispondenza o le linee in cui non trova.

NOME

   grep, egrep, fgrep - print lines matching a pattern

SINOSSI

   grep [options] PATTERN [FILE...]
   grep [options] [-e PATTERN | -f FILE] [FILE...]

DESCRIZIONE

   Grep  searches the named input FILEs (or standard input if no files are
   named, or the file name - is given) for lines containing a match to the
   given PATTERN.  By default, grep prints the matching lines.

   In addition, two variant programs egrep and fgrep are available.  Egrep
   is the same as grep -E.  Fgrep is the same as grep -F.

OPZIONI

   -A NUM, --after-context=NUM
      Print NUM  lines  of  trailing  context  after  matching  lines.
      Places  a  line  containing  --  between  contiguous  groups  of
      matches.

   -a, --text
      Process a binary file as if it were text; this is equivalent  to
      the --binary-files=text option.

   -B NUM, --before-context=NUM
      Print  NUM  lines  of  leading  context  before  matching lines.
      Places  a  line  containing  --  between  contiguous  groups  of
      matches.

   -C NUM, --context=NUM
      Print  NUM lines of output context.  Places a line containing --
      between contiguous groups of matches.

   -b, --byte-offset
      Print the byte offset within the input file before each line  of
      output.

   --binary-files=TYPE
      If the first few bytes of a file indicate that the file contains
      binary data, assume that the file is of type TYPE.  By  default,
      TYPE is binary, and grep normally outputs either a one-line mes-
      sage saying that a binary file matches, or no message  if  there
      is  no  match.   If  TYPE  is without-match, grep assumes that a
      binary file does not match; this is equivalent to the -I option.
      If  TYPE  is  text,  grep  processes a binary file as if it were
      text; this is  equivalent  to  the  -a  option.   Warning:  grep
      --binary-files=text  might output binary garbage, which can have
      nasty side effects if the output is a terminal and if the termi-
      nal driver interprets some of it as commands.

   --colour[=WHEN], --color[=WHEN]
      Surround  the matching string with the marker find in GREP_COLOR
      environment variable. WHEN may be 'never', 'always', or 'auto'

   -c, --count
      Suppress normal output; instead print a count of matching  lines
      for  each  input  file.  With the -v, --invert-match option (see
      below), count non-matching lines.

   -D ACTION, --devices=ACTION
      If an input file is a device, FIFO or socket, use ACTION to pro-
      cess  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 ACTION, --directories=ACTION
      If  an  input file is a directory, use ACTION to process it.  By
      default, ACTION is read, which means that directories  are  read
      just  as if they were ordinary files.  If ACTION is skip, direc-
      tories are silently skipped.  If ACTION is recurse,  grep  reads
      all  files under each directory, recursively; this is equivalent
      to the -r option.

   -E, --extended-regexp
      Interpret PATTERN as an extended regular expression (see below).

   -e PATTERN, --regexp=PATTERN
      Use PATTERN as the pattern; useful to protect patterns beginning
      with -.

   -F, --fixed-strings
      Interpret PATTERN as a list of fixed strings, separated by  new-
      lines, any of which is to be matched.

   -P, --perl-regexp
      Interpret PATTERN as a Perl regular expression.

   -f FILE, --file=FILE
      Obtain  patterns  from  FILE, one per line.  The empty file con-
      tains zero patterns, and therefore matches nothing.

   -G, --basic-regexp
      Interpret PATTERN as a basic  regular  expression  (see  below).
      This is the default.

   -H, --with-filename
      Print the filename for each match.

   -h, --no-filename
      Suppress  the  prefixing  of  filenames  on output when multiple
      files are searched.

   --help Output a brief help message.

   -I     Process a binary file as if it did not  contain  matching  data;
      this is equivalent to the --binary-files=without-match option.

   -i, --ignore-case
      Ignore  case  distinctions  in  both  the  PATTERN and the input
      files.

   -L, --files-without-match
      Suppress normal output; instead print the  name  of  each  input
      file from which no output would normally have been printed.  The
      scanning will stop on the first match.

   -l, --files-with-matches
      Suppress normal output; instead print the  name  of  each  input
      file  from  which  output would normally have been printed.  The
      scanning will stop on the first match.

   -m NUM, --max-count=NUM
      Stop reading a file after NUM matching lines.  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.

   --mmap If  possible, use the mmap(2) system call to read input, instead
      of the default read(2) system call.  In some situations,  --mmap
      yields  better performance.  However, --mmap can cause undefined
      behavior (including core dumps) if an input file  shrinks  while
      grep is operating, or if an I/O error occurs.

   -n, --line-number
      Prefix each line of output with the line number within its input
      file.

   -o, --only-matching
      Show only the part of a matching line that matches PATTERN.

   --label=LABEL
      Displays input actually coming from standard input as input com-
      ing  from  file LABEL.  This is especially useful for tools like
      zgrep, e.g.  gzip -cd foo.gz |grep -H --label=foo something

   --line-buffered
      Use line buffering, it can be a performance penality.

   -q, --quiet, --silent
      Quiet; do not write anything to standard output.   Exit  immedi-
      ately  with  zero status if any match is found, even if an error
      was detected.  Also see the -s or --no-messages option.

   -R, -r, --recursive
      Read all files under each directory, recursively; this is equiv-
      alent to the -d recurse option.

 --include=PATTERN
      Recurse in directories only searching file matching PATTERN.

 --exclude=PATTERN
      Recurse in directories skip file matching PATTERN.

   -s, --no-messages
      Suppress  error  messages about nonexistent or unreadable files.
      Portability note: unlike GNU grep, traditional grep did not con-
      form to POSIX.2, because traditional grep lacked a -q option and
      its -s option behaved like GNU grep's -q option.  Shell  scripts
      intended to be portable to traditional grep should avoid both -q
      and -s and should redirect output to /dev/null instead.

   -U, --binary
      Treat the file(s) as binary.  By default, under MS-DOS  and  MS-
      Windows,  grep  guesses the file type by looking at the contents
      of the first 32KB read from the file.  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-Win-
      dows.

   -u, --unix-byte-offsets
      Report Unix-style byte offsets.   This  switch  causes  grep  to
      report  byte  offsets  as if the file were Unix-style text file,
      i.e. with CR characters stripped off.  This will produce results
      identical to running grep on a Unix machine.  This option has no
      effect unless -b option is  also  used;  it  has  no  effect  on
      platforms other than MS-DOS and MS-Windows.

   -V, --version
      Print  the  version number of grep to standard error.  This ver-
      sion number should be included in all bug reports (see below).

   -v, --invert-match
      Invert the sense of matching, to select non-matching lines.

   -w, --word-regexp
      Select only those  lines  containing  matches  that  form  whole
      words.   The  test is that the matching substring must either be
      at the beginning of the line, or preceded  by  a  non-word  con-
      stituent  character.  Similarly, it must be either at the end of
      the line or followed by a non-word constituent character.  Word-
      constituent  characters are letters, digits, and the underscore.

   -x, --line-regexp
      Select only those matches that exactly match the whole line.

   -y     Obsolete synonym for -i.

   -Z, --null
      Output a zero byte (the ASCII  NUL  character)  instead  of  the
      character  that normally follows a file name.  For example, grep
      -lZ outputs a zero byte after each  file  name  instead  of  the
      usual  newline.   This option makes the output unambiguous, even
      in the presence of file names containing unusual characters like
      newlines.   This  option  can  be  used  with commands like find
      -print0, perl -0, sort -z, and xargs  -0  to  process  arbitrary
      file names, even those that contain newline characters.

FONTE: MANPAGE PER GREP
È possibile conoscere i comandi digitando

info <command>  

man <command>

whatis <command>

apropos <command>  

nel terminal.

Hai taggato la tua domanda con il greptag. Ma era meglio se leggi prima le informazioni sui tag facendo riferimento agrep :

grep è un'utilità della riga di comando che viene utilizzata per cercare testo dall'input standard o un file per espressioni specifiche, restituendo le righe in cui si verificano le corrispondenze.

Un uso comune per grepè individuare e stampare determinate righe dai file di registro o dall'output del programma.

Vedi questa pagina della documentazione di Ubuntu per maggiori informazioni su come usare grep.

Inoltre, quasi tutti i comandi hanno una pagina di manuale che puoi leggere. Nel tuo caso, usa questo comando:

man grep

Ancor più, è possibile ottenere informazioni su grep utilizzando uno di questi comandi: info grep, grep -h, grep --help, whatis grepo apropos grep.

grep cerca il contenuto dei file in base a un'espressione regolare. Il modo più semplice per usarlo è qualcosa del genere grep "word" file.txt, nel qual caso restituirà solo ogni riga in cui "word" appare in file.txt (o niente se non è lì). Per farlo fare cose più avanzate, scopri le espressioni regolari. Puoi trovare molti tutorial online cercando. http://lmgtfy.com/?q=grep+tutorial

Personalmente, non consiglio di usare il terminale solo per il gusto di usare il terminale. Potresti avere molti problemi ad imparare strumenti complicati come grep solo per scoprire che usi programmi grafici o script che hai scritto nella tua lingua interpretata preferita. La maggior parte delle persone che consigliano di apprendere comandi di terminale vecchio stile sono essi stessi hacker di vecchio stile.

Il comando grep cerca uno o più file di input alla ricerca di righe contenenti una corrispondenza con un modello specificato. Per impostazione predefinita, grep stampa le linee corrispondenti.

Grep cerca nei FILE di input nominati (o nell'input standard se non viene indicato alcun file o viene fornito il nome del file) per le righe che contengono una corrispondenza con il PATTERN specificato. Per impostazione predefinita, grep stampa le linee corrispondenti.

Inoltre, sono disponibili due programmi varianti egrep e fgrep. Egrep è uguale a grep -E. Fgrep è uguale a grep -F. ^{Man Page}

Puoi anche dare un'occhiata a SS64