कुछ ईमेल वर्ण छिपाएँ
ईमेल वर्ण छिपाएँ:
जब ईमेल में केवल एक अक्षर होता है तो उस पत्र को
*प्रतीक के साथ कवर करें*@gmail.comजब ईमेल में दो अक्षर हों तो प्रतीक के साथ दूसरा अक्षर कवर करें * उदा
t*@gmail.comईमेल तीन अक्षर है जब दूसरे और प्रतीक के साथ तीसरे कवर
*जैसेt**gmail.comजब ईमेल में चार या अधिक अक्षर होते हैं तो पहले तीन अक्षर दिखाते हैं और अंत में 4 सितारे जोड़ते हैं - उदा
tim****@gmail.com tom****@gmail.com
मेरा कोड काम करता है लेकिन मुझे लगता है कि इसका तरीका बहुत ज्यादा हार्ड-कोडिंग है और इसे ज्यादा साफ किया जा सकता है
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();
}
- स्थित चिह्न पर किस सूचकांक का पता लगाएं
- साइन अप करने तक सब कुछ ट्रिम करें जो हमें केवल ईमेल का नाम देता है ताकि हम आसानी से कर सकें।
जवाब
कीड़े:
privateEmail.substring(0, 2)आवश्यकताओं के बदलने के लिएprivateEmail.substring(0, 3)मेंelse, के बाद से अंत सूचकांक अनन्य है और हम 3 अक्षरों, नहीं 2 शामिल करना चाहते हैं।विधि मानती है कि
privateEmailइसमें "@" है, और यह जांच नहीं करता है कि क्याatSignIndexपरिणाम -1 है, जिसके परिणामस्वरूपStringIndexOutOfBoundsExceptionअगर कोई "@" नहीं है। वापसीprivateEmail(कोई छुपा के साथ लागू) जल्दी यदि आप उम्मीद कर इस विधि किसी भी सामान्य स्ट्रिंग जो संभवतः एक ई-मेल हो सकता है सौंप दिया, याthrowएकIllegalArgumentExceptionअगरprivateEmailहमेशा एक ईमेल होने की उम्मीद है। मैं बाद वाले को बेहतर डिजाइन मानता हूं। ध्यान दें कि ये दोनों स्थितियाँ खाली तारों को भी संभालती हैं।
सुधार:
varटाइप इंफ़ेक्शन के लिए उपयोग करें जहाँ राइट साइड से टाइप स्पष्ट है, जैसेnew StringBuilder(...), याString#substring। यह Java 10 की तरह है।1 < emailName.length()निरर्थक है क्योंकि 0 और 1 की लंबाई पहले के मामलों द्वारा नियंत्रित की जाती है।StringUtils.repeatString#repeatजावा 11 के रूप में प्रतिस्थापित किया जा सकता है। यहां बाहरी निर्भरता की आवश्यकता के रैक।StringBuilderदूसरे में एक नया इंस्टेंटिअटिंग को वर्तमान को बदलने के साथ बदला जा सकता है, अर्थात्deleteऔरinsertउदाहरण के तरीकों के साथ।stringBuilderघोषणा को कम से कम, केवल तब तक ले जाएं जब इसकी आवश्यकता हो।एक
staticfinalचर के साथ "*" बदलें , जैसे कि हम इसे सड़क पर नीचे "-" या "_" में बदल सकते हैं और सभीifs और the के अनुरूप बने रह सकते हैंelse। यह, एक चरित्र होने के बावजूद,Stringके साथ टाइप-संगत रहने के लिए एक होना होगाString#repeatऔरStringBuilder#replace। अंतिम कोड:
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();
}
}
मैंने एक कोड स्टेटमेंट को कोड (महत्वपूर्ण!) पर टिप्पणी करते हुए और एकल मामलों को सरल करते हुए, कोड को थोड़ा रिफैक्ट किया है। हो सकता है कि एक नाम की तरह obfuscateEMailअधिक समझ में आता है।
"अपवाद नहीं होना चाहिए" मामला अपवाद को फेंककर बदला जा सकता है।
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$
}
}
}
मुख्य मेथिड का उत्पादन निम्नानुसार है (यह एक JUnit परीक्षण होगा):
*@gmail.com
a*@gmail.com
a**@gmail.com
abc****@gmail.com
abc****@gmail.com
abc****@gmail.com