First, please wrap your code, data and expected output within <code></code> tags.

You should always use strict; and use warnings;. I believe the problem you're having is that you don't define $public_key_type prior to the loop. perl lexicalizes variables, so if you define something within a scope, that variable will not be accessible outside of that scope; this is by design.

You don't show the beginning of the while loop, so I've guessed. Try something like the following (untested):

use strict;
use warnings;

my $public_key_type;

while (my $line = <DATA>){
    if ( $line =~ /^Public Key Type:/ ) {
        $public_key_type = scalar <DATA> for 1;
        $public_key_type =~ s/^\s+//;
        $public_key_type =~ s/\s+$//;
        $public_key_type =~ s/\R//g;
    }
}

print "$public_key_type\n";
[download]

-stevieb

perl lexicalizes variables, so if you define something within a scope, that variable will not be accessible outside of that scope ...

I think this is quite misleading. It doesn't make any distinction between lexical and package variables. The point should be clearly made that an automatically created or "autovivified" variable (which is what  $public_key_type might possibly be; no way to know from the code fragment shown) is a package global and visible (update: and accessible) everywhere. The following example runs with warnings, but of course can only run without strict (and a good thing, too!):

c:\@Work\Perl\monks>perl -le
"use warnings;
 ;;
 while (! $xyzzy || $xyzzy < 5) { ++$xyzzy; }
 print $xyzzy;
 ;;
 print for grep m{ xyzzy \z }xms, keys %main::;
"
5
xyzzy
[download]

Printing the  %main:: package namespace hash after the code is run shows autovivification of the variable globally.

---

Give a man a fish:  <%-{-{-{-<

Hi Randy_j53,

In Perl a variable will exist until the end of the scope it's created in. That's why we create variables with my(), in order to limit them to a restricted scope (block, package, subroutine, etc).

my $foo = 'bar';
[download]

#!/usr/bin/perl
use strict;
use warnings;

sub foo {
  my $bar = 'baz';
}

foo();

print $bar; # error
[download]

#!/usr/bin/perl
use strict;
use warnings;

my $bar = 'baz';

sub foo {
  $bar = 'qux';
}

foo();

print $bar; # prints 'qux'
[download]

And please, always put use strict; and use warnings; at the top of your code. These are Perl's safety features, and one of the main things they do is alert you when you are not getting variable scope right.

Hope this helps!

Edit: oops, missed the sub calls!

Also consider the implications of the following bit of code, which compiles and runs without errors or warnings:

   use strict;
   use warnings;
   my $foo = "bar ";
   {
      my $foo = "foo ";
      print $foo;
   }
   print $foo;
[download]

The definition of $foo which exists within the anonymous block conceals, without warning, the variable of the same name that exists outside the block.   Two entirely distinct values are maintained, each referred-to at different times and in different scopes by the same variable name.  Within the block, the value "bar " cannot be reached, and there is nothing to alert you to the probably-unintentional conflict.

This is not “incorrect” behavior.   It is, in fact, by design, although it might be slightly different from other languages you have used (and whose error, warning, and informational messages you might have come to rely upon).   This it just might be yet-another reason why “global variables are not a particularly good idea.”