masque tous les chiffres sauf les 6 premiers et les 4 derniers chiffres d'une chaîne (la longueur varie)
J'ai un numéro de carte sous forme de chaîne, par exemple:
string ClsCommon.str_CardNumbe r = "3456123434561234";
La longueur de ce numéro de carte peut varier de 16 à 19 chiffres, selon les besoins.
Mon exigence est que je dois montrer les six premiers chiffres et les 4 derniers chiffres d'un numéro de carte et masquer les autres caractères intermédiaires avec le caractère "X".
J'ai essayé d'utiliser subString et je l'ai implémenté séparément pour 16,17,18,19 chiffres.
J'ai divisé la chaîne (ClsCommon.str_CardNumber) en 5 chaînes (str_cardNum1, str_cardNum2, str_cardNum3, str_cardNum4, str_cardNum5 - 4 chiffres pour chaque chaîne ... chiffres restants pour la 5ème chaîne)
Toutes les chaînes sont placées dans le fichier ClsCommon . Sur cette base, j'ai implémenté le code ci-dessous, qui fonctionne parfaitement:
if (ClsCommon.str_CardNumber.Length == 16) {
txtmskcrdnum.Text = string.Concat(ClsCommon.str_cardNum1, " ", ClsCommon.str_cardNum2.Substring(0, 2), "XX", " ", "XXXX", " ", ClsCommon.str_cardNum4);
}
if (ClsCommon.str_CardNumber.Length == 17) {
txtmskcrdnum.Text = string.Concat(ClsCommon.str_cardNum1, " ", ClsCommon.str_cardNum2.Substring(0, 2), "XX", " ", "XXXX", " ", "X", ClsCommon.str_cardNum4.Substring(1, 3), " ", ClsCommon.str_cardNum5);
}
if (ClsCommon.str_CardNumber.Length == 18) {
txtmskcrdnum.Text = string.Concat(ClsCommon.str_cardNum1, " ", ClsCommon.str_cardNum2.Substring(0, 2), "XX", " ", "XXXX", " ", "XX", ClsCommon.str_cardNum4.Substring(2, 2), " ", ClsCommon.str_cardNum5);
}
if (ClsCommon.str_CardNumber.Length == 19) {
txtmskcrdnum.Text = string.Concat(ClsCommon.str_cardNum1, " ", ClsCommon.str_cardNum2.Substring(0, 2), "XX", " ", "XXXX", " ", "XXX", ClsCommon.str_cardNum4.Substring(3, 1), " ", ClsCommon.str_cardNum5);
}
txtmskcrdnum.Text = ClsCommon.str_CardNumber.PadLeft(ClsCommon.str_CardNumber.Length, 'X').Substring(ClsCommon.str_CardNumber.Length - 4);
Pour plusieurs longueurs, l'approche ci-dessus n'est pas utile.
Je veux une approche unique qui affiche les 6 premiers et les 4 derniers chiffres et masque les autres chiffres avec X . La dernière chaîne doit comporter un espace entre 4 chiffres.
Cela fonctionnera avec n'importe quelle longueur de numéro de carte:
var cardNumber = "3456123434561234";
var firstDigits = cardNumber.Substring(0, 6);
var lastDigits = cardNumber.Substring(cardNumber.Length - 4, 4);
var requiredMask = new String('X', cardNumber.Length - firstDigits.Length - lastDigits.Length);
var maskedString = string.Concat(firstDigits, requiredMask, lastDigits);
var maskedCardNumberWithSpaces = Regex.Replace(maskedString, ".{4}", "$0 ");
Essaye celui-là. Simple et direct.
public static class StringExtensions
{
public static string Masked(this string source, int start, int count)
{
return source.Masked('x', start, count);
}
public static string Masked(this string source, char maskValue, int start, int count)
{
var firstPart = source.Substring(0, start);
var lastPart = source.Substring(start + count);
var middlePart = new string(maskValue, count);
return firstPart + middlePart + lastPart;
}
}
Je voudrais faire quelque chose comme ça (pseudo C # - prenez comme idée approximative pour construire).
Code non testé à venir ...
string MaskDigits(string input)
{
//take first 6 characters
string firstPart = input.Substring(0, 6);
//take last 4 characters
int len = input.Length;
string lastPart = input.Substring(len - 4, 4);
//take the middle part (XXXXXXXXX)
int middlePartLenght = input.Substring(6, len - 4).Count();
string middlePart = new String('X', 5);
return firstPart + middlePart + lastPart;
}
Implémentation possible (selon différents formats, par exemple les nombres peuvent être divisés en groupes, etc.)
private static String MaskedNumber(String source) {
StringBuilder sb = new StringBuilder(source);
const int skipLeft = 6;
const int skipRight = 4;
int left = -1;
for (int i = 0, c = 0; i < sb.Length; ++i) {
if (Char.IsDigit(sb[i])) {
c += 1;
if (c > skipLeft) {
left = i;
break;
}
}
}
for (int i = sb.Length - 1, c = 0; i >= left; --i)
if (Char.IsDigit(sb[i])) {
c += 1;
if (c > skipRight)
sb[i] = 'X';
}
return sb.ToString();
}
// Tests
// 3456-12XX-XXXX-1234
Console.Write(MaskedNumber("3456-1234-3456-1234"));
// 3456123XXXXX1234
Console.Write(MaskedNumber("3456123434561234"));
cette implémentation ne fait que masquer les chiffres et préserver le format.
Une méthode:
string masked = null;
for (int i = 0; i < str_CardNumber.Length; i++) {
masked += (i > 5 && i < str_CardNumber.Length - 4) ? 'X' : str_CardNumber[i];
if ((i + 1) % 4 == 0)
masked += " ";
}
Je suis sûr qu'il existe une façon plus propre de faire cela:
int currentChar = 0;
string maskable = "11111144441111";
string masked = maskable;
int length = masked.Length;
int startMaskPoint = 6;
int endMaskPoint = length - 4 - startMaskPoint;
masked = masked.Remove(startMaskPoint, endMaskPoint);
int numRemoved = length - masked.Length;
string Mask = "";
while (numRemoved != 0)
{
Mask = Mask + "#";
numRemoved--;
}
masked = masked.Insert(startMaskPoint, Mask);
string returnableString = masked;
while (length > 4)
{
returnableString = returnableString.Insert(currentChar + 4, " ");
currentChar = currentChar + 5;
length = length - 4;
}
Linq enregistre les lignes de codage, petit extrait de code.
Remplace par (*) caractère supérieur à 6 et soufflet longueur CardPan moins 4
var CardPan = "1234567890123456";
var maskedPan = CardPan.Aggregate(string.Empty, (value, next) =>
{
if (value.Length >= 6 && value.Length < CardPan.Length - 4)
{
next = '*';
}
return value + next;
});
Bon nombre des solutions données analysent l’entrée plusieurs fois. Ci-dessous, je présente une solution qui analyse l’entrée une seule fois . Mais je n’ai aucune expérience en C #, la fonction est donc écrite en Scheme.
La fonction est divisée en deux:
(1) visit-first-6 analyse les six premiers caractères et les concatène au reste du calcul . Lorsque visit-first-6 a analysé les six premiers caractères, il appelle visit-repos.
(2) visit-rest exploite le fait que nous pouvons retarder certains calculs jusqu'à ce que nous ayons acquis plus de connaissances . Dans ce cas, nous attendons de déterminer si l'élément de la liste doit être affiché jusqu'à ce que nous sachions combien de caractères il reste .
(define (mask xs)
(letrec ([visit-first-6 (lambda (xs chars-parsed)
(cond
[(null? xs)
;; Shorter than 6 characters.
'()]
[(< chars-parsed 6)
;; Still parsing the first 6 characters
(cons (car xs)
(visit-first-6 (cdr xs)
(1+ chars-parsed)))]
[else
;; The first 6 characters have been parsed.
(visit-rest xs
(lambda (ys chars-left)
ys))]))]
[visit-rest (lambda (xs k)
(if (null? xs)
;; End of input
(k '() 0)
;; Parsing rest of the input
(visit-rest (cdr xs)
(lambda (rest chars-left)
(if (< chars-left 4)
;; Show the last 4 characters
(k (cons (car xs) rest)
(1+ chars-left))
;; Don't show the middle characters
(k (cons "X"
rest)
(1+ chars-left)))))))])
(visit-first-6 xs
0)))
Masque de course à l'interprète Petite Chez Scheme
> (mask '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18))
(1 2 3 4 5 6 "X" "X" "X" "X" "X" "X" "X" "X" 15 16 17 18)
> (mask '())
()
> (mask '(1 2 3 4))
(1 2 3 4)
> (mask '(1 2 3 4 5))
(1 2 3 4 5)
> (mask '(1 2 3 4 5 6 7 8 9))
(1 2 3 4 5 6 7 8 9)
> (mask '(1 2 3 4 5 6 7 8 9 10))
(1 2 3 4 5 6 7 8 9 10)
> (mask '(1 2 3 4 5 6 7 8 9 10 11))
(1 2 3 4 5 6 "X" 8 9 10 11)
NB J’ai vu cela comme un exercice amusant et j’ai pensé que je pourrais aussi bien le partager… __ Yannick Meeus a déjà fourni une solution facilement compréhensible. Donc, cela ne sert que pour les intéressés.
Pourquoi ne pas remplacer un groupe correspondant spécifique à l’aide de Regex:
string cardNumber = "3456123434561234";
var pattern = "^(.{6})(.+)(.{4})$";
var maskedNumber = Regex.Replace(cardNumber, pattern, (match) =>
{
return Regex.Replace(String.Format("{0}{1}{2}",
match.Groups[1].Value, // the first 6 digits
new String('X', match.Groups[2].Value.Length), // X times the 'X' char
match.Groups[3].Value) /*the last 4 digits*/,".{4}", "$0 "); //finally add a separator every 4 char
});