String Proccessing

Conditional Constructs

        String Test     Meaning
            eq          Equal to
            ne          Not equal
            gt          Greater then
            le          Greater then or equal to
            lt          Less than
            le          Less than or equal to
            cmp         Not equal to, with signed return

Example:

        while (<>) {               #Print lines that weren't blank.
            chop;
            if ($_ ne "") {
                print $_,"/n";
            }
        }

Scalar Operators

         Pattern Matching                    Result
    $a =~/pat/          Match          True if $a contains pattern
    $a =~s/p/r/         Substitution   Replace occurrences of p with r in $a
    $a =~tr/a-z/A_Z/    Translation    Translate to corresponding characters

            Logical Operators                  Result
      $a && $b          And             True if $a is true and $b is true
      $a || $b          Or              $a if $a is true, otherwise $b
      ! $a              Not             True if $a is not true

            String Operations                   Result
        $a . $b          Concatenation   Values of $a and $b as one long string
        $a x $b          Repeat          Value of $a strung together $b times
        substr($a,$o,$1) Substring       Substring at offset $o of length $1
        index($a,$b)     Index            Offset of string $b in string $a

Example:

            $/ = "";            #Enable paragraph mode.
            $* = 1;             #Enable multi-line patterns.
        # Now read each paragraph and split into words. Record each instance
        # of a word in the %wordcount associative array.
            while <> {
                s/-\n//g;                            #Dehyphenate hyphenations.
                tr/A-Z/a-z;                          #Canonicalize to lowercase.
                &words = split(/\W*\s+\W*/, $_);
                foreach $word (@words) {
                    $wordcount($word)++;              #Increment the entry.
                }
            }

Regular Expressions

A regular expression matches string if any of the alternatives of the regular expression match.
An alternative matches if every item in the alternative matches in the order the items occur.

An item consists of either an assertion or a quantified atom. Assertions are:

            ^   Matches the beginnig of the string (or line, if $* set)
            $   Matches the end of the string ( or line, if $* set)
            \b  Matches on word boundary (between \w and \W)
            \B  Matches on non-word boundary

Quantifiers are:

        

        {n,m}   Must occur at least n times but no more than m times
        {n,}    Must occur at least n times
        {n}     Must match exactly n times
        *       0 or more times (same as {0})
        +       1 or more times (same as {1,})
        ?       0 or 1 time (same as {0,1})

A backslashed letter matches a special character or character class:

        \n      Newline
        \r      Carriage return
        \t      Tab
        \f      Formfeed
        \d      A digit, same as [0-9]
        \D      A non-digit
        \w      A word character (alphanumeric), same as [0-9a-z_A-Z]
        \W      A non-word character
        \s      A whitespace character, same as [\t\n\r\f]
        \S      A non-whitespace character

Magical variables

        $       Matches the end of a string
        $_      Returns current string
        $&      Returns the intire matched string
        $^      Holds everything before matching
        $'      Holds everything after the matched string

Example:

        s/^([^ ]*) *([^ ]*)/$2 $1/;     #swap first two words
        /{\w*)\s*=\s*\1/;               #match "foo = foo"
        /.(80,};                        #match line at least 80 chars
        /^(\d+\.?\d*|\.\d+)$/;          #match valid Perl number
        if (/Time: (..):(..):(..)/) {   #pull fields out of line
            $hours = $1;
            $minutes = $2;
            $seconds = $3;
        }
                

    Functions
        

        
        chop
        

        This function chops off the last character of a string and returns the character
        chopped.
        

        
                chop(LIST)
        chop(VARIABLE)
        chop VARIABLE
        chop

Example:
        while  {
            shop;       # avoid \n on last field
            @array = split (/:/);
            ....
        }

        
        
crypt
        

        This function encrypts a string.
        

        
        crypt(PLAINTEXT,SALT)
        

        Example:
        if ( crypt($quess, $pass) eq $pass) {
            # guess is correct
        }
        
        
        
defined
        

        This function returns a Boolean value saying whether the value EXPR has a real
        value or not.
        

        
                defined(EXPR)
        defined EXPR
Example:
        print if defined $switch{'D'}; #Test a scalar value from associative array

        
        
grep
        

        This function evaluates EXPR for each element of LIST and returns the array
        value consisting of those elements for which the expression evaluated to true.
        

        
        grep(EXPR,LIST)
        

Example:
                @foo = grep(!/^/#/, @bar);  #@bar containes lines of code. Weed out comment lines.
        
                
        
index
        

        This function returns the position of the first occurrence of SUBSTR in STR.
        

        
                index(STR,SUBSTR,POSITION)
        index(STR,SUBSTR)
Example:
        $pos = $1;
        while (( $pos = index($string, $lookfor, $pos)) >= $[) {
            print "Found at $pos\n";        #look for occurence of $lookfor from posistion
                                            #$[ in a $string and print it
            $pos ++;
        }

        
        
join
        

        This function joins the separate strings of LIST into a single string with
        fields separated by the value of EXPR, and returns the string.
        

        
        join(EXPR,LIST)        
        

Example:
                S_ = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);        
        
        
length
        

        This function returns the length in characters of the value of EXPR.
        

        
                length(EXPR)
        length EXPR
        
        

        
print
        

        This function prints a string or a comma-separated lisr of strings. The
        function returns 1 if successful, 0 otherwise.
        

        
                print(FILEHANDLE LIST)
        print(LIST)
        print FILEHANDLE LIST
        print LIST
        print

        
        
printf
        

        This function prints a formatted string to a FILEHANDLE or, if ommited, the
        currently selected output filehandle.
        

        
                printf(FILEHANDLE FORMAT,LIST)
        printf(FORMAT,LIST)
        printf FILEHANDLE FORMAT,LIST
        printf FORMAT,LIST

        
        
reverse
        

        This function returns a string consisting of the characters of the first
        element of LIST in reverse character order.
        

        
                reverse(LIST)
        reverse LIST
Example:
        %barfoo = reverse %foobar;

        
        
s
        

        This function searches a string for a pattern, and if found, replaces that
        pattern with the replacement text and returns the number of the substitutions
        made.

                       g   option indicates that all occurences of the pattern
                                     are to be replaced;

                i   option indicates that matching is to be done in a 
                                     case-senesitive manner.   

                e   option indicates that replacement string is to be 
                                     evaluted as an expression rather than just as a 
                                     double-quoted string.
        
        
        

        s/PATTERN/REPLACEMENT/[g][i][e][o]
        

Example:
                for (;;) {                      #The substitute takes each line and replaces it
            print "$_\$";               #it with the value of $1 after processing it
            last unless $_ = ;   #through backquotes(running a /bin/sh on it)
            s`^([^#)(#.*)?\n$`$1`;
        }
    
        
        
splice
        

        This function removes the elements designated by OFFSET and LENGTH from array
        and replaces them with the elements of LIST, if any. The function returns the
        elements removed from array.
        

        
                splice(ARRAY,OFFSET,LENGTH,LIST)
        splice(ARRAY,OFFSET,LENGTH)
        splice(ARRAY,OFFSET)

Example:
        sub aeq {                                   #compare two array values
                local(&a) = splice(@_,0,shift);
                local(@b) = splice(@_,0,shift);
                return 0 unless @a == @b;           # same length?
                while (@a) {
                    return 0 if pop(@a) ne pop(@b);
                }
                return 1;
        }                                            #assuming array lengths before arrays
       
        
        
split
        

        This function splits a string into an array of strings, and returns the array
        value. The PATTERN matches the delimiters that separate the desired array 
        elements.
        

        
                split(/PATTERN/,EXP,LIMIT)
        split(/PATTERN/,EXP)
        split(/PATTERN/
        split

Example:
        ($login, $passwd, $remainder ) = split(/:/,$_,3);
        
        
        
sprintf
        

        This function returns formatted by the usual printfconventions.
        

        
        sprintf(FORMAT,LIST)
        

        
substr
        

        This function extracts a substring out of EXPR and returns it.
        

        
                substr(EXPR,OFFSET,LENGTH)
        substr(EXPR,OFFSET)

Example:
        substr($_,-1,1) = "Curly";  # replace the last character of $_ with "Curly"

        
        
tr
        

                        d      option deletes all characters within SEARCHLIST
                                        that are not found in REPLACEMENTLIST.

                s      option causes any substitutions that would result
                                        in multiple identical REPLACEMENTLIST characters
                                        to be output consecutively to be replaced with just 
                                        a single occurrence of that character.        
 
                 c     option complements the SEARCHLIST; any caharacters
                                        mentioned in SEARCHLIST are removed from string and
                                        the resulting string is used in place of SEARCHLIST.
        
        
                tr/SEARCHLIST/REPLACEMENTLIST/[c][d][s]
        y/SEARCHLIST/REPLACEMENTLIST/[c][d][s]

Example:
        ($HOST = $host) =~ tr/a-z/A-Z/;     #Translate while copying document
        
        
        

        
undef
        

        This function undefines the value of EXPR, which must be an lvalue.
        
 
        
                undef(EXPR)
        undef EXPR
        undef

String Proccessing

Conditional Constructs

Scalar Operators

Regular Expressions

Functions

Back to content