/this/ && /that/
[download]

/this.*that|that.*this/s
[download]

Using Perl features, you can also do

/^(?=.*this)(?=.*that)/s
/^(?=.*this).*that/s
[download]

Keep in mind that these aren't all equivalent. Consider the string "thathis"

This achieves the AND requirement, but note the possibility of false matches if there is overlap between the two words (3rd example):

[0] Perl> $re = qr[(?=^.*this)(?=^.*that)];;
[0] Perl> $_ =~ $re and print "$_ matched" 
          for qw[thisthat thatthis thathis thisnthat thatnthis];;
thisthat matched
thatthis matched
thathis matched **
thisnthat matched
thatnthis matched
[download]

Actually /this/ && /that/ would return true in 3rd case, too, so OP should be happy with your (and ikegami's) solution.

Using match time pattern interpolation can avoid the && and it also avoids false positives with overlapping words. I'm not sure you could call it better though. What you have is much easier to understand and maintain.

use strict;
use warnings;

use re q{eval};

my %alt = ( this => q{that}, that => q{this} );
my $re  = do   
   {
       local $" = q{|};
       qr{(?x) ( @{ [ keys %alt ] } ) .* (??{ $alt{ $1 } }) };
   };
print
   sprintf( q{%-9s: }, $_ ),
   m{$re}
   ? qq{matched\n}
   : qq{did not match\n}
   for qw{ thisthat thatthis thathis thisnthat thatnthis };
[download]

The output.

thisthat : matched
thatthis : matched
thathis  : did not match
thisnthat: matched
thatnthis: matched
[download]

I hope this is of interest.

Update: I noticed the i flag on one of the OP's patterns but the above didn't work with mixed case. It is fixed in this version.

Which produces

thisthat : matched
thatthis : matched
thathis  : did not match
thisnthat: matched
thatnthis: matched
ThISnthAt: matched
[download]

$zipFile =~ /(this|that).*?(this|that)/i
[download]

False positive:

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

my $zipFile="foo bar this this blivitz";

if ( $zipFile =~ /(this|that).*?(this|that)/i ) {
    print "$1  $2";
}else{
    print "nope";
}
[download]

For a list of things to match in any order, what I did was:

my $regexLockParams = '(?:[\\s,]+'
    ."|(?:$regexSubstringOf{angle}|$regexSubstringOf{offset})\\s*$rege
+xNumber"
    ."|$regexSubstringOf{dispersion}\\s*$regexNumber"
       #."|..."
    .')+';
[download]

At the end of the match, you are left with $1 containing the angle, or undef if it was unspecified, and $2 containing the dispersion or again undef.
Order doesn't matter since the alternation is repeated.

IE:
angle 5, dispersion20 ==> $1=5  $2=20
disp1ang4 ==> $1=4  $2=1
d42 ==> $1=undef  $2=42

CAVEAT:
Each alternation branch must fail to match before the capture is closed, otherwise that capture variable will be overwritten and not get restored to the previous value when the engine backtracks past the capture.
You can use a lookahead (?=...)to ensure that the remainder of the branch will match if necessary. (In the above example, the capture was last, so there was no postfix to worry about)

sub safeCapture
{
    # Workaround for Regex issue in which backtracked captures inside 
+alternations inside repetition, will stomp on the capture value.
    my $prefix = shift;
    my $cap = shift;
    my $postfix = shift;
    return "$prefix($cap(?=$postfix))$postfix";
}
[download]

++$seen{lc($_)} for split /\s+/, $zipFile;
if ($seen{this} && $seen{$that}) {
    ....
}
[download]

if ($zipFile =~ /\bthis\b/i && $zipFile =~ /\bthat\b/i) {
    ....
}
[download]