Validation des paramètres selon une référence fixe

Question

La méthode suivante permet de définir le type de transfert d'une connexion FTP. Fondamentalement, je voudrais valider la saisie de caractères (voir les commentaires).

Est-ce que ça va par-dessus bord? Y a-t-il une approche plus élégante? Comment abordez-vous la validation des paramètres en général? Tous les commentaires sont les bienvenus.

public void setTransferType(Character typeCharacter, 
     Character optionalSecondCharacter) throws NumberFormatException, 
     IOException { 

    // http://www.nsftools.com/tips/RawFTP.htm#TYPE 
    // Syntax: TYPE type-character [second-type-character] 
    // 
    // Sets the type of file to be transferred. type-character can be any 
    // of: 
    // 
    // * A - ASCII text 
    // * E - EBCDIC text 
    // * I - image (binary data) 
    // * L - local format 
    // 
    // For A and E, the second-type-character specifies how the text should 
    // be interpreted. It can be: 
    // 
    // * N - Non-print (not destined for printing). This is the default if 
    // second-type-character is omitted. 
    // * T - Telnet format control (<CR>, <FF>, etc.) 
    // * C - ASA Carriage Control 
    // 
    // For L, the second-type-character specifies the number of bits per 
    // byte on the local system, and may not be omitted. 

    final Set<Character> acceptedTypeCharacters = new HashSet<Character>(Arrays.asList(
      new Character[] {'A','E','I','L'} 
    )); 

    final Set<Character> acceptedOptionalSecondCharacters = new HashSet<Character>(Arrays.asList(
      new Character[] {'N','T','C'} 
    )); 

    if(acceptedTypeCharacters.contains(typeCharacter)) { 
     if(new Character('A').equals(typeCharacter) || new Character('E').equals(typeCharacter)){ 
      if(acceptedOptionalSecondCharacters.contains(optionalSecondCharacter)) { 
       executeCommand("TYPE " + typeCharacter + " " + optionalSecondCharacter); 
      } 
     } else { 
      executeCommand("TYPE " + typeCharacter); 
     } 
    } 
} 

Answer 1

Valider la chaîne entière dans une simple vérification regex: « »

String.matches("TYPE ([AE] [NTC]|I|L .)") 

(Notez que j'utilise (tout caractère) après la L parce que le document n'a pas expliqué ce que le caractère devrait être. Si cela ne peut être, disons, que 7 ou 8, utilisez [78].)

Vous pouvez aller plus loin avec ceci (capturer des groupes, précompiler l'expression régulière, autoriser des espaces supplémentaires arbitraires, etc.) mais ce qui est fait .

Answer 2

Voici comment je voudrais aller à ce sujet:

private static final List<String> ALLOWED = Arrays.asList("AN", "AT", "AC", "EN", "ET", "EC"); 

public void setTransferType(Character type, Character optional) 
    throws NumberFormatException, IOException { 

    String[] arr = new String[] { "AN", "AT", "AC", "EN", "ET", "EC" }; 

    if(type = 'I') 
    executeCommand("TYPE " + type); 
    else if(type = 'L') { 
    executeCommand("TYPE " + type + " " + optional); 
    else if(ALLOWED.contains("" + type + optional)) 
    executeCommand("TYPE " + type + " " + optional); 
    else 
    // Handle an incorrect argument error    
} 

• Votre code ne gère pas le cas 'L'. Je suppose que vous le voulez faire executeCommand("TYPE " + type + " " + optional);
• Votre code a ignoré silencieusement les paramètres incorrects. J'ai ajouté un else (le dernier) pour gérer explicitement ce cas.
• Les noms que vous utilisez sont trop bruyants. Par exemple, vous déclarez une variable de type Caractère et vous l'appelez typeCharacter. Le suffixe «Character» du nom est noise - il n'ajoute aucune information utile.
• Si l'interface et les responsabilités de votre méthode sont claires, je ne m'inquiéterais pas trop de sa mise en œuvre (en particulier dans des méthodes aussi courtes). Il suffit d'écrire la chose la plus simple qui fasse passer les tests. Si vous n'en avez pas encore écrit, il vaut mieux commencer tout de suite. Vous feriez mieux de passer votre temps à l'écrire au lieu de peaufiner l'implémentation.