Unit 1-subroutines in perl
1 like477 views
A Perl subroutine is a block of code that performs a specific task. Subroutines allow code to be reused and executed from different parts of a program with different parameters. They are defined using the "sub" keyword followed by the subroutine name and code block. Subroutines can accept arguments, return values, and contain private variables scoped to the subroutine using the "my" keyword. This modular approach improves code organization, reusability, and maintainability.
![PASSING ARGUMENTS TO A SUBROUTINE
You can pass various arguments to a subroutine like you do in any other programming
language and they can be accessed inside the function using the special array @_. Thus
the first argument to the function is in $_[0], the second is in $_[1], and so on.
You can pass arrays and hashes as arguments like any scalar but passing more than
one array or hash normally causes them to lose their separate identities. So we will
use references to pass any array or hash.
Let's try the following example, which takes a list of numbers and then prints their
average −](https://image.slidesharecdn.com/unit-1-subroutinesinperl-170313141651/85/Unit-1-subroutines-in-perl-5-320.jpg)
Unit 1-subroutines in perl
- 2. WHAT IS SUBROUTINE? A Perl subroutine or function is a group of statements that together performs a task. You can divide up your code into separate subroutines. How you divide up your code among different subroutines is up to you, but logically the division usually is so each function performs a specific task. Perl uses the terms subroutine, method and function interchangeably. The simplest way for reusing code is building subroutines. They allow executing the same code in several places in your application, and they allow it to be executed with different parameters. Define and Call a Subroutine The general form of a subroutine definition in Perl programming language is as follows − sub subroutine_name { body of the subroutine } The typical way of calling that Perl subroutine is as follows − subroutine_name( list of arguments ); Or &subroutine_name(earlier way);
- 3. Because Perl compiles your program before executing it, it doesn't matter where you declare your subroutine.
- 4. # # Main Code # pseudo-code ..set variables . call sub1 . call sub2 . call sub3 . exit program sub 1 # code for sub 1 exit subroutine sub 2 # code for sub 2 exit subroutine sub 3 # code for sub 3 call sub 4 exit subroutine sub 4 # code sub4 exit PROGRAM(CODE) DESIGN USING SUBROUTINES -PSEUDO CODE
- 5. PASSING ARGUMENTS TO A SUBROUTINE You can pass various arguments to a subroutine like you do in any other programming language and they can be accessed inside the function using the special array @_. Thus the first argument to the function is in $_[0], the second is in $_[1], and so on. You can pass arrays and hashes as arguments like any scalar but passing more than one array or hash normally causes them to lose their separate identities. So we will use references to pass any array or hash. Let's try the following example, which takes a list of numbers and then prints their average −
- 6. PASSING LISTS TO SUBROUTINES Because the @_ variable is an array, it can be used to supply lists to a subroutine. However, because of the way in which Perl accepts and parses lists and arrays, it can be difficult to extract the individual elements from @_. If you have to pass a list along with other scalar arguments, then make list as the last argument as shown below −
- 7. PASSING HASHES TO SUBROUTINES When you supply a hash to a subroutine or operator that accepts a list, then hash is automatically translated into a list of key/value pairs. For example −
- 8. RETURNING VALUE FROM A SUBROUTINE You can return a value from subroutine like you do in any other programming language. If you are not returning a value from a subroutine then whatever calculation is last performed will automatically returns value. You can return arrays and hashes from the subroutine like any scalar but returning more than one array or hash normally causes them to lose their separate identities. So we will use references to return any array or hash from a function. Let's try the following example, which takes a list of numbers and then returns their average −
- 9. PRIVATE VARIABLES IN A SUBROUTINE By default, all variables in Perl are global variables, which means they can be accessed from anywhere in the program. But you can create private variables called lexical variables at any time with the my operator. The my operator confines a variable to a particular region of code in which it can be used and accessed. Outside that region, this variable cannot be used or accessed. This region is called its scope. A lexical scope is usually a block of code with a set of braces around it, such as those defining the body of the subroutine or those marking the code blocks of if, while, for, foreach, and evalstatements. Following is an example showing you how to define a single or multiple private variables using my operator − sub somefunc { my $variable; # $variable is invisible outside somefunc() my ($another, @an_array, %a_hash); # declaring many variables at once }
- 10. The following example distinguishes between global variable and private variable.
- 11. ADVANTAGES OF SUBROUTINES Saves typing → fewer lines of code →less likely to make a mistake re-usable if subroutine needs to be modified, can be changed in only one place other programs can use the same subroutine can be tested separately makes the overall structure of the program clearer