Esiste un modo più intelligente per farlo oltre a una lunga catena di istruzioni if ​​o switch?

Sto implementando un bot IRC che riceve un messaggio e sto controllando quel messaggio per determinare quali funzioni chiamare. C'è un modo più intelligente di farlo? Sembra che mi sfuggirebbe rapidamente di mano dopo essermi alzato a 20 comandi.

Forse c'è un modo migliore per astrarre questo?

 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);
        }
    }

Utilizzare una tabella di invio . Questa è una tabella contenente coppie ("parte del messaggio", pointer-to-function). Il dispatcher avrà quindi questo aspetto (in pseudo codice):

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

(il equalsIgnoreCasepuò essere gestito come un caso speciale da qualche parte prima, o se hai molti di questi test, con una seconda tabella di spedizione).

Naturalmente, ciò che pointer-to-functiondeve apparire dipende dal tuo linguaggio di programmazione. Ecco un esempio in C o C ++. In Java o C # probabilmente userete espressioni lambda a tale scopo, oppure simulerete "puntatore a funzioni" utilizzando il modello di comando. Il libro online gratuito " Ordine superiore Perl " ha un capitolo completo sulle tabelle di spedizione che utilizzano Perl.

Probabilmente farei una cosa del genere:

public interface Command {
  boolean matches(String message);

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

Quindi puoi avere tutti i comandi implementare questa interfaccia e restituire true quando corrisponde al messaggio.

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
    }
}

Stai usando Java - quindi rendilo bellissimo ;-)

Probabilmente lo farei usando Annotations:

1. Creare un'annotazione del metodo personalizzata

   @IRCCommand( String command, boolean perfectmatch = false )

2. Aggiungi l'annotazione a tutti i metodi pertinenti nella classe, ad es

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

3. Nel tuo costruttore usa Reflections per creare una HashMap di metodi da tutti i metodi annotati nella tua classe:

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

4. Nel tuo onMessagemetodo, fai semplicemente un ciclo commandListcercando di abbinare la stringa su ognuno e chiamando method.invoke()dove si adatta.

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

Che cosa succede se si definisce un'interfaccia, dire IChatBehaviourquale ha un metodo chiamato Executeche accetta in messagee un cmdoggetto:

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

Nel tuo codice, quindi implementare questa interfaccia e definire i comportamenti desiderati:

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

E così via per il resto.

Nella tua classe principale, hai quindi un elenco di comportamenti ( List<IChatBehaviour>) implementati dal tuo bot IRC. È quindi possibile sostituire le ifdichiarazioni con qualcosa del genere:

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

Quanto sopra dovrebbe ridurre la quantità di codice che hai. L'approccio sopra ti consentirebbe anche di fornire comportamenti aggiuntivi alla tua classe di bot senza modificare la stessa classe di bot (come da Strategy Design Pattern).

Se si desidera attivare un solo comportamento alla volta, è possibile modificare la firma del executemetodo in modo da produrre true(il comportamento è stato attivato) o false(il comportamento non è stato attivato) e sostituire il ciclo precedente con qualcosa del genere:

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

Quanto sopra sarebbe più noioso da implementare e inizializzare poiché è necessario creare e superare tutte le classi extra, tuttavia, dovrebbe rendere il bot facilmente estensibile e modificabile poiché tutte le classi di comportamento saranno incapsulate e, si spera, indipendenti l'una dall'altra.

"Intelligente" può essere (almeno) tre cose:

Prestazioni più elevate

Il suggerimento di Dispatch Table (e suoi equivalenti) è valido. Un tavolo del genere era chiamato "CADET" negli anni passati per "Non posso aggiungere; non ci prova nemmeno". Tuttavia, considera un commento per aiutare un manutentore inesperto su come gestire detta tabella.

manutenibilità

"Make it beautiful" non è un ammonimento ozioso.

e, spesso trascurato ...

elasticità

L'uso di toLowerCase ha delle insidie ​​nel fatto che alcuni testi in alcune lingue devono subire una dolorosa ristrutturazione quando si passa da magiscule a miniscule. Sfortunatamente, esistono le stesse insidie ​​per toUpperCase. Basta essere consapevoli.

È possibile che tutti i comandi implementino la stessa interfaccia. Quindi un parser di messaggi potrebbe restituirti il ​​comando appropriato che eseguirai solo.

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);
    }
}

Sembra solo più codice. Sì, devi ancora analizzare il messaggio per sapere quale comando eseguire, ma ora si trova in un punto ben definito. Può essere riutilizzato altrove. (Potresti voler iniettare il MessageParser, ma questa è un'altra questione. Inoltre, il modello Flyweight potrebbe essere una buona idea per i comandi, a seconda di quanti ti aspetti di essere creato.)

Quello che vorrei fare è questo:

1. Raggruppa i comandi che hai in gruppi. (hai almeno 20 in questo momento)
2. Al primo livello, categorizza per gruppo, in modo da avere il comando relativo al nome utente, i comandi dei brani, i comandi di conteggio, ecc.
3. Quindi segui il metodo di ciascun gruppo, questa volta otterrai il comando originale.

Questo renderà questo più gestibile. Maggiori vantaggi quando il numero di "else if" aumenta troppo.

Certo, a volte avere questi "se altro" non sarebbe un grosso problema. Non credo che 20 sia così male.