Masquer certains caractères d'e-mail
Masquer les caractères des e-mails:
Lorsque l'e-mail n'a qu'une seule lettre, couvrez-la simplement avec le
*symbole, par exemple*@gmail.comLorsque l'e-mail a deux lettres, couvrir la deuxième lettre avec le symbole * par exemple
t*@gmail.comLorsque l'e-mail a trois lettres, couvrez la deuxième et la troisième avec le symbole,
*par exemplet**gmail.comLorsque 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();
}
- localiser à quel index au signe situé
- couper tout jusqu'au signe qui nous donne le nom de l'e-mail uniquement pour que nous puissions facilement.
Réponses
Bugs:
privateEmail.substring(0, 2)doit être remplacé parprivateEmail.substring(0, 3)danselse, puisque l'index de fin est exclusif et que nous voulons inclure 3 caractères, pas 2.La méthode suppose que
privateEmailcontient un "@" et ne vérifie pas si leatSignIndexrésultat est -1, ce qui entraîne unStringIndexOutOfBoundsExceptions'il n'y a pas de "@". RenvoyezprivateEmail(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, outhrowunIllegalArgumentExceptionifprivateEmailest 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:
À utiliser
varpour l'inférence de type où le type est évident du côté droit, commenew StringBuilder(...)ouString#substring. C'est à partir de Java 10.1 < emailName.length()est redondant car les longueurs 0 et 1 sont gérées par les cas précédents.StringUtils.repeatpeut être remplacé par àString#repeatpartir de Java 11. Rids de besoin de dépendance externe ici.L'instanciation d'un nouveau
StringBuilderdans else peut être remplacée par la mutation de l'actuel, à savoir avec les méthodes d'instancedeleteetinsert.Déplacer la
stringBuilderdéclaration vers le bas, uniquement lorsque cela est nécessaire.Remplacez "*" par une
staticfinalvariable, de sorte que nous puissions le changer en "-" ou "_" plus tard et rester cohérent sur tous lesifs et leelse. Ceci, bien qu'il s'agisse d'un personnage, devra être unStringpour rester compatible avec le typeString#repeatetStringBuilder#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();
}
}
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