Passing arrays and hashes by reference will avoid copying, and will (depending on scale) be the way to make things go faster.

In Perl, arguments are always passed by reference

use Devel::Peek qw( Dump );

sub f {
   Dump( $_[0] );
   # ...
}

my $x = "abc";
Dump( $x );
f( $x );            # Only a "C pointer" copied onto the stack.
[download]

SV = PV(0x55df7c8f0ee0) at 0x55df7c91f1e0    <-- One scalar
  REFCNT = 1
  FLAGS = (POK,IsCOW,pPOK)
  PV = 0x55df7c94f190 "abc"\0
  CUR = 3
  LEN = 16
  COW_REFCNT = 1
SV = PV(0x55df7c8f0ee0) at 0x55df7c91f1e0    <-- Same scalar
  REFCNT = 1
  FLAGS = (POK,IsCOW,pPOK)
  PV = 0x55df7c94f190 "abc"\0
  CUR = 3
  LEN = 16
  COW_REFCNT = 1
[download]

That said, subs typically start by making a copy of the arguments.

use Devel::Peek qw( Dump );

sub f {
   my $x = shift;   # Scalar is copied.
   Dump( $x );
   # ...
}

my $x = "abc";
Dump( $x );
f( $x );            # Only a "C pointer" copied onto the stack.
[download]

SV = PV(0x5602d6441ee0) at 0x5602d6470148    <-- One scalar
  REFCNT = 1
  FLAGS = (POK,IsCOW,pPOK)
  PV = 0x5602d6478030 "abc"\0                <-- String buffer
  CUR = 3
  LEN = 16
  COW_REFCNT = 1
SV = PV(0x5602d6441f00) at 0x5602d6470100    <-- Different scalar
  REFCNT = 1
  FLAGS = (POK,IsCOW,pPOK)
  PV = 0x5602d6478030 "abc"\0                <-- String buffer
  CUR = 3
  LEN = 16
  COW_REFCNT = 2
[download]

But notice that both scalars share the same string buffer. Since 5.20, copying a scalar containing string usually doesn't involve copying the string buffer thanks to the Copy on Write (COW) mechanism. So even when scalars are effectively passed by copy (though explicit copying), the performance cost is relatively low.

"Passing by reference" ( reference in computer science lingo) is the default in Perl since $_[0] is an alias . (NB: "alias" != "reference" in Perl)

For instance you can do

 

my $string = "This is a string";

printWthStrRef($string);    # passing string by alias


sub printWthStrRef {
    my $ref = \( $_[0] );

    print $$ref;       # prints the string
    print $_[0];       # prints the string
    $_[0] = "new";     # overwrite original $string

}
[download]

You only need explicit references when passing multiple complex variables like arrays or hashes, to avoid flattening to lists.

(And even here you could use prototypes, but this is too far fetched here)

( disclaimer: I wrote this hours ago but the website was unresponsive for me)

I think, passing a string by reference makes sense when you work with extremely large string

Please read the earlier answers which show this completely wrong. Perl always passes by reference, so there's no reason to pass a reference.

Note that COW has a chance of failing. (The scalar needs to "owned by Perl", and its string buffer must have space to accommodate the COW count.) But even if you want to give your argument names without relying on COW, you don't have to change your code to use references. Instead, you can replace

my $x = shift;
[download]

with

use experimental qw( refaliasing declared_refs );

my \$x = \shift;
[download]

or

use Data::Alias qw( alias );

alias my $x = shift;
[download]

or

our $x; local *x = \shift;
[download]

Perl always passes by reference

Okay, but then why is it that as soon as I do my $STRING = shift; inside my sub, Perl's memory usage doubles (using TinyPerl 5.8 under Windows XP)?

It seems like it may be passed by reference, but as soon as you grab that using shift() or just do my $MYSTRING = $_[0]; then viola! You have another copy of the string!