¿Hay una manera más inteligente de hacer esto además de una larga cadena de declaraciones if o switch?

Estoy implementando un bot IRC que recibe un mensaje y lo reviso para determinar a qué funciones llamar. ¿Hay alguna forma más inteligente de hacer esto? Parece que rápidamente se saldría de control después de que me dieron 20 comandos.

Tal vez hay una mejor manera de abstraer esto?

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

Use una tabla de despacho . Esta es una tabla que contiene pares ("parte del mensaje", pointer-to-function). El despachador se verá así (en pseudocódigo):

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

( equalsIgnoreCasese puede manejar como un caso especial en algún lugar antes, o si tiene muchas de esas pruebas, con una segunda tabla de despacho).

Por supuesto, lo que pointer-to-functiondebe verse depende de su lenguaje de programación. Aquí hay un ejemplo en C o C ++. En Java o C #, probablemente usará expresiones lambda para ese propósito, o simulará "puntero a funciones" usando el patrón de comando. El libro en línea gratuito " Higher Order Perl " tiene un capítulo completo sobre las tablas de despacho con Perl.

Probablemente haría algo como esto:

public interface Command {
  boolean matches(String message);

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

Luego puede hacer que cada comando implemente esta interfaz y devuelva verdadero cuando coincida con el mensaje.

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

Estás utilizando Java, así que hazlo hermoso ;-)

Probablemente haría esto usando Anotaciones:

1. Crear una anotación de método personalizada

   @IRCCommand( String command, boolean perfectmatch = false )

2. Agregue la anotación a todos los métodos relevantes en la clase, por ejemplo

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

3. En su constructor, use Reflections para crear un HashMap de métodos a partir de todos los métodos anotados en su clase:

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

4. En su onMessageMétodo, solo haga un bucle para commandListtratar de hacer coincidir la Cadena en cada uno y llamar method.invoke()donde encaja.

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

¿Qué pasa si define una interfaz, digamos IChatBehaviourcuál tiene un método llamado Executeque toma en messageun cmdobjeto?

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

En su código, entonces implementa esta interfaz y define los comportamientos que desea:

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

Y así por el resto.

En su clase principal, tiene una lista de comportamientos ( List<IChatBehaviour>) que implementa su bot IRC. Entonces podría reemplazar sus ifdeclaraciones con algo como esto:

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

Lo anterior debería reducir la cantidad de código que tiene. El enfoque anterior también le permitiría proporcionar comportamientos adicionales a su clase de bot sin modificar la clase de bot en sí (según el Strategy Design Pattern).

Si desea que solo se active un comportamiento a la vez, puede cambiar la firma del executemétodo para obtener true(el comportamiento se ha activado) o false(el comportamiento no se activó) y reemplazar el bucle anterior con algo como esto:

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

Lo anterior sería más tedioso de implementar e inicializar ya que necesita crear y pasar todas las clases adicionales, sin embargo, debería hacer que su bot sea fácilmente extensible y modificable ya que todas sus clases de comportamiento serán encapsuladas y, con suerte, independientes entre sí.

"Inteligente" puede ser (al menos) tres cosas:

Mayor rendimiento

La sugerencia de la tabla de despacho (y sus equivalentes) es buena. Tal tabla se llamaba "CADET" en años anteriores para "No se puede agregar; ni siquiera se intenta". Sin embargo, considere un comentario para ayudar a un mantenedor novato sobre cómo administrar dicha tabla.

Mantenibilidad

"Hacerlo hermoso" no es una advertencia ociosa.

y, a menudo pasado por alto ...

Resistencia

El uso de toLowerCase tiene dificultades en el sentido de que algunos textos en algunos idiomas deben sufrir una reestructuración dolorosa al cambiar entre magiscule y miniscule. Desafortunadamente, existen los mismos escollos para toUpperCase. Solo ten en cuenta.

Puede hacer que todos los comandos implementen la misma interfaz. Luego, un analizador de mensajes podría devolverle el comando apropiado que solo ejecutará.

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

Parece que solo hay más código. Sí, aún necesita analizar el mensaje para saber qué comando ejecutar, pero ahora está en un punto definido correctamente. Puede ser reutilizado en otro lugar. (Es posible que desee inyectar el MessageParser, pero ese es otro asunto. Además, el patrón Flyweight podría ser una buena idea para los comandos, dependiendo de cuántos espera crear.)

Lo que haría es esto:

1. Agrupe los comandos que tiene en grupos. (tienes al menos 20 en este momento)
2. En el primer nivel, clasifique por grupo, de modo que tenga comandos relacionados con el nombre de usuario, comandos de canciones, comandos de conteo, etc.
3. Luego ingresa al método de cada grupo, esta vez obtendrá el comando original.

Esto hará que esto sea más manejable. Más beneficio cuando el número de 'más si' crece demasiado.

Por supuesto, a veces tener estos 'si no' no sería un gran problema. No creo que 20 sea tan malo.