perl programming
DESCRIPTION
Perl programmingTRANSCRIPT
RAHIM AHMEDOV
PERL Programming
CONTENTS
Introduction to Perl Programming languageScalarsControl structuresArraysHashesBasic I/ORegular expressionsFilehandles and filesSubroutines and modulesFile and directory operationsReferences
PERL PROGRAMMING LANGUAGE: Intro
PERL is for Practical Extraction And Report Language
Perl advantages: Combines shell script languages, Unix commands like
awk, sed, grep, sort, tr, include C library routines and system calls
Faster than shell scripts: perl interprets the commands, convert them in to platform independent byte code and then execute
Safer than C.
PERL PROGRAMMING LANGUAGE: Basics
Statements Use “;” as statement separator
Comments “#” use to comment the line “#!” identify the path that is used to compile and execute the
code. Appears at 1st line Printing
Use print command: print “Hello world”;Variables
Scalar variables: variable that contain single value. Scalars are identified by placing “$” before variable name:
$x = 10; $x = “ten”;
Simple operators Simple numeric operators: +, -, *, %, /, ** (exponential)
PERL PROGRAMMING LANGUAGE: Running script
Ways to run perl script: perl filename chmod +x filename; ./filename
Perl command line options: -e: execute perl statement:
perl –e ‘print “hello world”’ -w: display warnings. -c: check syntax of script without executing it -n: loop through the specified file, applying command
or script for each line, as awk. perl –ne ‘print’ records.dat
-v, -V: version information
SCALARS
Initializing and assigning values in perl is straightforward: $a = 1; $b = 3.14; $c = “String”; $d = undef;
undef is equivalent of null Perl allows uninitialized variables. Perl decides by
operator whether data is numeric or string $var = 15;
$var = $vrr +1;print $var;
If –w is used, perl check for 3 things: Variables that are used only once Subroutines that are defined 2nd time Syntactically correct but suspicious constructions
SCALARS: Scalar data
Numeric data: 2.5, -1.5e11, 1_000_000, 021 (octal), 0xaf, 0b1110011
String data: perl use to quotation for string Single quotation (strong quote): all characters are taken
literally. No character conversion nor variable interpolation is done: $var = “world”;print ‘hello $var\n’; Output: hello $var\n $>
Double quotation (weak quotes): all special characters are converted and variable interpolation is done: print “hello $var\n”; Output: hello world$>
Quoting operators; Single quote operator: q/string/
print q/hello $var\n/; Double quote operator: qq/string/
print qq/hello $var\n/;
SCALARS: Operators
Arithmetic operators assignment operators:
= , +=, -=, *=, /=, **=, %= Autoincrement and autodecrement operators
$a++, ++$a, $a--, --$a
Bitwise operators &, |, ^, >>, <<
Boolean expression If expression is undef or 0 it is false If expression is not undef or 0 it is true
SCALARS: Comparison operators
Numeric operator String operator
Meaning
> gt Greater than
< lt Less than
>= ge Greater than or equal
<= le Less than or equal
== eq Equal to
!= ne Not equal to
<=> cmp Boolean equality operator. $a = (3 <=> 2); #$a is 1$a = (3 <=> 3); #$a is 0$a = (3 <=> 4); #$a is -1
SCALARS: Logical operators
Symbol Word Meaning
&& and Logical and
|| or Logical or
! not Logical not
^ xor Exclusive or
SCALARS: String operators
Function Meaning
. Concatenate 2 string:$a = “hello”;$b = “world!”;$c = $a.$b; helloworld!
x Repeats string several time$c = $a x 2; hellohello
.= $a .= $b; helloworld
x= $a x= 2; hellohello
SCALARS: Reading from standard input
To read from standard input predefined filehandle STDIN can be used: $in = <STDIN>;
To remove last character (as the last character is always \n if you read from keyboard) chop and chomp string functions is used. chop(string): modify string by removing last
character of this string chomp(string): modify string by removing last
character of this string if the last character in \n chomp($in = <STDIN>);
SCALARS: String functions
Function Meaning
substr(string, start [, length])
Rvalue: $s = substr (…);Returns the substring to right value
Lvalue: substr($s, …) = “A string”;Replaces what would have been returned by function with the value on the right.
length $str Return length of string
reverse $str Returns a string in reversed order
lc $str Return string in lower case
lcfirst $str Return string with the 1st character in lowercase
ucfirst $str Return string with the 1st character in uppercase
ord $str Returns ASCII value of character
chr $num Returns character represented by the ASCII value
CONTROL STRUCTURES
if statement: if (condition) {statement_block} if (condition) {statement block} else {statement_block}
if (condition) {statement_block} elsif (condition2) {statement_block}…else {statement_block}
unless statement is same as if statement but block executes when condition is false. print “lets go outside” unless ($isRaining);
CONTROL STRUCTURES: Loops
while loop: executes as long as condition is true while (condition) {
statement_block}
until loop: executes as long as condition is false until (condition) {
statement_block}
do loops: do {
statement_block} while (condition);
do {statement_block
} until (condition); for loop
for (initialization; condition; increment) {statement_block} foreach loop
foreach $var (LIST) {statement_block} for $var (LIST) {statement_block}
CONTROL STRUCTURES: Heredocs
print <<end_tag;The text goes here …The text goes here ……end_tag
Text between tags is printed out exactly as formatted
Variables are interpolated and escape characters are converted
Back quotas (“``”) can be used to pass content of heredoc to shell for execution
CONTROL STRUCTURES: Statement modifiers
statemet if condition; print “$a world!\n” if $a eq “hello”;
statemet unless condition;statemet while condition;statemet until condition;statemet for condition;
CONTROL STRUCTURES: Loop control
next loop control: skip the rest of the block and begin the next iteration for ($i=0;$i<=10;$i++) {
print “$i “; next; print $i*10; } Output: 0 1 2 3 4 5 6 7 8 9 10
redo loop control restart current iteration for ($i=0;$i<=10;$i++) {
print “$i “; redo; print $i*10; } Output: 0 0 0 0 0 0 …
last loop control exit the loop for ($i=0;$i<=10;$i++) {
print “$i “; last; print $i*10; } Output: 0 1 2 3 4 5 6 7 8 9 10
CONTROL STRUCTURES: Labels
Labels are written in upper caseLoop controls are used as goto statement
$i = 1;TOP: {
print “$i “;$i++;last TOP if $i == 10;redo TOP;print “got here”;
}print “goodbye…\n”;
output: 1 2 3 4 5 6 7 8 9 goodbye…
ARRAYS
Array variable names start with @ @arr = (1, 2 , 3, 4, 5, 6, 7, 8);
Arrays are named listsLists are constructed by putting comma
separated scalars between parentheses (1, 2, 3, 4, 5, 6) (11, 13, “One”, “Two”) (12, 14, undef, “three”) List as the range of value: (1 .. 5) Empty list: ()
ARRAYS: Initialization and access
Array do not have to be declaredArray definition examples:
@arr1 = (1, 2, 3, 4, 5, 6); @arr2 = (11, 13, “One”, “Two”); @arr3 = (12, 14, undef, “three”); @arr4 = (1 .. 5); @arr5 = ();
qw// quoting operator can be used if array contains string data. qw// does not perform variable interpolation! @arr = (“one”, “two”, “three”, “four”); @arr = qw/one two three four/;
ARRAYS: Initialization and access (2)
Accessing single element $a = $arr[0]; $a = $arr[-2]; # accesses the 2nd to last element
Getting last index of an array $lst = $#arr;
Adding elements @arr = (@arr, “last”); # add to end @arr = (“first”, @arr); # add to front
Get the length of an array $len = @arr;
Iterations foreach $elem (@arr) {print $elem}
$_ “the default” variable foreach (@arr) {print $_} # $_ gets the current variable
ARRAYS: Flat lists and slices
Lists could be combined. Result is flat list where all elements are sequential@arr1 = (3, 4, 5);@arr2 = (6, 7, 8);@arr = (1, 2, @arr1, @arr2, 9, 10);print @arr;output: 1 2 3 4 5 6 7 8 9 10
Slices: @arr = (“one”, “two”, “three”, “four”, “five”, “six”);
@slice1 = @arr[1, 3]; @slice2 = @arr[0 .. 2]; @arr[1, 3] = @arr[3, 1]; #swap element 2 and 4
ARRAYS: @ARGV and multidimensional arrays
@ARGV contains arguments passed on the command line. $ARGV[0] contains 1st command line argument
Multidimensional array initialization @marr = ([1, 2, 3], [4, 5, 6]);
Multidimensional array element access: $x = $marr[1][0];
ARRAYS: Array functions
Function Description
shift array Removes 1st element of an array and return this removed element$first = shift @arr;
unshift array Insert element to the beginning of an array, returns array’s new count$cnt = unshift @arr “elem1”;
pop array Removes last element of an array and return this removed element$last = pop @arr;
push array, element Insert element to the end of an array, returns array’s new count$cnt = push @arr “elem”;
ARRAYS: Array functions (2)
Function Description
splice array, start_pos [, number, list]
Removes number of elements from array starting from start_pos. if number is not specified, removes till end if element. If LIST is specified, replace removed part with list.splice @arr, 2, 4, @rep_arr;
reverse array Reverse the array’s elements@rev = reverse @arr;
print Print array to output
print @arr;
grep reg_exp, array Returns matched to reg_exp elements of array.@narr = grep /^a/, @arr;
ARRAYS: split and join
split function splits string into substrings and return it to array. Regular expression, string or single characters can be a separator: @passwd = split /:/, $passwd;
If separator is “//” each character is spitted into array: @chars = split //, “abcdefgh”; Output: a b c d e f g h
To split and remove leading white spaces single quote (“‘ ‘” ) is used: $str = “ a b c”; @chrs = split / /, $str; #output: chrs[0]= “ “, chrs[1]=a,
# chrs[2]=“ “, chrs[3]=b, chrs[4]=c @chrs = split ‘ ‘, $str; #output: chrs[0]=a, chrs[1]=b,
# chrs[2]=c Join joins elements of an array into string:
$str = join “::”, @words;
ARRAYS: sorting
sort function by default sorts in ASCII order. @sortarr = sort @arr;
Sort logic used in sort function can be customized: String sort:
@sarr = sort {$a cmp $b} @arr; $a and $b is special variables which represents 1st and 2nd
elements String sort descending order:
@sarr = sort {$b cmp $a} @arr; Numeric sort:
@sarr = sort {$a <=> $b} @arr; @sarr = sort {$b <=> $a} @arr;
Complex example: @sarr = sort {$a <=> $b || $a cmp $b} @arr;
HASHES
Hashes are associative array, which is organized as key => value pair.
Hashes are represented by %Hash initialization example:
Define using key => value %emp = (“name” => “john”, “sname” => “hodson”, “position”=> “team member”);
Define using array like syntax %emp = (“name” , “john”, “sname” , “hodson”, “position”, “team member”);
Accessing hash elements: $emp_name = $emp{“name”};
Special hash variable %ENV contains environment variables: $path = $ENV{PATH};
HASHES: Hash functions
keys returns all keys in hash into array @k = keys %emp; $k = keys %emp; #return number of keys Keys are in random order.
values returns all values in hash into array @v = values %emp; $v = values %emp;
each returns one key and one value in every call ($k, $v) = each %emp;
reverse change values to keys, keys to values: %rev = reverse %emp;
HASHES: iterations and sorting
Using for loop with keys function foreach $key (keys %emp) {
print “$key -> $emp{$key}\n”; } foreach (keys %emp) {
print “$_ -> $emp{$_}\n”; }Using while loop with each function
while ( ($k, $v) = each %emp) {print “$k -> $v\n”; }
Sorting by the keys: foreach $key (sort keys %emp) { print “$key->$emp{$key}\n”; }
HASHES: Adding, removing and testing
Adding elements: %emp = (“name” => “John”, “sname” => “Hodson”, “position”=> “team member”)$emp{payroll} = “0888”; # add new key payrol
# with value 0888Deleting elements:
undef $emp{name}; # value set to “” or undef delete $emp{payroll}; # payroll key deleted
Checking existence and if defined print “exists” if exists $emp{payroll}; print “defined” if defined $emp{name};
Hash slices: @emp{“name”, “position”} = (“rahim”, “team member”); As hash slices is a list @ is used.
BASIC I/O
<> filehandle can be used to read file or files from command line: #!/usr/bin/perl -w
# reader.plwhile (<>) { print ; }
$> ./reader.pl data.txt data2.txt Formatted output
printf can be used to format output: printf [FILEHANDLE] FORMAT, LIST; printf “%15s %5d %4.2f\n”, “a”, 5, 5.1;
Commonly used formats: d decimal integer f floating point format s string - left justified + right justified
sprintf can be used to print into string:$str = sprintf FORMAT, LIST;
BASIC I/O: Page formats
format keyword is used for defining page formats: format FILE_HANDLE_NAME =
picture lines[argument lines].
format STDOUT =@<<<<<<<< @<<<<<<<<<<<< @##### @##### @###.##$$host, $ip, $kbin, $kbout, $costs.
Placeholder descriptions @<<<<: left justified field with fixed length @>>>>: right justified field with fixed length @||||: centered fields with fixed length @###.##: right justified numeric field with fixed length and optional decimal
point @*: multiline field ^<<<, ^>>>, …: fields that start with ^ are successively filled up with the
text of variable. For defining page header format “_TOP” is added to
FILE_HANDLE_NAME
BASIC I/O: printing using page formats
write is used to print data in desired page format. write [FLHANDLE]; #if FLHANDLE is omitted it prints to STDOUT
Example:open FORM1, "<$ARGV[0]";format STDOUT =@<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< @####### @########
@#####.####$$host, $ip, $kbin, $kbout, $costs.format STDOUT_TOP =Hostname IP Address KByteIN KByteOUT Cost===============================================================. while (<FORM1>) { ($host, $ip, $kbin, $kbout, $costs) = split ' ', $_;
write ; }
BASIC I/O: Changing format of filehandle
select is used to select filehandle as standard select FORM1; write;
$~ is standard output filehandle format: $~ = FORM1;
$^ is standard output filehandle header format: $^ = FORM1_TOP;
Special variables for page formats: $%: current page number $=: number of lines per page $-: number of lines remaining on the page
REGULAR EXPRESSIONS
Binding operator (=~) and matching operator (m// or //) is used for string search and matching if ($line =~ m/text/) { print “matches”; } Opposite of =~ is !~ (not matches)
Working with $_: while (<>) {
if ($_ =~ /ab/) {print $_;
} }
while (<>) {if (/ab/) {
print ;}
}
REGULAR EXPRESSIONS: single-char patterns
Character Description
. Any character:/a.b/
[…] Builds a character class. Any character found in class return a true/[a-zA-Z]/, /[abs1-0]/
[^…] Any character found in class return false./[^a-zA-Z]/, /[^abs1-0]/
\ Escape character. /[0-9]\+[0-9]/
| Or operator for regular expression/bc|ef/
REGULAR EXPRESSIONS: Default character class
Predefined character
Character class
Negated characters
Character class
\d [0-9] \D [^0-9]
\w [a-zA-Z0-9_] \W [^a-zA-Z0-9_]
\s (white space)
[ \r\t\n\f] \S [^ \r\t\n\f]
REGULAR EXPRESSIONS: Anchors
Anchor Description
^ The beginning of the line/^a6/
$ The end of line/..c$/
\b A word boundary. To delimit a word put \b in the front and at the end of pattern/ab\b/
\B Opposite of \b
REGULAR EXPRESSIONS: Quantifiers
Quantifier
Description
* The previous character is repeated 0 or more time/a5555*/
+ The previous character is repeated 1 or more time/a5555+/
? The previous character must appear exactly one time or not at all/a5?\D/
{n} The previous character exactly appears n times/a5{4}\D/
{m,n} The previous character appears from m to n times/a5{3,5}\D/
{m,} The previous character appears m or more times/a5{3,}\D/
(..) This groups characters together for use in alteration/(ab){2}/
REGULAR EXPRESSION: Capturing & back referencing
To mark substring () is used. To reference matched part $1..$N is used: while (<>) {
/(.*):.*:.*:.*:(.*):.*:.*/;$login = $1; $comment = $2; }
Inside the regular expression pattern can also be back reference to matched parts. \1..\N is used as reference: /\w+i(ss)i\1/ matches:
MississippiGreediness is property of regular expression, where
patterns always try to match the largest possible part of a string $str = “In a galaxy far, far away”;if ($str =~ /(f.*r)/) {print $1}Result: far, far
REGULAR EXPRESSION: Special variables
Variable Meaning
$& Contains matching part of the whole string
$` Contains left part of the string (before matching position)
$’ Contains right part of the string (after matching position)
$+ Contains the last match in parentheses
REGULAR EXPRESSION: Substitute operator
s/// operator replace matching string with new string $str =~ s/match/replacement/;
Modifiers: i modifier makes search case insensitive:
$str =~ s/match/replacement/i; g modifier replaces all matched string. By default s
only replaces 1st match $str =~ s/match/replacement/g;
REGULAR EXPRESSION: Translation operator
tr/// is used for translation $str = “abcdabcd”;
$str =~ tr/a/A/; #makes a uppercase Modifiers for translation:
s modifier removes consecutive repeating characters from a string $str = “aaaabbbbccccdddd”;$str =~ tr/a-z/a-z/s; # $str is abcd
c modifier tells tr to replace any character not included in 1st list with the character in 2nd list $str = “abc def”; $str =~ tr/a-z/_/c; # $str is abc_def
If the length of the 2nd list does not match the 1st, the last character in the 2nd list will replace any characters in the 1st beyond it. $str = “abcdabcdefgh”; $str =~ tr/a-z/a-c/; # $str is abccabcccccc
FILEHANDLES & FILES
Opening files: open FH, “filename”; for reading: open FH, “<filename”; for writing, truncates the file: open FH, “>filename”; for appending: open FH, “>>filename”;
die function can be used error handling. It prints error message and exit program open FH, “<filename” or die “error! ”;
$! variable stores generated error message open FH, “<filename” or die $!;
Closing file handle close FH;
FILEHANDLES & FILES: Reading from file
<FILEHANDLE> is used for reading files: while ($ln = <FH>) { print $ln; } while (<FH>) { print $_;}
Reading file into array @lines = <FH>; # slurp file into array
DATA is predefined filehandle for reading data from script file itself. Data is denoted by the marker __END__ @line = <DATA>;foreach $ln (@line) {
print $ln; }__END__Data1 data2Data3 data4Data5 data6
FILEHANDLES & FILES: Writing to file
Print is used to write into filehandle open FH, “>filename”print FH “data”;
$, and $\ is used to modify print $, define separator between elements $\define trailing character$, = “--”;$\=“\n”;print “aa”, “bb”;print “cc”, “dd”;
Output: aa--bbcc--dd
FILEHANDLES & FILES: Processes & system commands
Using back quotes to start external commands: @lists = `who |grep sa`;
Using qx// to start external commands: @lists = qx/who |grep sa/;
Using system to start external command: system “date”; system “ping –s $host” and die “Command failed\n”;
Using filehandels: open LS, “ls –l |”; while (<LS>) {print ;} # same result as ls –l
Piping can be also used to write to another process open IN, “<file”;open OUT, “| wc”;while (<IN>) { print OUT; }
SUBROUTINES & MODULES
Subroutines are defined using sub keyword sub subroutine {
statement;statement;
}Valid invocation forms:
subroutine(); &subroutine(); &subroutine; subroutine;
To define return value return is used: sub subroutine {
statement;return value;
}
SUBROUTINES & MODULES: Passing parameters
When subroutine executes, the passed parameters are available in the special array @_. So no need for defining parameters when subroutines are declared: sub myuc{
$_[0] = uc ($_[0]);return $_[0];
}As the values stored in @_ are references to original
values, by default parameters are passing by reference.
Defining subroutine prototype: sub add($$);sub add {
return $_[0] +$_[1];}
SUBROUTINES & MODULES: Scope
By default all variables are global variables: $name = “Larry”;
$ret = myuc($name);print $copy_name;sub myuc{
$copy_name = $_[0]; $copy_name = uc($copy_name);return $copy_name; } output is LARRY
my is used to declare local variables. my variables have meaning only within the code block, where they are defined my $var;
local variables are broadened than my: they are also visible in subroutines called from within the block in which they are declared: sub printall {
local $car = “fiat”;printcar(); }
sub printcar { print $car; } output is fiat
SUBROUTINES & MODULES: Pragmas & context sensitivity
Pragmatic modules or pragmas gives the compiler hints how to handle the code. use strict; Strict pragma requires all variables in a script be declared as
my or as explicitly specify global variablesA context-sensitive subroutine returns the correct
data type whether it is in a scalar or list context. To implement context sensitivity wantarray is used: sub mysplit{
my $str = $_[0];my @list = split /:/, $str;my $len = @list;return @list if wantarray();return $len;
}
SUBROUTINES & MODULES: Libraries
Libraries are an older way of sharing subroutines Libraries should return true Creating library:
# mymath.plsub add { return $_[0]+$[1]; }sub substract { return $_[0]-$[1]; }sub mult { return $_[0]*$[1]; }1;
@INC array is searched by Perl for libraries and modules to include in script.
require is used to include library: use strict;
unshift @INC, “$ENV{HOME}/myPerlLibs”;require “mymath.pl”;my $x = 2; my $y = 3;my $sum = &add($x, $y);
Libraries do not have own namespace. So subroutines declared in libraries must be unique.
SUBROUTINES & MODULES: Packages
Packages store variables and subroutines in different namespaces Packages should return true; package is used to declare packages:
# mymath.plpackage mymath;sub add { return $_[0]+$[1]; }sub substract { return $_[0]-$[1]; }sub mult { return $_[0]*$[1]; }1;
For using package variables and subroutines namespace name (packname::) should be prefixed on variable and subroutine names use strict;
unshift @INC, “$ENV{HOME}/myPerlLibs”;require “mymath.pl”;my $x = 2; my $y = 3;my $sum = &mymath::add($x, $y);
Perl has default namespace for all scripts: main:: $main::sum = &mymath::add($x, $y); # Here $main::sum becomes global variable
SUBROUTINES & MODULES: Modules
Packages and libraries are included at run time, but modules are included at compile time.
Modules are defined in the same way as packages, but with extension .pm
use is used to include module in script. It includes file at compile time.
BEGIN{..} block is executed during compile time use strict;
BEGIN { unshift @INC, “$ENV{HOME}/myPerlLibs”; }use mymath;my $x = 2; my $y = 3;my $sum = &mymath::add($x, $y)
BEGIN { unshift @INC, “$ENV{HOME}/myPerlLibs/”; } can be replaced by use lib: use lib “$ENV{HOME}/myPerlLibs/”;
END{..} block is executed after end of program (even if program exits with die)
FILE & DIRECTORY OPERATIONS
Perl offers special file and directory test operators like UNIX shells:
General file and directory operators:
Operator Meaning
-A The access age in days
-b File is block-special file
-B File is binary
-c File is character-special file
-C Inode modification age in days
-d File is directory
-e File or directory exits
-f File is a plain file
-g File or directory have setgid
FILE & DIRECTORY OPERATIONS:General file & directory operators(2)
Operator Meaning
-k File or directory has sticky bit set
-l Entry is symbolic link
-M Modification age in days
-p Entry is named pipe
-s File or directory exits and has non-zero size. Also returns file size
-S The entry is socket
-T The entry is text
-u File has setuid
-z File exits and has zero size
FILE & DIRECTORY OPERATIONS: File & directory tests
Example: $file = “file”;if (-d $file) {
print “$file is directory\n”$age = -M $file;
}Perl use _ to access the inode information from the
last call. $file = “temp.pl”;-e $file or die “File doesn’t exists\n”;-w _ or die “File doesn’t have writable access\n”;
stat function retrieves complete list of inode contents: ($dev, $inode, $mode, $nlink, $uid,
$gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks) = stat $file;
FILE & DIRECTORY OPERATIONS: Permissions
Operator Meaning
-o File or directory is owned by user
-O File or directory is owned by real user
-r File or directory is readable
-R File or directory is readable by real user
-w File or directory is writable
-W File or directory is writable by real user
-x File or directory is executable
-X File or directory is executable by real user
FILE & DIRECTORY OPERATIONS: Reading directory contents
Using UNIX commands @dir = `ls`; @dir = `ls -l`; @dir = qx/ls –l *.txt/;
Using file-name globbing, <> is used for globbing for (<./*>) {
print “$_ \n”; } for (sort <$dir/*.pl>) {
print “$_ \n”; }Using directory handles. Directory handle
functions are not a filehandle and has its own namespace open DH, “dirname”;for (sort readdir (DH)) {
if (/\.pl/) {print “$_\n”;} }
FILE & DIRETORY OPERATIONS: File & directory functions
Function Meaning
opendir DH, “dirname”; Open a directory handle
readdir DH; Reads one entry from the directory handle DH
telldir DH; States the position of the pointer to DH
seekdir DH, pos; Sets the pointer to DH to the specific position
rewinddir DH; Sets the pointer to DH to the beginning
closedir DH; Closes DH
unlink filename; Deletes a file
rename oldfile, newfile; Renames a file or directory
link oldfile, newfile; Creates a hard link
symlink oldfile, newfile; Creates a symbolic link
FILE & DIRETORY OPERATIONS: File & directory functions (2)
Functions Meaning
readlink linkname; Returns the path and file pointed to by the link
mkdir dirname, perms; Create new directory
rmdir dirname; Deletes empty directory
chdir dirname; Change the current directory
chown uid, gid, filename; Change file owner
chmod perms, filename; Change permission of file
utime atime, mtime, filename; Changes access and modification time
REFERENCES
References in Perl are creating by putting \ in front of variable
Creating references to named: $str = “String”;$sref = \$str;
Creating references to anonymous variables $sref = \”String”;
To get access to data a reference points to, the reference must be dereferenced: $str = “String”;$sref = \$str;print ${$sref};${$sref} = “Newstr”; # $str become “Newstr”
New value cannot be assigned to references of anonymous variables!
REFERENCES: References to array
Creating reference to named array: @arr = (“elem1”, “elem2”);
$aref = \@arr; Creating reference to anonymous array: [] is used
@aref = [“elem1”, “elem2”]; \(“elem1”, “elem2”) is equivalent to (\”elem1”, \“elem2”) and will just
return list of two scalar references Dereferencing array references:
@new = @{$aref};print ${$aref}[1];
-> operator is also used for dereferencing array and hash references print $aref->[1];
Arrays can be passed by reference to subroutine, to keep their structure: func(\@a, \@b);
sub func{my ($aref, $bref) = @_;print $aref->[1], $bref->[1]; }
REFERENCES: References to hashes
Creating reference to named hash: %hash = (“key1”=>”value1”, “key2”=>”value2”); $href = \%hash;
Creating reference to anonymous hash: {} is used $href = {“key1”=>”value1”, “key2”=>”value2”};
Dereferencing hash references: %new = %{$href}; print $href ->{key1};
REFERENCES: Other references
References to subroutines: Create reference to named subroutine
$fref = \&myfunc; Create reference to anonymous subroutine
$fref = sub {print “I hate $_[0]”} ; Dereferencing :
&{fref}($x); $fref->($y);
Reference to filehandles is used if filehandles have to be passed to subroutines. Filehandle is prefixed by (*) $fhref =\*FH; print $fhref “something”;
Reference to refenece $str = “abcd”; $ref = \$str; $rref = \$ref;
print ${${$rref}}; # prints abcdprint $$$rref; # the same
REFERENCES: Complex data structures
References make it possible to build complex data structures Arrays of arrays – multidimensional arrays:
@marr ([1,2],[3,4],[5,6]);$a = ${$marr[2]}[0];$a = $marr[2]->[0];$a = $marr[2][0]; #all the same
Hashes of arrays %hash = (key0=>[1,2,3], key1=>[4,5,6]);
print $hash{key1}[1]; Arrays of hashes
@arr = ({“key0”=>”val0”, “key1”=>”val1”}, {“key0”=>”val3”, “key1”=>”val4”});
print $arr[1]{key1}; Hashes of hashes
%hash = (“key0” =>{“keya0”=>”vala1”, “keya1”=>”vala2”}, “key1”=> {“keyb0”=>”valb1”, “keyb1”=>”valb2”});
print $hash{key1}{keyb1};