use strict;
use warnings;
use 5.010;

{
    package Foo;
    our $bar;
}
{
    if (exists $::{'Foo::'}{bar}) {
        say "There's a Foo::bar with some sigil";
    }
    if (exists $::{'Foo::'}{baz}) {
        say "There's a Foo::baz with some sigil";
    }
}
[download]

(Update: added code)

thanks a lot!

They are called symbolic refs.

I must disagree with moritz. Using %:: instead of symbolic refs does not help at all. All the same problems and disadvantages exist because it does exactly the same thing. Using %:: has the additional disadvantage that it's not caught by use strict 'refs';. In fact, it's generally less readable and harder to code using %:: instead of symbolic refs, so it's usually a step backwards to use %::.

If you want to improve your approach, use accessors.

use strict;

{
  package Foo;
  my $str = 'foo str';
  sub str {
    my $class = shift;
    $str = $_[0] if @_;
    return $str;
  }
}

{
  package Bar;
  my $str = 'bar str';
  sub str {
    my $class = shift;
    $str = $_[0] if @_;
    return $str;
  }
}

my $class = 'Foo';
my $value = $class->str();
[download]

# So, how to get $Foo::Str without soft ref?
[download]

Moreover, how to know whether an arbitrary package has a specific global

1. various ways.
a) Any symbol table your current symbol table knows about - is in the current symbol table. So:

use strict;
package Foo;

use vars qw($str); # $Foo::str created
$str = 'foo str';

package main;

my $pack = "Foo::";
my $var = "str";
print ${*{${$main::{$pack}}{$var}}{SCALAR}};
__END__
foo str
[download]

b) You could also use string eval - but that's as deprecated as symbolic references hereabouts ;-)

use strict;
$Foo::str = 'foo str';
my $class = 'Foo';
my $value = eval "\$$class\::str";
print $value,$/;
[download]

2. Look into the symbol table:

package Foo;

use vars qw($str);
$str = "foo str";

package main; 

my $pack = "Foo::";
my $var = "str";
print "$_: ",(defined ${$main::{$pack}}{$_} ? 'yup' : 'nope'),$/
    for qw(str bar);
__END__
str: yup
bar: nope
[download]

update: Caveats about autovivification apply. You might want to break up the lookup into steps, operating with defined. Consider:

$\=$/;
use strict;
use warnings;

package Foo;

use vars qw($str);
$str = "foo str";

package main;

my $pack = "Bar::";
my $var = "str";
print "yup" if defined ${$main::{$pack}}{$var};
/::$/ and print for keys %main::
__END__
version::
Tie::
utf8::
re::
CORE::
DynaLoader::
mro::
strict::
attributes::
Bar::       <----here
Regexp::
vars::
UNIVERSAL::
Foo::
main::
Carp::
PerlIO::
IO::
Internals::
warnings::
DB::
[download]

Symbol tables are subject to autovivification, too.

So, how to get $Foo::Str without soft ref?