use strict;
use warnings;
use v5.14;

while (1) {
    my $current = shift @ARGV;
    say $current;
    push @ARGV, $current;
    say "Hit return or enter 0 to exit";
    chomp (my $input = <STDIN>);
    last if $input eq "0";
}
exit 0;
[download]

I want it to ... present the name of the command, wait for the user, then print the description, wait for the user, ad infinitum.

That makes sense, but I think that passing the output of whatis to your program via @ARGV is not the right way to go, one reason being that command-line arguments are generally split on whitespace, whereas you would have a much easier time parsing the output of whatis on a line-by-line basis, and then parse each line with a regex (or split).

There are other methods to get the output of external programs into your Perl script, practically all of which can automatically split the input into lines. The simplest is backticks (``), aka qx, and it's built in to Perl, but that can have issues with shell quoting (and thereby security, depending on usage) and error handling. So I'd recommend using a module, such as: capture from IPC::System::Simple, run3 from IPC::Run3, or capture from Capture::Tiny (there are a couple more but I like these the best).

Instead, I might use @ARGV to allow the user to pick which commands they want to be quizzed on, e.g. perl bashflash dd echo cp or perl bashflash /bin/* - note that for the latter, fileparse from File::Basename is useful to get only the name of the command.

m#^(?!-\s)$#
[download]

m#^(-\s)$#
[download]

I also have no idea why you're pushing and shifting, so I don't know whether you're using them incorrectly, but my intuition says 'yes'

Anyway, Perl can do backticks and can change directories, so your users don't need to bother:

use strict;
use warnings;

sub usage {
    die <<END
Usage: $0 <directory of binaries you want to test your knowledge of>
For example:
$0 /usr/bin
END
}

my $path = shift or usage();
-r -x -d $path or usage();
chdir $path or die $!;

my @whatis;

print "wait a little...\n";

for (`whatis --wildcard * 2>/dev/null`) {
    chomp;
    push @whatis, [ split /\s+-\s+/, $_ ];
}

print "(control-d to exit)\n\n";

MAINLOOP: while (1) {
    for (@whatis) {
        print $_->[0];
        defined <STDIN> or last MAINLOOP;
        print "\t", $_->[1], "\n\n";
    }
}

print "\n";
[download]

`whatis --wildcard *`

The * will be expanded by the shell before whatis is called. If the intent is to have * be expanded to the files in the current directory, then the --wildcard switch can be dropped, but if the intent is to have the * be used in whatis's database search (which goes beyond the files in the current directory!), the * needs to be quoted, e.g. `whatis --wildcard "*"` - or use a module that can bypass the shell, such as capturex from IPC::System::Simple.

The * will be expanded by the shell before whatis is called.

Yes, I think that was what the OP intended. I'm just too lazy to read the manpage for 'whatis'. This thing doesn't seem very useful to me.

#!/usr/bin/perl

use strict;
use warnings;

open ( my $WIIB, '<', "WhatIsInBin");
our @binstrings = <$WIIB>;
close ($WIIB);
my @cards;
for my $line (@binstrings) {
    push ( @cards, ( substr ($line, 0, 22) ) );
    push ( @cards, ( substr ($line, 22) ) );
}

print "Bash Flash!\n";
while (1) {
    for my $currentcard (@cards) {
        print "$currentcard \n";
        <STDIN>;
    }
}

exit; 

#
[download]