8.4 Pattern und Operatoren

AWK ist eine zeilenorientierte Sprache, sie verwendet pattern und actions. awk pattern werden zur Beschreibung der Bedingung verwendet, unter der eine action ausgeführt werden soll.
  • fehlt pattern, so wird der Aktionsteil für jeden Satz durchgeführt
  • fehlt der Aktionsteil, so wird der Satz ausgegeben.
  • Folgende pattern können verwendet werden:
    
          BEGIN
          END
          /regular expression/
          relational expression
          pattern && pattern
          pattern || pattern
          pattern ? pattern : pattern
          (pattern)
          ! pattern
          pattern1, pattern2
    


    8.4.1 BEGIN END

  • BEGIN und END sind zwei besondere Patterns. Sie werden nicht mit dem Input verglichen. sondern unabhängig davon ausgeführt.
  • BEGIN und END können nicht mit anderen Pattern verknüpft werden.
  • Sind mehrere BEGIN oder END pattern vorhanden, dann werden ihre Aktionsteile so zusammengefaßt, als ob sie jeweils in einer Aktion geschrieben wären. BEGIN und END patterns müssen einen Aktionsteil haben oder ganz weggelassen werden.
    Beispiele:
        # Anzahl der Sätze ausgeben
             END     { print NR }   
    
       # Anzahl aller Zeichen ausgeben
          	        { nc += length($0) } 	# $0 ist kompletter Satz, davon length ohne  \n
    	END     { print  nc + NR  } 	# Zeichenanzahl + Anzahl der Sätze
        


    8.4.2 Metazeichen in /regular expression/ pattern

  • /regular expression/ Der zugehörige Aktionsteil wird für jede Eingabezeile
    durchgeführt, auf die der RE zutrifft. Als RE können alle extended Formen verwendet
    werden, die auch in egrep Anwendung finden.
  • Innerhalb eines RE sind die Zeichen \ ^ $ . [ ] + ? () | Metazeichen. Sie haben für den awk eine spezielle Bedeutung.
    Sollen sie als normale Zeichen verwendet werden, so sind sie durch einen \ zu maskieren.
  • 
    c          	matches das non-Metazeichen c.
    
    ^          	der RE beginnt am Anfang einer Zeile oder eines Strings	/^d/
    
    $          	der RE steht am Ende einer Zeile oder eines Strings		/test$/
    
    .           	steht für jedes Zeichen (Ausnahme newline).			/^.....w/
    
    \c         	Quoten des Metazeichen c, ergibt das Literalzeichen c.		/^\./
    
    [abc]   		Character Class, jedes der Zeichen abc			   	/[ xyzabc]/
    [a-zA-Z]		Bereiche werden durch Bindestrich gebildet
    
    [^abc]  		Negation der Character Class, jedes Zeichen das nicht
    		abc   oder newline ist.
    
    re1|re2    	Alternation: steht für entweder  re1 oder re2.			/root|hahn/
    
    re1re2      	Concatenation:   erst  re1, und dann  re2. 			/[abc][0-9]/
    
    re+         	steht für ein oder mehrere  re's.				 /[0-9]+/
    
    re*         	steht für Null  oder mehrere re's.				 /[0-9]*/
    
    re?         	steht für Null oder ein re's.					 /[0-9]?/
    
    (re)        	Zusammenfassung von  re.					 /(,[ \t])|([ \t])/
    
    Escapesequenzen die in Strings verwendet werden dürfen, können auch in RE verwendet werden.
    \\ 		backslash
    \a		alert                 		(im Regelfall  ASCII BEL Zeichen)
    \b		backspace
    \f		formfeed
    \n		newline
    \r		carriage return
    \t		horizontal tab
    \v		vertical tab
    \ddd	octal value ddd
    \xhh	hex-digits		       		z.B.  "\x1B"  für ASCII ESC Zeichen
    \"		quotation mark
    \c		jedes andere Zeichen
    
         Escapesequenzen können auch in Zeichenklassen verwendet werden.
         /[ \t\f\n\r\v]/  trifft zu für alle 'white space'
    
         Achtung : wird der vorstender RE einem String zugewiesen der als RE verwendet
    		werden soll, dann muß jeder \ als \\ geschrieben werden.
            		re = "[ \\t\\f\\n\\r\\v]"
            			$3 ~  re { print $3 }
    


    8.4.3 Relational Expression

    Relational Expression vergleichen i.d.R. den Inhalt von Feldern gegen einen RE. Dabei können alle Operatoren benutzt werden, die auch in einer Aktion verwendet werden k�nnen.
    Operator	Funktion		Beipiel
    ~	enthält			ls -l | awk ' $1 ~  /^d/ {print $1, $9} '
    !~	enthält  nicht		ls -l | awk ' $1 !~ /^d/ {print $1, $9} '
    >	größer als		ls -l | awk ' $5 > 30000 '
    >=	größer gleich		ls -l | awk ' $2 >= 2 '
    == 	gleich			ls -l | awk ' $3 == /root/ '
    <	kleiner als		ls -l | awk ' $2 < 2 '
    <=	kleiner gleich		ls -l | awk ' $5 <= 1024 '
    !=	ungleich		ls -l | awk ' $3 != /root/ '
    
    awk interpretiert Strings auf der rechten Seite von  ~  oder !~ als Regular Expression.
    Sollen mit \ maskierte Metazeichen in einem String abgelegt werden um Sie als RE zu
    verwenden,  dann müssen in dem String 2 \\ geschrieben werden.
                    Pattern   			String
                    x  ~  /a\$/			x  ~  "a\\$"
                    x  ~  /a$/			x  ~  "a\$"
                    x  ~  /\t/			x  ~  "\\t"
    


    8.4.4 Verküpfung von Relational Expression

    Relational Expression können über die Operatoren && || sowie ! verknüpft werden.
    Die Auswertung dieser Operatoren erfolgt im Kurzschlussverfahren.
    Klammern können gesetzt werden, um die Auswertungsreihenfolge zu beeinflußen.
    Operator	Funktion			Beispiel
    && 	logisch-UND			ls -l | awk '$5 > 1024 && $3 != "root" '
    || 	logisch-ODER			ls -l | awk '$3 ~ "root"   ||  $3 ~ "hahn" '
    !	logisch-NOT			ls -l | awk ' $3 ~  ! "root"  '
    

    8.4.5 tenärer Operator ? :

    Der ? : Operator formuliert eine Bedingung und eine Unterbedingung.
         pattern1 ? pattern2 : pattern3
    Wenn pattern1 zutrifft, wird mit pattern2 getestet, andernfalls mit pattern3.
    Nur eines der Pattern 2 oder 3 wird evaluiert.
     


    8.4.6 pattern1 , pattern2 Patternbereich

    Die Form pattern1, pattern2 bezeichnet einen Pattern-Bereich. Er trifft alle Sätze zu,
    die mit pattern1 beginnen und erstreckt sich bis zu dem Satz der pattern2 enthält (inclusiv).
    Diese Form darf nicht mit einem anderen Regular Expression kombiniert werden.
    awk '/^# Modif/,/^#_==/' $1 | more        # gibt alle Sätze in dem Bereich aus