c# - enmascarar todos los dígitos excepto los primeros 6 y los últimos 4 dígitos de una cadena(la longitud varía)

.net string

Question

Tengo un número de tarjeta como una cadena, por ejemplo:

string  ClsCommon.str_CardNumbe r = "3456123434561234";

La longitud de este número de tarjeta puede variar de 16 a 19 dígitos, según el requisito.

Mi requisito es que tengo que mostrar los primeros seis dígitos y los últimos 4 dígitos de un número de tarjeta y enmascarar los otros caracteres con el carácter ''X''.

He intentado usar SubString y lo he implementado por separado para 16,17,18,19 dígitos.

Dividí la cadena (ClsCommon.str_CardNumber) en 5 cadenas (str_cardNum1, str_cardNum2, str_cardNum3, str_cardNum4, str_cardNum5 - 4 dígitos para cada cadena .. dígitos remanentes para la 5ta cadena)

Todas las cadenas se colocan en el archivo ClsCommon. En base a eso implementé lo siguiente, que funciona perfectamente:

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);

Para longitudes múltiples, el enfoque anterior no es útil.

Quiero un enfoque único que muestre los primeros 6 y los últimos 4 dígitos y enmascara otros dígitos con X. La cadena final debe tener un espacio entre cada 4 dígitos.

Answer 1

¿Qué hay de reemplazar un grupo emparejado específico usando 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
        });

Answer 2

Esto funcionará con cualquier longitud de número de tarjeta:

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 ");

Answer 3

Estoy seguro de que hay una forma más limpia de hacer esto:

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;
}

Answer 4

Haría algo como esto (pseudo C # - tomar como una idea aproximada sobre la cual construir).

Código no probado por delante ...

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;
}

Answer 5

Linq guarda las líneas de codificación, pequeño fragmento de código.

Reemplaza con (*) caracteres por encima de 6 y debajo de CardPan longitud menos 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;
});

Answer 6

Muchas de las soluciones dadas analizan la entrada varias veces. A continuación presento una solución que analiza la entrada solo una vez. Pero no tengo experiencia en C #, por lo que la función está escrita en Esquema.

La función se divide en dos:

(1) visit-first-6 analiza los primeros seis caracteres y los concatena al resto del cálculo. Cuando visit-first-6 ha analizado los primeros seis caracteres, se llama visit-rest.

(2) visit-rest explota el hecho de que podemos retrasar algunos cálculos hasta que hayamos adquirido más conocimiento. En este caso, esperamos para determinar si el elemento de la lista debe mostrarse hasta que sepamos cuántos caracteres quedan.

(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)))

Máscara de running en el intérprete del 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)

NÓTESE BIEN. Vi esto como un ejercicio divertido y pensé que podría compartirlo. Yannick Meeus ya ha proporcionado una solución fácilmente comprensible. Por lo tanto, esto solo sirve para los interesados.

Answer 7

Posible implementación (acepta varios formatos, por ejemplo, los números se pueden dividir en grupos, 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"));

esta implementación solo enmascara los dígitos y conserva el formato.

Answer 8

Prueba este. Sencillo y directo.

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;
    }
}

Answer 9

Un método:

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 += " ";
}