Masquer certains caractères d'e-mail

Sep 05 2020

Masquer les caractères des e-mails:

  1. Lorsque l'e-mail n'a qu'une seule lettre, couvrez-la simplement avec le *symbole, par exemple*@gmail.com

  2. Lorsque l'e-mail a deux lettres, couvrir la deuxième lettre avec le symbole * par exemple t*@gmail.com

  3. Lorsque l'e-mail a trois lettres, couvrez la deuxième et la troisième avec le symbole, *par exemplet**gmail.com

  4. Lorsque l'e-mail contient quatre lettres ou plus, affichez les trois premières lettres et ajoutez 4 étoiles aux extrémités - par exemple

    tim****@gmail.com
    tom****@gmail.com
    

Mon code fonctionne mais j'ai l'impression qu'il est beaucoup trop codé en dur et peut être fait beaucoup plus proprement

public static String hideSomeOfEmailValue(String privateEmail) {
StringBuilder stringBuilder = new StringBuilder(privateEmail);
int atSignIndex = privateEmail.indexOf("@");
String emailName = privateEmail.substring(0, atSignIndex);

if (emailName.length() == 1) {
    return stringBuilder.replace(0, emailName.length(), "*").toString();
}
if (emailName.length() > 1 && emailName.length() < 4) {
    return stringBuilder.replace(1, atSignIndex, StringUtils.repeat("*", emailName.length() - 1)).toString();
} else {
    stringBuilder = new StringBuilder(privateEmail.substring(0, 2));
    String emailProvider = privateEmail.substring(atSignIndex);
    stringBuilder.append("****").append(emailProvider);
    return stringBuilder.toString();
}
  1. localiser à quel index au signe situé
  2. couper tout jusqu'au signe qui nous donne le nom de l'e-mail uniquement pour que nous puissions facilement.

Réponses

5 MarioIshac Sep 05 2020 at 11:19

Bugs:

  1. privateEmail.substring(0, 2)doit être remplacé par privateEmail.substring(0, 3)dans else, puisque l'index de fin est exclusif et que nous voulons inclure 3 caractères, pas 2.

  2. La méthode suppose que privateEmailcontient un "@" et ne vérifie pas si le atSignIndexrésultat est -1, ce qui entraîne un StringIndexOutOfBoundsExceptions'il n'y a pas de "@". Renvoyez privateEmail(sans masquage appliqué) tôt si vous vous attendez à ce que cette méthode reçoive une chaîne générique qui pourrait potentiellement être un e-mail, ou throwun IllegalArgumentExceptionif privateEmailest toujours censé être un e-mail. Je considère que ce dernier est un meilleur design. Notez que ces deux situations gèrent également les chaînes vides.

Améliorations:

  1. À utiliser varpour l'inférence de type où le type est évident du côté droit, comme new StringBuilder(...)ou String#substring. C'est à partir de Java 10.

  2. 1 < emailName.length() est redondant car les longueurs 0 et 1 sont gérées par les cas précédents.

  3. StringUtils.repeatpeut être remplacé par à String#repeatpartir de Java 11. Rids de besoin de dépendance externe ici.

  4. L'instanciation d'un nouveau StringBuilderdans else peut être remplacée par la mutation de l'actuel, à savoir avec les méthodes d'instance deleteet insert.

  5. Déplacer la stringBuilderdéclaration vers le bas, uniquement lorsque cela est nécessaire.

  6. Remplacez "*" par une static finalvariable, de sorte que nous puissions le changer en "-" ou "_" plus tard et rester cohérent sur tous les ifs et le else. Ceci, bien qu'il s'agisse d'un personnage, devra être un Stringpour rester compatible avec le type String#repeatet StringBuilder#replace. Code final:

private static final String HIDE_CHAR = "*";

public static String asHiddenEmail(String privateEmail) {
    int atSignIndex = privateEmail.indexOf("@");

    if (atSignIndex == -1) {
        throw new IllegalArgumentException("`privateEmail` must be an email.");
    }

    var stringBuilder = new StringBuilder(privateEmail);
    var emailName = privateEmail.substring(0, atSignIndex);

    if (emailName.length() == 1) {
        return stringBuilder.replace(0, emailName.length(), HIDE_CHAR).toString();
    }
    if (emailName.length() < 4) {
        var hiddenNameEnd = HIDE_CHAR.repeat(emailName.length() - 1);
        return stringBuilder.replace(1, atSignIndex, hiddenNameEnd).toString();
    }
    else {
        stringBuilder.delete(3, atSignIndex);
        stringBuilder.insert(3, HIDE_CHAR.repeat(4));
        return stringBuilder.toString();
    }
}
DorianGray Sep 07 2020 at 18:35

J'ai remanié un peu le code, en utilisant une instruction switch, en commentant le code (important!) Et en simplifiant les cas individuels. Peut-être qu'un nom comme celui- obfuscateEMailci serait plus compréhensible.

Le cas "Ne devrait pas arriver" pourrait être remplacé par le lancement d'une exception.

public class EMail {
    public static void main(String[] args) {
        System.out.println(hideSomeOfEmailValue("[email protected]")); //$NON-NLS-1$
        System.out.println(hideSomeOfEmailValue("[email protected]")); //$NON-NLS-1$
        System.out.println(hideSomeOfEmailValue("[email protected]")); //$NON-NLS-1$
        System.out.println(hideSomeOfEmailValue("[email protected]")); //$NON-NLS-1$
        System.out.println(hideSomeOfEmailValue("[email protected]")); //$NON-NLS-1$
        System.out.println(hideSomeOfEmailValue("[email protected]")); //$NON-NLS-1$
    }
    
    /**
     * 
     * @param privateEmail
     * @return
     */
    public static String hideSomeOfEmailValue(String privateEmail) {
        final int atSignIndex = privateEmail.indexOf('@');
        if (atSignIndex <= 0) {
            // Not an E-Mail address.
            // Shouldn't happen. Return the input.
            return privateEmail;
        }
        
        final StringBuilder obfuscatedEmail = new StringBuilder(privateEmail);
        switch (atSignIndex) {
        case 1:
            // When email only has one letter then just cover that letter with the * symbol e.g. *@gmail.com
            obfuscatedEmail.setCharAt(0, '*');
            return obfuscatedEmail.toString();

        case 2:
            // When email has two letters then cover second letter with the * symbol e.g. t*@gmail.com
            obfuscatedEmail.setCharAt(1, '*');
            return obfuscatedEmail.toString();
            
        case 3:
            // When email has three letters then cover second and third with the symbol * e.g. t**gmail.com
            return obfuscatedEmail.replace(1, 3, "**").toString(); //$NON-NLS-1$
            
        default:
            // When email has four or more letters then show first three letters and add 4 stars at the ends - e.g. tim****@gmail.com
            return obfuscatedEmail.replace(3, atSignIndex, "****").toString(); //$NON-NLS-1$
        }
    }
}

Le résultat du méthid principal est le suivant (il s'agira d'un test JUnit):

*@gmail.com
a*@gmail.com
a**@gmail.com
abc****@gmail.com
abc****@gmail.com
abc****@gmail.com