Czy istnieje bardziej inteligentny sposób na zrobienie tego oprócz długiego łańcucha instrukcji if lub switch?

Wdrażam bota IRC, który odbiera wiadomość i sprawdzam tę wiadomość, aby określić, które funkcje wywołać. Czy jest na to bardziej sprytny sposób? Wygląda na to, że szybko wymknął się spod kontroli po tym, jak wykonałem 20 poleceń.

Być może istnieje lepszy sposób na streszczenie tego?

 public void onMessage(String channel, String sender, String login, String hostname, String message){

        if (message.equalsIgnoreCase(".np")){
//            TODO: Use Last.fm API to find the now playing
        } else if (message.toLowerCase().startsWith(".register")) {
                cmd.registerLastNick(channel, sender, message);
        } else if (message.toLowerCase().startsWith("give us a countdown")) {
                cmd.countdown(channel, message);
        } else if (message.toLowerCase().startsWith("remember am routine")) {
                cmd.updateAmRoutine(channel, message, sender);
        }
    }

Użyj tabeli wysyłki . To jest tabela zawierająca pary („część wiadomości”, pointer-to-function). Dyspozytor będzie więc wyglądał następująco (w pseudo-kodzie):

for each (row in dispatchTable)
{
    if(message.toLowerCase().startsWith(row.messagePart))
    {
         row.theFunction(message);
         break;
    }
}

( equalsIgnoreCasemoże być traktowany gdzieś wcześniej jako specjalny przypadek lub jeśli masz wiele z tych testów, z drugą tabelą wysyłkową).

Oczywiście to, jak pointer-to-functionmusi wyglądać, zależy od języka programowania. Oto przykład w C lub C ++. W Javie lub C # prawdopodobnie użyjesz do tego celu wyrażeń lambda lub symulujesz „wskaźnik do funkcji” za pomocą wzorca poleceń. Bezpłatna książka online „ Wyższy porządek Perl ” zawiera pełny rozdział na temat tabel wysyłkowych przy użyciu Perla.

Prawdopodobnie zrobiłbym coś takiego:

public interface Command {
  boolean matches(String message);

  void execute(String channel, String sender, String login,
               String hostname, String message);
}

Następnie możesz sprawić, by każde polecenie zaimplementowało ten interfejs i zwróciło true, gdy pasuje do komunikatu.

List<Command> activeCommands = new ArrayList<>();
activeCommands.add(new LastFMCommand());
activeCommands.add(new RegisterLastNickCommand());
// etc.

for (Command command : activeCommands) {
    if (command.matches(message)) {
        command.execute(channel, sender, login, hostname, message);
        break; // handle the first matching command only
    }
}

Używasz Javy - więc upiększ ją ;-)

Prawdopodobnie zrobiłbym to za pomocą Adnotacji:

1. Utwórz niestandardową adnotację metody

   @IRCCommand( String command, boolean perfectmatch = false )

2. Dodaj adnotację do wszystkich odpowiednich metod w klasie, np

   @IRCCommand( command = ".np", perfectmatch = true )
   doNP( ... )

3. W swoim konstruktorze użyj Reflections, aby utworzyć HashMap metod ze wszystkich metod z adnotacjami w twojej klasie:

   ...
   for (Method m : getDeclaredMethods()) {
   if ( isAnnotationPresent... ) {
       commandList.put(m.getAnnotation(...), m);
       ...

4. W swojej onMessagemetodzie po prostu wykonaj pętlę, commandListpróbując dopasować ciąg na każdym z nich i wywołać method.invoke()tam, gdzie pasuje.

   for ( @IRCCommand a : commanMap.keyList() ) {
       if ( cmd.equalsIgnoreCase( a.command )
            || ( cmd.startsWith( a.command ) && !a.perfectMatch ) {
           commandMap.get( a ).invoke( this, cmd );

Co się stanie, jeśli zdefiniujesz interfejs, powiedzmy, IChatBehaviourktóra ma wywoływaną jedną metodę, Executektóra przyjmuje a messagei cmdobiekt:

public Interface IChatBehaviour
{
    public void execute(String message, CMD cmd);
}

W swoim kodzie implementujesz ten interfejs i definiujesz pożądane zachowania:

public class RegisterLastNick implements IChatBehaviour
{
    public void execute(String message, CMD cmd)
    {
        if (message.toLowerCase().startsWith(".register"))
        {
            cmd.registerLastNick(channel, sender, message);
        }
    }
}

I tak dalej.

W swojej głównej klasie masz listę zachowań ( List<IChatBehaviour>), które implementuje twój bot IRC. Następnie możesz zamienić swoje ifwypowiedzi na takie:

for(IChatBehaviour behaviour : this.behaviours)
{
    behaviour.execute(message, cmd);
}

Powyższe powinno zmniejszyć ilość posiadanego kodu. Powyższe podejście pozwoliłoby również na dostarczenie dodatkowych zachowań do twojej klasy bota bez modyfikowania samej klasy bota (zgodnie z Strategy Design Pattern).

Jeśli chcesz, aby zadziałało tylko jedno zachowanie w danym momencie, możesz zmienić sygnaturę executemetody, aby uzyskać true(zachowanie zadziałało) lub false(zachowanie nie zadziałało) i zastąpić powyższą pętlę czymś takim:

for(IChatBehaviour behaviour : this.behaviours)
{
    if(behaviour.execute(message, cmd))
    { 
         break;
    }
}

Powyższe byłoby bardziej żmudne we wdrażaniu i inicjowaniu, ponieważ musisz utworzyć i przekazać wszystkie dodatkowe klasy, jednak powinno to uczynić twojego bota łatwym do rozszerzenia i modyfikowania, ponieważ wszystkie twoje klasy zachowań będą zamknięte i mam nadzieję, że będą od siebie niezależne.

„Inteligentny” może obejmować (przynajmniej) trzy rzeczy:

Wyższa wydajność

Sugestia tabeli wysyłki (i jej odpowiedników) jest dobra. Taki stół nazywał się w przeszłości „CADET” dla „Nie można dodać, nawet nie próbuje”. Zastanów się jednak nad komentarzem, który pomoże nowemu opiekunowi, jak zarządzać wspomnianą tabelą.

Konserwowalność

„Make it beautiful” nie jest bezczynnym napomnieniem.

i często pomijane ...

Odporność

Korzystanie z funkcji toLowerCase wiąże się z pułapkami polegającymi na tym, że niektóre teksty w niektórych językach muszą podlegać bolesnej restrukturyzacji przy zmianie między magiscule a maleinule. Niestety w przypadku toUpperCase istnieją takie same pułapki. Po prostu bądź świadomy.

Możesz mieć wszystkie polecenia implementujące ten sam interfejs. Następnie analizator komunikatów może zwrócić odpowiednie polecenie, które wykonasz tylko.

public interface Command {
    public void execute(String channel, String message, String sender) throws Exception;
}

public class MessageParser {
    public Command parseCommandFromMessage(String message) {
        // TODO Put your if/switch or something more clever here
        // e.g. return new CountdownCommand();
    }
}

public class Whatever {
    public void onMessage(String channel, String sender, String login, String hostname, String message) {
        Command c = new MessageParser().parseCommandFromMessage(message);
        c.execute(channel, message, sender);
    }
}

Wygląda jak tylko więcej kodu. Tak, nadal musisz przeanalizować komunikat, aby wiedzieć, które polecenie wykonać, ale teraz jest ono we właściwie zdefiniowanym punkcie. Może być ponownie użyty w innym miejscu. (Być może chcesz wstrzyknąć MessageParser, ale to inna sprawa. Ponadto wzorzec Flyweight może być dobrym pomysłem dla poleceń, w zależności od tego, ile utworzysz.)

Chciałbym to zrobić:

1. Pogrupuj posiadane polecenia w grupy. (masz teraz co najmniej 20)
2. Na pierwszym poziomie, kategoryzuj według grup, więc masz komendy związane z nazwą użytkownika, komendy piosenki, komendy liczenia itp.
3. Następnie zastosuj metodę każdej grupy, tym razem otrzymasz oryginalne polecenie.

Ułatwi to zarządzanie. Więcej korzyści, gdy liczba „else if” zbytnio rośnie.

Oczywiście czasami posiadanie tych „jeśli inaczej” nie byłoby dużym problemem. Nie sądzę, że 20 jest tak źle.