Wie kann ich ein einfaches Menü in Perl?

Ich arbeite an einem Perl-Skript, erfordert einige grundlegende Menü-Funktionalität. Letztendlich würde ich wie jedes Menü mit ein paar Optionen und dann entweder die option zum zurückkehren zum vorherigen Menü oder beenden.

Beispiel:

Dies ist ein Menü:

  1. Wahl 1
  2. Wahl 2
  3. Zurück zum vorherigen Menü
  4. Ausfahrt

Wählen Sie eine option:

Momentan habe ich ein Menü-Unterroutine machen den Menüs, aber es gibt keine Funktionen und erlaubt es, um zurück zum vorherigen Menü.

    sub menu
    {
        for (;;) {
            print "--------------------\n";
            print "$_[0]\n";
            print "--------------------\n";
            for (my $i = 0; $i < scalar(@{ $_[1]}); $i++) {
                print $i + 1, "\.\t ${ $_[1] }[$i]\n";
            }
            print "\n?: ";
            my $i = <STDIN>; chomp $i;
            if ($i && $i =~ m/[0-9]+/ && $i <= scalar(@{ $_[1]})) {
                return ${ $_[1] }[$i - 1];
            } else {
                print "\nInvalid input.\n\n";
            }
        }
    }

    # Using the menu
    my $choice1  = menu('Menu1 header', \@list_of_choices1);

    # I would like this menu to give the option to go back to
    # the first menu to change $choice1
    my $choice2 = menu('Menu2 header', \@list_of_choices2);

Ich will nicht zu hart code alle Menüs und verwenden if/elsif-Anweisungen für alle von der Verarbeitung so wandte ich mich der Menü-Funktion.

Meine Menüs derzeit so Aussehen...

Menü-Header:

  1. Choice1
  2. Auswahl2
  3. Choice3

?: (Geben Sie hier eingeben)

Diese Lösung noch nicht erlauben den Benutzer, um zurück zum vorherigen Menü oder beenden obwohl. Ich wurde überlegt, einen menu-Klasse zu behandeln, die Menüs, aber ich bin noch nicht sehr gut mit objektorientiertem Perl. Dies ist ein kleines Programm, mit nur ein paar Menüs, so dass durch eine komplexe Menü-Aufbau-Modul kann overkill. Ich möchte, dass mein code so leicht wie möglich.

EDIT:

Danke für die schnellen Antworten! Es ist aber immer noch ein Problem. Wenn ich wählen Sie eine option aus "Menu1" und Laufe auf "Menu2" ich möchte, dass das speichern der Auswahl von "Menu1" für die spätere Verwendung:

Menu1:

  1. Choice1 <-- speichern Sie Wert, wenn ausgewählt, und gehen Sie zum nächsten Menü
  2. Auswahl2 <-- ...
  3. Exit <-- beenden

Menu2:

  1. Choice1 <-- speichern Sie Wert, wenn ausgewählt, und gehen Sie zum nächsten Menü
  2. Auswahl2 <-- ...
  3. Zurück <-- zurück zum vorherigen Menü erneut Wert
  4. Exit <-- beenden

Auswahl entweder Choice1 oder Auswahl2 sollte speichern einen Wert in einer Variablen für die spätere Verwendung und Fortschritt zum nächsten Menü. Dann, wenn Sie sich entscheiden, gehen Sie zurück zum ersten Menü Menu2, wird es geben Ihnen die Möglichkeit, erneut Ihre Auswahl und definieren Sie die variable. Ich versuche zu vermeiden Sie die Verwendung globaler Variablen, die macht dies sehr schwierig.

Nach voran durch alle Menüs und Einstellung der Werte aller dieser Variablen möchte ich eine Unterroutine ausführen zu verarbeiten, all der Wahlen, und drucken Sie eine endgültige Ausgabe.

 sub main () {

   # DO MENU STUFF HERE

   # PROCESS RESULTS FROM MENU CHOICES
   my $output = process($menu1_choice, $menu2_choice, $menu3_choice, ... );
 }

Auch wenn jemand einen objektorientierten Ansatz, um diese Klassen benutzen oder einige andere Daten-Struktur, obwohl es vielleicht übertrieben, ich würde immer noch gerne sehen und versuchen, wickeln Sie meinen Kopf herum, die Idee!

InformationsquelleAutor tjwrona1992 | 2014-08-22
  1. 5

    Könnten Sie ein Modul, wie Begriff::Wählen:

    use Term::Choose qw( choose );

my $submenus = {
    menu1 => [ qw( s_1 s_2 s_3 ) ],
    menu2 => [ qw( s_4 s_5 s_6 s_7) ],
    menu3 => [ qw( s_8 s_9 ) ],
};
my @menus = ( qw( menu1 menu2 menu3 ) );
my $mm = 0;
MAIN: while ( 1 ) {
    my $i = choose( 
        [ undef, @menus ],
        { layout => 3, undef => 'quit', index => 1, default => $mm }
    );
    last if ! $i;
    if ( $mm == $i ) {
        $mm = 0;
        next MAIN;
    }
    else {
        $mm = $i;
    }
    $i--;
    SUB: while ( 1 ) {
        my $choice = choose(
            [ undef, @{$submenus->{$menus[$i]}} ],
            { layout => 3, undef => 'back' }
        );
        last SUB if ! defined $choice;
        say "choice: $choice";
    }
}
    InformationsquelleAutor sid_com
  2. 3

    Wenn Sie nicht wollen, zu gehen voll OO mit diesem, eine einfache Weise, Sie können diese viel flexibler ist es, die einzelnen Menü-Wahl zu kontrollieren, wie es ausgeführt wird. Lassen Sie uns sagen, jedes Menü ist ein array von hashes, die die Menü-Texten und einer coderef, die, was die Karte tut. 

    use strict;
use warnings;

sub menu {
    my @items = @_;

    my $count = 0;
    foreach my $item( @items ) {
        printf "%d: %s\n", ++$count, $item->{text};
    }

    print "\n?: ";

    while( my $line = <STDIN> ) {
        chomp $line;
        if ( $line =~ m/\d+/ && $line <= @items ) {
            return $items[ $line - 1 ]{code}->();
        }

        print "\nInvalid input\n\n?: ";
    }
}

my @menu_choices;
my @other_menu_choices;

@menu_choices = (
    { text  => 'do something',
      code  => sub { print "I did something!\n" } },
    { text  => 'do something else',
      code  => sub { print "foobar!\n" } },
    { text  => 'go to other menu',
      code  => sub { menu( @other_menu_choices ) } }
);

@other_menu_choices = (
    { text  => 'go back',
      code  => sub { menu( @menu_choices ) } }
);

menu( @menu_choices );

    Den menu Unterprogramm nimmt ein array von Optionen, und jede option, die "weiß", wie Sie zur Durchführung Ihrer eigenen Aktion. Wenn Sie möchten, dass Sie zum wechseln zwischen Menüs die Menü-option ruft einfach menu wieder mit einer anderen Liste von Optionen, wie in der "zurück" - Beispiel aus @other_menu_choices. Diese stellen die Verknüpfung zwischen den Menüs sehr einfach und es ist auch einfach hinzufügen exit-Optionen und so.

    Um diesen code sauber und lesbar, für alles andere als trivial Menü Aktionen, verwenden Sie eine benannte Referenz auf eine subroutine anstelle eines anonymen Subroutinen-Referenz. Zum Beispiel:

    @another_menu_options = (
    { text => 'complicated action'
      code => \&do_complicated_action
    }
);

sub do_complicated_action { 
    ...
}
    • Wie funktioniert dieser Linie der Arbeit return $items[ $line - 1 ]{code}->();? Warum geht es nicht wenn du es auf diese Weise return $items[ $line - 1 ]->{code};? Ich Schätze, dass ich nicht vollständig verstehen, wie anonyme Subroutinen in hashes arbeiten.
    • die -> - operator für die Dereferenzierung, aber in einer zusammengesetzten Struktur kann es weggelassen werden, zwischen den Ebenen. So $ref->[0]->{foo}->[2] ist das gleiche wie $ref->[0]{foo}[2]. Aber für sub-refs haben, müssen Sie auf die -> zum aufrufen der sub, sonst Perl denkt, die Sie zurückgeben möchten die sub auf sich selbst. Man könnte also auch schreiben return $items[ $line - 1 ]->{code}->();. Die ->() benötigt zum aufrufen der sub anstatt nur die Rückgabe als Wert.
    InformationsquelleAutor friedo
  3. 2

    Nach ein paar Monaten der Programmierung mit Perl habe ich gelernt, viel mehr über den Umgang mit Objekten und schrieb eine einfache Objekt-orientierte Menüs erstellen-Modul auf der Grundlage von friedo Antwort.

    # Menu.pm

#!/usr/bin/perl

package Menu;

use strict;
use warnings;

# Menu constructor
sub new {

    # Unpack input arguments
    my $class = shift;
    my (%args) = @_;
    my $title       = $args{title};
    my $choices_ref = $args{choices};
    my $noexit      = $args{noexit};

    # Bless the menu object
    my $self = bless {
        title   => $title,
        choices => $choices_ref,
        noexit  => $noexit,
    }, $class;

    return $self;
}

# Print the menu
sub print {

    # Unpack input arguments
    my $self = shift;
    my $title   =   $self->{title  };
    my @choices = @{$self->{choices}};
    my $noexit  =   $self->{noexit };

    # Print menu
    for (;;) {

        # Clear the screen
        system 'cls';

        # Print menu title
        print "========================================\n";
        print "    $title\n";
        print "========================================\n";

        # Print menu options
        my $counter = 0;
        for my $choice(@choices) {
            printf "%2d. %s\n", ++$counter, $choice->{text};
        }
        printf "%2d. %s\n", '0', 'Exit' unless $noexit;

        print "\n?: ";

        # Get user input
        chomp (my $input = <STDIN>);

        print "\n";

        # Process input
        if ($input =~ m/\d+/&& $input >= 1 && $input <= $counter) {
            return $choices[$input - 1]{code}->();
        } elsif ($input =~ m/\d+/ && !$input && !$noexit) {
            print "Exiting . . .\n";
            exit 0;
        } else {
            print "Invalid input.\n\n";
            system 'pause';
        }
    }
}

1;

    Mit diesem Modul können Sie erstellen Menüs und verlinken Sie Sie relativ einfach. Finden Sie unter Beispiel für die Verwendung unter:

    # test.pl

#!/usr/bin/perl

use strict;
use warnings;

use Menu;

my $menu1;
my $menu2;

# define menu1 choices
my @menu1_choices = (
    { text => 'Choice1',
      code => sub { print "I did something!\n"; }},
    { text => 'Choice2',
      code => sub { print "I did something else!\n"; }},
    { text => 'Go to Menu2',
      code => sub { $menu2->print(); }},
);

# define menu2 choices
my @menu2_choices = (
    { text => 'Choice1',
      code => sub { print "I did something in menu 2!\n"; }},
    { text => 'Choice2',
      code => sub { print "I did something else in menu 2!\n"; }},
    { text => 'Go to Menu1',
      code => sub { $menu1->print(); }},
);

# Build menu1
$menu1 = Menu->new(
    title   => 'Menu1',
    choices => \@menu1_choices,
);

# Build menu2
$menu2 = Menu->new(
    title   => 'Menu2',
    choices => \@menu2_choices,
    noexit  => 1,
);

# Print menu1
$menu1->print();

    Dieser code erzeugt ein einfaches Menü mit einem Untermenü. Einmal im Untermenü können Sie leicht gehen Sie zurück zum vorherigen Menü.

    Dank für all die tollen Antworten! Sie hat mir sehr geholfen, dies herauszufinden, und ich glaube nicht, dass ich würde haben endete mit einem so guten Lösung, ohne all die Hilfe!

    EINE BESSERE LÖSUNG:

    Verabschieden, um die hässlichen arrays von hashes!

    Einige der code-interne Menü.pm und Posten.pm-Module kann die Optik leicht verwirrend, aber dieses neue design macht die Schnittstelle der Aufbau der Menüs selbst viel sauberer und effizienter.

    Nachdem einige vorsichtige code-überarbeitung und Herstellung der einzelnen Menü-Elemente in Ihre eigenen Objekte war ich in der Lage zu schaffen eine viel sauberere Schnittstelle für die Erstellung von Menüs. Hier ist mein neuer code:

    Dies ist ein test-Skript zeigt ein Beispiel, wie die Module zu bauen-Menüs.

    # test.pl

#!/usr/bin/perl

# Always use these
use strict;
use warnings;

# Other use statements
use Menu;

# Create a menu object
my $menu = Menu->new();

# Add a menu item
$menu->add(
    'Test'  => sub { print "This is a test\n";  system 'pause'; },
    'Test2' => sub { print "This is a test2\n"; system 'pause'; },
    'Test3' => sub { print "This is a test3\n"; system 'pause'; },
);

# Allow the user to exit directly from the menu
$menu->exit(1);

# Disable a menu item
$menu->disable('Test2');
$menu->print();

# Do not allow the user to exit directly from the menu
$menu->exit(0);

# Enable a menu item
$menu->enable('Test2');
$menu->print();

    Dem Menü.pm-Modul dient zum Aufbau der Menü-Objekte. Diese Menü-Objekte enthalten kann, die mehrere Menü::Element-Objekten. Die Objekte gespeichert sind in ein array, so wird die Reihenfolge beibehalten.

    # Menu.pm

#!/usr/bin/perl

package Menu;

# Always use these
use strict;
use warnings;

# Other use statements
use Carp;
use Menu::Item;

# Menu constructor
sub new {

    # Unpack input arguments
    my ($class, $title) = @_;

    # Define a default title
    if (!defined $title) {
        $title = 'MENU';
    }

    # Bless the Menu object
    my $self = bless {
        _title => $title,
        _items => [],
        _exit  => 0,
    }, $class;

    return $self;
}

# Title accessor method
sub title {
    my ($self, $title) = @_;
    $self->{_title} = $title if defined $title;
    return $self->{_title};
}

# Items accessor method
sub items {
    my ($self, $items) = @_;
    $self->{_items} = $items if defined $items;
    return $self->{_items};
}

# Exit accessor method
sub exit {
    my ($self, $exit) = @_;
    $self->{_exit} = $exit if defined $exit;
    return $self->{_exit};
}

# Add item(s) to the menu
sub add {

    # Unpack input arguments
    my ($self, @add) = @_;
    croak 'add() requires name-action pairs' unless @add % 2 == 0;

    # Add new items
    while (@add) {
        my ($name, $action) = splice @add, 0, 2;

        # If the item already exists, remove it
        for my $index(0 .. $#{$self->{_items}}) {
            if ($name eq $self->{_items}->[$index]->name()) {
                splice @{$self->{_items}}, $index, 1;
            }
        }

        # Add the item to the end of the menu
        my $item = Menu::Item->new($name, $action);
        push @{$self->{_items}}, $item;
    }

    return 0;
}

# Remove item(s) from the menu
sub remove {

    # Unpack input arguments
    my ($self, @remove) = @_;

    # Remove items
    for my $name(@remove) {

        # If the item exists, remove it
        for my $index(0 .. $#{$self->{_items}}) {
            if ($name eq $self->{_items}->[$index]->name()) {
                splice @{$self->{_items}}, $index, 1;
            }
        }
    }

    return 0;
}

# Disable item(s)
sub disable {

    # Unpack input arguments
    my ($self, @disable) = @_;

    # Disable items
    for my $name(@disable) {

        # If the item exists, disable it
        for my $index(0 .. $#{$self->{_items}}) {
            if ($name eq $self->{_items}->[$index]->name()) {
                $self->{_items}->[$index]->active(0);
            }
        }
    }

    return 0;
}

# Enable item(s)
sub enable {

    # Unpack input arguments
    my ($self, @enable) = @_;

    # Disable items
    for my $name(@enable) {

        # If the item exists, enable it
        for my $index(0 .. $#{$self->{_items}}) {
            if ($name eq $self->{_items}->[$index]->name()) {
                $self->{_items}->[$index]->active(1);
            }
        }
    }
}

# Print the menu
sub print {

    # Unpack input arguments
    my ($self) = @_;

    # Print the menu
    for (;;) {
        system 'cls';

        # Print the title
        print "========================================\n";
        print "    $self->{_title}\n";
        print "========================================\n";

        # Print menu items
        for my $index(0 .. $#{$self->{_items}}) {
            my $name   = $self->{_items}->[$index]->name();
            my $active = $self->{_items}->[$index]->active();
            if ($active) {
                printf "%2d. %s\n", $index + 1, $name;
            } else {
                print "\n";
            }
        }
        printf "%2d. %s\n", 0, 'Exit' if $self->{_exit};

        # Get user input
        print "\n?: ";
        chomp (my $input = <STDIN>);

        # Process user input
        if ($input =~ m/^\d+$/ && $input > 0 && $input <= scalar @{$self->{_items}}) {
            my $action = $self->{_items}->[$input - 1]->action();
            my $active = $self->{_items}->[$input - 1]->active();
            if ($active) {
                print "\n";
                return $action->();
            }
        } elsif ($input =~ m/^\d+$/ && $input == 0 && $self->{_exit}) {
            exit 0;
        }

        # Deal with invalid input
        print "\nInvalid input.\n\n";
        system 'pause';
    }
}

1;

    Den Punkt.Uhr-Modul gespeichert werden müssen, in einem Unterordner namens "Menü", um für es zu auf Sie verwiesen werden, richtig. Dieses Modul ermöglicht Ihnen das erstellen-Menü::Element-Objekten, die einen Namen enthalten und eine Subroutinen-Referenz. Diese Objekte werden, was der Benutzer wählt aus dem Menü.

    # Item.pm

#!/usr/bin/perl

package Menu::Item;

# Always use these
use strict;
use warnings;

# Menu::Item constructor
sub new {

    # Unpack input arguments
    my ($class, $name, $action) = @_;

    # Bless the Menu::Item object
    my $self = bless {
        _name   => $name,
        _action => $action,
        _active => 1,
    }, $class;

    return $self;
}

# Name accessor method
sub name {
    my ($self, $name) = @_;
    $self->{_name} = $name if defined $name;
    return $self->{_name};
}

# Action accessor method
sub action {
    my ($self, $action) = @_;
    $self->{_action} = $action if defined $action;
    return $self->{_action};
}

# Active accessor method
sub active {
    my ($self, $active) = @_;
    $self->{_active} = $active if defined $active;
    return $self->{_active};
}

1;

    Dieser Entwurf ist eine große Verbesserung gegenüber meinem vorherigen design und macht das erstellen von Menüs sehr viel einfacher und sauberer.

    Lassen Sie mich wissen, was Sie denken.

    Alle Kommentare, Gedanken, oder Ideen für Verbesserungen?

    • Ich arbeite auf eine noch bessere Lösung 🙂 ich werde Bearbeiten Sie diesen posten, wenn es fertig ist!
    • Die bearbeitete Lösung gepostet wird! Hoffentlich hilft es jemandem 🙂
    InformationsquelleAutor tjwrona1992
  4. 1

    Folgenden wird ein Ansatz. Jede Entscheidung hat eine zugeordnete Unterprogramm. Wenn die Wahl gemacht ist, wird das entsprechende Unterprogramm aufgerufen. Hier bin ich mit anonymen Subroutinen, aber Sie können auch Referenzen auf benannte Subroutinen.

    use warnings; use strict;

sub menu {
  my $args = shift;
  my $title = $args->{title};
  my $choices = $args->{choices};

  while (1) {
    print "--------------------\n";
    print "$title\n";
    print "--------------------\n";
    for (my $i = 1; $i <= scalar(@$choices); $i++) {
      my $itemHeading = $choices->[$i-1][0];
      print "$i.\t $itemHeading\n";
    }
    print "\n?: ";
    my $i = <STDIN>; chomp $i;
    if ($i && $i =~ m/[0-9]+/ && $i <= scalar(@$choices)) {
      &{$choices->[$i-1][1]}();
    } else {
      print "\nInvalid input.\n\n";
    }
  }
}

my $menus = {};
$menus = {
  "1" => {
    "title" => "Menu 1 header",
    "choices" => [
       [ "Choice 1" , sub { print "Choice 1 selected"; }],
       [ "Choice 2" , sub { print "Choice 2 selected"; }],
       [ "Menu 2" , sub { menu($menus->{2}); }],
       [ "Exit" , sub { exit; }],
    ],
  },
 "2" => {
    "title" => "Menu 2 header",
    "choices" => [
       [ "Choice 3" , sub { print "Choice 3 selected"; }],
       [ "Choice 4" , sub { print "Choice 4 selected"; }],
       [ "Menu 1" , sub { menu($menus->{1}); }],
       [ "Exit" , sub { exit; }],
  ],
  },
};

menu($menus->{1});
    InformationsquelleAutor imran
  5. 1

    Danke an alle für die Antworten! Alle drei Antworten waren hilfreich, schließlich kommen mit meiner Lösung. Ich beschloss, gehen mit dem Begriff::Wählen Sie module, (Dank sid_com für die Idee). Meine Menü-Struktur war anders als Sie hatte ursprünglich vorgeschlagen, und es dauerte eine ganze Weile von meinen Kopf kratzen, um herauszufinden, wie man es tun, genau das, was ich wollte. Hoffentlich hilft diese Lösung jemand, der auf ein ähnliches problem.

    Konstruierte ich das Menü wie unten dargestellt:

    (Ich habe ersetzt meine Variablen mit mehr Allgemeinen Namen, so dass es einfacher ist, zu Folgen)

        #!/usr/bin/perl

    use strict;
    use warnings;
    use Term::Choose qw(choose);

    my @CHOICES1 = ('A','B','C');
    my @CHOICES2 = ('1','2','3');
    my @CHOICES3 = ('BLUE','YELLOW','GREEN');

    # function to use the choices
    sub some_function {
        print "THIS IS SOME FUNCTION!\n";
        print "Choice 1 is $_[0]\n";
        print "Choice 2 is $_[1]\n";
        print "Choice 3 is $_[2]\n";
        print "Have a nice day! :)\n";
    }

    sub main() {

        # clear the screen
        # (for some reason the build in screen clear 
        # for the module was not working for me)
        system ('cls');

        # create menu object
        my $menu = new Term::Choose();

        # menu 1
        for (;;) {
            my $choice1 = $menu->choose(
                [@CHOICES1, undef],
                {
                    prompt => 'Select a choice1:',
                    undef  => 'Exit',
                    layout => 3,
                }
            );
            last if ! $choice1;

            # submenu 1
            for (;;) {
                my $choice2 = $menu->choose(
                    [@CHOICES2, undef],
                    {
                        prompt => 'Select a choice2:',
                        undef  => 'Back',
                        layout => 3,
                    }
                );
                last if ! $choice2;

                # submenu2
                for (;;) {
                    my $choice3 = $menu->choose(
                        [@CHOICES3, undef],
                        {
                             prompt => 'Select a choice3:',
                            undef  => 'Back',
                            layout => 3,
                        }
                    );
                    last if ! $choice3;

                    # function operating on all choices
                    some_function($choice1, $choice2, $choice3);
                    return;
                }
            }
        }
    }

    main();

    Ich bin noch sehr neu in objektorientierten Perl, so dass dies eine sehr lange Zeit brauchte, um herauszufinden, und es ist vielleicht nicht perfekt, aber es bekommt den job getan. Lassen Sie mich wissen, wenn Sie irgendwelche Ideen oder Verbesserungen!

    InformationsquelleAutor tjwrona1992
  6. -1

    Ich gefunden habe, dieses alte Modul ohne perldoc in meinem perl-Module...
    Bitte, probieren Sie es aus...

    #!/usr/bin/perl
    BEGIN { $Curses::OldCurses = 1; }
    use Curses;
    use perlmenu;
    &menu_init(0,"Select an Animal"); # Init menu

    &menu_item("Collie","dog"); # Add item
    &menu_item("Shetland","pony"); # Add item
    &menu_item("Persian","cat"); # Add last item

    $sel = &menu_display("Which animal?"); # Get user selection

    if ($sel eq "dog") {print "Its Lassie!\n";}
    InformationsquelleAutor MuchiProds
Schreibe einen Kommentar