Newsgroup: it.comp.macintosh
Titolo: [SW] Ricerche in BBEdit con le escape sequences

Ciao a tutti,
lo stress da superlavoro mi ha generato un bucone nel cervello e non
ricordo piu' come accidenti si indicano le escape sequences.
Se dovessi cercare zio e zia all'interno di un testo come dovrei
indicarlo? zi? zi* zi/*... non mi ricordo piu'!!!
-- 
Mr. Fix at work

 indicarlo? zi? zi* zi/*... non mi ricordo piu'!!!
zi[a|o]
-- 
stiamo lavorando per voi...

 zi[a|o]
gia che ci sono ti incollo un pezzo di man grep
REGULAR EXPRESSIONS
       A  regular expression is a pattern that describes a set of
       strings.  Regular expressions are constructed  analogously
       to  arithmetic  expressions, by using various operators to
       combine smaller expressions.
       Grep understands two different versions of regular expres-
       sion  syntax:  "basic" and "extended."  In GNU grep, there
       is no difference in available functionality  using  either
       syntax.   In  other implementations, basic regular expres-
       sions  are  less  powerful.   The  following   description
       applies  to  extended regular expressions; differences for
       basic regular expressions are summarized afterwards.
       The fundamental building blocks are  the  regular  expres-
       sions  that  match  a  single character.  Most characters,
       including all letters and digits, are regular  expressions
       that  match  themselves.   Any  metacharacter with special
       meaning may be quoted by preceding it with a backslash.
       A list of characters enclosed by [ and ] matches any  sin-
       gle  character in that list; if the first character of the
       list is the caret ^ then it matches any character  not  in
       the   list.    For   example,   the   regular   expression
       [0123456789] matches any single digit.  A range of charac-
       ters may be specified by giving the first and last charac-
       ters, separated  by  a  hyphen.   Finally,  certain  named
       classes  of  characters  are  predefined.  Their names are
       self  explanatory,  and  they  are  [:alnum:],  [:alpha:],
       [:cntrl:],  [:digit:],  [:graph:],  [:lower:],  [:print:],
       [:punct:],  [:space:],  [:upper:],  and  [:xdigit:].   For
       example,  [[:alnum:]] means [0-9A-Za-z], except the latter
       form depends upon the POSIX locale and the ASCII character
       encoding,  whereas the former is independent of locale and
       character set.  (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  list.)
       Most  metacharacters  lose  their  special  meaning inside
       lists.  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.
       The period .  matches any single character.  The symbol \w
       is  a  synonym  for  [[:alnum:]]  and  \W is a synonym for
       [^[:alnum]].
       The caret ^ and the dollar sign $ are metacharacters  that
       respectively  match  the empty string at the beginning and
       end of a line.  The symbols \< and \>  respectively  match
       the  empty string at the beginning and end of a word.  The
       symbol \b matches the empty string at the edge of a  word,
       and  \B  matches the empty string provided it's not at the
       edge of a word.
       A regular expression may be followed  by  one  of  several
       repetition operators:
       ?      The  preceding item is optional and matched at most
              once.
GNU Project                 2000/12/06                          5
GREP(1)                                                   GREP(1)
       *      The preceding item will be  matched  zero  or  more
              times.
       +      The  preceding  item  will  be  matched one or more
              times.
       {n}    The preceding item is matched exactly n times.
       {n,}   The preceding item is matched n or more times.
       {n,m}  The preceding item is matched at least n times, but
              not more than m times.
       Two regular expressions may be concatenated; the resulting
       regular expression matches any string formed  by  concate-
       nating two substrings that respectively match the concate-
       nated subexpressions.
       Two regular expressions may be joined by the infix  opera-
       tor |; the resulting regular expression matches any string
       matching either subexpression.
       Repetition takes precedence over concatenation,  which  in
       turn  takes  precedence  over alternation.  A whole subex-
       pression may be enclosed in parentheses to override  these
       precedence rules.
       The  backreference  \n, where n is a single digit, matches
       the substring previously matched by the nth  parenthesized
       subexpression of the regular expression.
       In  basic  regular expressions the metacharacters ?, +, {,
       |, (, and ) lose their special meaning;  instead  use  the
       backslashed versions \?, \+, \{, \|, \(, and \).
       Traditional egrep did not support the { metacharacter, and
       some egrep implementations support \{ instead, so portable
       scripts  should  avoid  { in egrep patterns and should use
       [{] to match a literal {.
       GNU egrep attempts to support traditional usage by  assum-
       ing  that  { is not special if it would be the start of an
       invalid interval specification.  For  example,  the  shell
       command  egrep  '{1' searches for the two-character string
       {1 instead of reporting a  syntax  error  in  the  regular
       expression.  POSIX.2 allows this behavior as an extension,
       but portable scripts should avoid it.


 gia che ci sono ti incollo un pezzo di man grep...
Mitico! Avevo trovato qualcosa di simile tempo fa ma non utilizzandole
mai ho un po' perso la mano...
Visto che sei pratico ti metto ancora alla prova  : )
Data questa situazione:
alpha">alpha
beta">beta
gamma">gamma
e' possibile fare una ricerca in modo da trovare (e selezionare) in un
colpo solo "> e tutti i caratteri seguenti fino al simbolo di 'a capo'
(escluso) in tutte le righe?
Devo ripulire un codice html che contiene dei pop-up ed estrapolare del
testo pulito. Il grosso del codice l'ho gia' eliminato ma nei pop-up non
riesco ad automatizzare niente...


 (escluso) in tutte le righe?
\"\>.*\r oppure
\"\>.*$
non so se " e > hanno bisogno di \, quindi ce l'ho messo per tutti e due


 non so se " e > hanno bisogno di \, quindi ce l'ho messo per tutti e due
mi rispondo di nuovo da solo
su 9 \r va bene, ma su X si usa \n. In ogni caso $ funziona


 su 9 \r va bene, ma su X si usa \n. In ogni caso $ funziona
Mitico again! Grazie lire 1000!  : )
-- 
Mr. Fix at home

 Mitico again! Grazie lire 1000!  : )
aspetto il vaglia


 aspetto il vaglia
  : )
Ho capito adesso perche' non mi funziona niente...
Non avevo attivato il checkbox "Use Grep"!!! Ma saro' gia' stronato!
Ho bisogno di ferie...


 Ma e` it.comp.lang.perl? Credevo fosse icm ;o)
Hem... Ero OT? Ops...  : )


 No, non eri OT... ero io ad essere sarcastico ;o)
Ci speravo... Difatti anch'io avevo la faccina!  : p
