my %regular_hash = (
    question1 => 'How are you?',
    question2 => 'What is your name',
);

print $regular_hash{question1}; # prints 'How are you?'

change_question1(%regular_hash);

print $regular_hash{question1}; # still prints 'How are you?'

sub change_question1
{
    my %regular_hash = @_;
    $regular_hash{question1} = 'What is your mothers name?';
}
[download]

my $hash_rev = {   #notice the change of opening brace
    question1 => 'How are you?',
    question2 => 'What is your name',
};  # and the corresponding close

# and slightly different access methods
print $hash_ref->{question1}; # prints 'How are you?'

change_question1($hash_ref);

print $hash_ref->{question1}; # now prints 'What is your mothers name?
+'

sub change_question1
{
    my $hash_ref = shift @_;
    $hash_ref->{question1} = 'What is your mothers name?';
}
[download]

Ben is absolutely right - pass a hash *by reference* - that is, pass a reference to a hash instead of the hash itself.

One concept that Ben didn't mention that I think is worth acknowledging is that when parameters are passed to a subroutine, that argument list is "flattened" out into a list of scalars - arrays are flattened out into a list of scalars, and hashes are flattened out into a list of scalars - the result is one big list of scalars getting passed to the subroutine. This isn't a problem unless you pass an array or hash first, and *then* other parameter(s) - the array or hash that receives the 1st argument in the subroutine will likely "swallow up" all the arguments being passed in, since it can't tell from the one big "list" of scalars coming in which ones are intended for it and which ones are intended for other parameters.

To avoid confusion when passing "things" to subroutines, pass each parameter as a scalar - this means

  * passing scalars as themselves

  * passing a "reference to an array" (which is itself a scalar)
      instead of the array itself

  * passing a "reference to a hash" (which is itself a scalar)
      instead of the hash itself
[download]

Then if you really want to work with a "copy" of the array or hash (instead of just using the reference to refer to elements in the array or hash) whose reference was passed into the subroutine, you can create a copy like this:

  sub do_something($my_scalar, $my_arrayref, $my_hashref) {
    my @my_array = @$my_arrayref;
    my %my_hash  = %$my_hashref;
    ### more code here ###
  }
[download]

HTH.

if I update a variable value later on, it will not pick up the changed value

You need to store a reference, rather than simply copying the value. Example:

  my $foo = "foo";
  my %hash = (foo => \$foo);
  print ${$hash{foo}};
  $foo = "bar";
  print ${$hash{foo}};
[download]

s/\$(\w+)/$values{$1}/g
[download]

I think others have answered your question but I would like to add that any time I find myself passing a hash (or hash reference) around to a whole bunch of functions that manipulate the hash, it starts becoming obvious that I should think about converting that hash into a class and the all those functions into methods of that class. This does not work all the time and for all the functions but most of the time on a majority of the functions, at least for me.