Re^7: search and replace strings in different files in a directory (Path::Tiny)

Dear Monks,

Thanks you for the exicting read. As promised, I did my homework and tried to comment the code you provided.

Please find my endeavours below.

Looking forward to your replies and comments, I am sure I lack some basic understanding and proper perl terminology

Thanks a mil in advance for your support.

#!/usr/bin/perl --
use strict;
use warnings;
use Data::Dump qw/ dd /;
# Creates a shortcut for calling Data::Dumper, writing dd is enough to
+ call module
Main( @ARGV );
# main function, takes every file (as an argument) that is passed to @
+ARGV, might be command line or files
#that are read in
exit( 0 );
#not really a clue, maybe main exits if no arguments are passed to it

#This defines the subrotine Main which is called in line 6 (in my edit
+or at least)
sub Main {
    dd( -argv, \@ARGV );
#calls Data::Dumper via reference => possibly to print which files are
+ being passed as arguments (control function) 
    for my $ar ( @ARGV ){
            #a for loop to treat each file that has been passed as arg
+ument to @ARGV with the sub Sky
            # each individual file assigned to $ar is in turn passed a
+s a parameter to the subroutine
       Sky( $ar );
    }
    Sky(6);
#not really a clue => Does that mean that the sub stops after six runs
+ 
}

#defining subroutine Sky
sub Sky {
    my( $ra ) = @_;
    # variable for the argument(s) passed to the sub, @_ accepts every
+ argument passed to sub, i.e. the files passed to main
    dd( -ra, $ra );
    #print data strucutre of the files -parameter -ra
    dd( -args, \@_ );
    #print data strucutre of the arguments passed to the subroutine
}


__END__
$ perl sky
("-argv", [])
("-ra", 6)
("-args", [6])

# explains what sky does
$ perl sky a b c
#if I were to pass a, b, c
("-argv", ["a", "b", "c"])
#@ARGV would contain ["a", "b", "c"]

#Lists individual files as they are passed to both the sub Sky and sub
+ Main
("-ra", "a")
("-args", ["a"])
("-ra", "b")
("-args", ["b"])
("-ra", "c")
("-args", ["c"])

#Still no clue about the number, sorrry
("-ra", 6)
("-args", [6])
[download]

Comment on Re^7: search and replace strings in different files in a directory (Path::Tiny) Download Code

Replies are listed 'Best First'.

Re^8: search and replace strings in different files in a directory (Path::Tiny)
by Athanasius (Archbishop) on Aug 28, 2014 at 07:22 UTC

Hello PitifulProgrammer,

Here’s some feedback on your annotations:

use Data::Dump qw/ dd /;
# Creates a shortcut for calling Data::Dumper, writing dd is enough to
+ call module
[download]

Say rather, writing dd is now enough to call Data::Dump::dd. But actually qw/ dd / is not needed here, because the Data::Dump module exports dd by default.

Main( @ARGV );
# main function, takes every file (as an argument) that is passed to @
+ARGV, might be command line or files
#that are read in
[download]

Correct, but note that in Perl, unlike in C, you don’t need a main function. (I assume that by “command line” you mean command line options.)

exit( 0 );
#not really a clue, maybe main exits if no arguments are passed to it
[download]

No, exit terminates the script and returns its argument to the shell. By convention, an exit value of zero means “success: the script terminated without errors.”

    dd( -argv, \@ARGV );
#calls Data::Dumper via reference => possibly to print which files are
+ being passed as arguments (control function)
[download]

No, dd is a Data::Dump function; Data::Dumper is a different module.

    Sky(6);
#not really a clue => Does that mean that the sub stops after six runs
[download]

No, it’s just another call to sub Sky with the literal 6 passed as an argument instead of the variable $ar.

    my( $ra ) = @_;
    # variable for the argument(s) passed to the sub, @_ accepts every
+ argument passed to sub, i.e. the files passed to main
[download]

Yes, but note that only the first of these arguments is being copied to the scalar variable $ra. (All the arguments passed to the sub remain in the array @_.)

Hope that helps,

Athanasius <°(((>< contra mundum Iustus alius egestas vitae, eros Piratica,

[reply]
[d/l]
[select]

Re^9: search and replace strings in different files in a directory (Path::Tiny)

by Anonymous Monk on Aug 28, 2014 at 08:58 UTC

But actually qw/ dd / is not needed here, because the Data::Dump module exports dd by default.

While technically its "not needed", it sure does document rather well where dd comes from :) so its there for documentation

[reply]

Re^9: search and replace strings in different files in a directory (Path::Tiny)

by PitifulProgrammer (Acolyte) on Aug 28, 2014 at 14:03 UTC

Dear Athanasius,

Thank you for going through my comments and providing feedback. I am quite happy that I was not completely wrong about all lines.

However some questions remain:

Why was the subroutine called with 6 passed as an argument. Was this just for demonstrating that not only strings but also numbers can be passed to a sub?.

Could you please clarify why only the first argument $ra is passed an the others remain in the array? Does that mean that arguments to a sub are passed in some kind of for loop?

my( $ra ) = @_;
    # variable for the argument(s) passed to the sub, @_ accepts every
+ argument passed to sub, i.e. the files passed to main
[download]

Looking forward to your feedback. Will work on the inital code and try to use more subroutines.

Thanks a mil for your support

Kind regards

[reply]
[d/l]

Re^10: search and replace strings in different files in a directory (Path::Tiny)

by Athanasius (Archbishop) on Aug 28, 2014 at 14:59 UTC

Hello PitifulProgrammer,

Why was the subroutine called with 6 passed as an argument. Was this just for demonstrating that not only strings but also numbers can be passed to a sub?

Maybe, I don’t know, I didn’t write the code. ;-)

Could you please clarify why only the first argument $ra is passed an the others remain in the array? Does that mean that arguments to a sub are passed in some kind of for loop?

No, no, no! Perl is not like C, where arguments are passed by value (i.e., as local copies). In Perl, arguments are passed by reference. Specifically, the arguments passed into a subroutine are available within that subroutine in the special array variable @_ (also called @ARG), which contains aliases to the originals.

What this means is that if you call foo($bar, $baz), then within that call to sub foo the variable $_[0], which is the first element of the array @_, is an alias for $bar, and likewise $_[1] is an alias for $baz. So if you change $_[0] within the subroutine, when you return from the subroutine you find that $bar has changed too.

Sometimes this is what you want, but mostly it isn’t. So the usual practice is to make local copies of the arguments before using them. These local copies are not aliases, so changing the local copies has no effect on the originals. There are two ways of creating the local copies:

Within a sub, when shift is used without an explicit argument it automatically shifts @_. For example,
```
sub foo
{
    my $x = shift;
    my $y = shift;
    ...
[download]
```
This removes the first two elements from @_ and makes copies of them in $x and $y, respectively.
Simple assignment:
```
sub foo
{
    my ($x, $y) = @_;
    ...
[download]
```
This makes local copies of the first two elements of @_, but @_ itself remains unchanged.

Please see the entry for @_ in perlvar, and study perlsub, especially the third paragraph of the “DESCRIPTION” section.

Hope that helps,

Athanasius <°(((>< contra mundum Iustus alius egestas vitae, eros Piratica,

[reply]
[d/l]
[select]

Re^10: search and replace strings in different files in a directory

by Anonymous Monk on Aug 28, 2014 at 23:22 UTC

I'd like to thank Athanasius for picking up the slack :)

Why was the subroutine called with 6 passed as an argument. Was this just for demonstrating that not only strings but also numbers can be passed to a sub?.

:) To demonstrates that arguments can be passed and they end up in @_ ... so you can lookup @_ in perlvar and read about it :)

Its also so you can resolve the issue you had in Re^2: search and replace strings in different files in a directory (Path::Tiny), something like