Masquer les 12 premiers caractères de la chaîne avec *?

Comment puis-je prendre de la valeur 123456789012345 ou 1234567890123456 et de le transformer en:

************2345 et ************3456

La différence entre les cordes au-dessus, c'est que l'un se compose de 15 chiffres et l'autre contient 16.

J'ai essayé le suivant, mais il ne garde pas les 4 derniers chiffres du numéro à 15 chiffres et maintenant importe ce que la longueur de la chaîne, 13, 14, 15 ou 16, je veux masque tous les premiers chiffres avec un *, mais garder les 4 derniers. Voici ce que j'ai essayé:

String.Format("{0}{1}", "************", str.Substring(11, str.Length - 12))

source d'informationauteur Xaisoft

.net c#c#-4.0

using System;

class Program
{
    static void Main()
    {
        var str = "1234567890123456";
        if (str.Length > 4)
        {
            Console.WriteLine(
                string.Concat(
                    "".PadLeft(12, '*'), 
                    str.Substring(str.Length - 4)
                )
            );
        }
        else
        {
            Console.WriteLine(str);
        }
    }
}

20

Quelque chose comme ceci:
```
string s = "1234567890123"; //example
string result = s.Substring(s.Length - 4).PadLeft(s.Length, '*');
```
Cela va masquer tous, mais les quatre derniers caractères de la chaîne. Il suppose que la chaîne source est d'au moins 4 caractères.
11

Façon la plus simple: Créer une extension de la méthode pour extraire les quatre derniers chiffres. Utilisez-la dans votre Chaîne.Format d'appel.

Par exemple:
```
public static string LastFour(this string value)
{
    if (string.IsNullOrEmpty(value) || value.length < 4)
    {
        return "0000";
    }
    return value.Substring(value.Length - 4, 4) 
}
```
Dans votre code:
```
String.Format("{0}{1}", "************", str.LastFour());
```
À mon avis, ce qui conduit à un code plus lisible, et il est réutilisable.

EDIT: peut-être pas le moyen le plus facile, mais une alternative qui peut produire plus facile à maintenir les résultats. <haussement d'épaules/>

LINQ:

char maskBy = '*'; 
string input = "123456789012345";
int count = input.Length <= 4 ? 0 : input.Length - 4; 
string output = new string(input.Select((c, i) => i < count ? maskBy : c).ToArray());

Essayez ceci:

var maskSize = ccDigits.Length - 4;
var mask = new string('*', maskSize) + ccDigits.Substring(maskSize);

static private String MaskInput(String input, int charactersToShowAtEnd)
{
  if (input.Length < charactersToShowAtEnd)
  {
    charactersToShowAtEnd = input.Length;
  }
  String endCharacters = input.Substring(input.Length - charactersToShowAtEnd);
  return String.Format(
    "{0}{1}", 
    "".PadLeft(input.Length - charactersToShowAtEnd, '*'), 
    endCharacters
    );
}

Ajuster la tête de la fonction en tant que nécessaire, appeler avec:

MaskInput("yourInputHere", 4);

private 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 (****)
    int middlePartLenght = len - (firstPart.Length + lastPart.Length);
    string middlePart = new String('*', middlePartLenght);

    return firstPart + middlePart + lastPart;
}

MaskDigits("1234567890123456");

//output : "123456******3456"

Essayez ce qui suit:

    private string MaskString(string s)
    {
        int NUM_ASTERISKS = 4;

        if (s.Length < NUM_ASTERISKS) return s;

        int asterisks = s.Length - NUM_ASTERISKS;
        string result = new string('*', asterisks);
        result += s.Substring(s.Length - NUM_ASTERISKS);
        return result;
    }

1

Regex avec un match évaluateur va faire le travail
```
string filterCC(string source) {
  var x=new Regex(@"^\d+(?=\d{4}$)");
  return x.Replace(source,match => new String('*',match.Value.Length));
}
```
Cela correspond à un nombre quelconque de chiffres suivi de 4 chiffres et la fin (il ne comprend pas les 4 chiffres de la remplacer). La fonction remplacer remplacera le match avec une chaîne de * de longueur égale.

Cela a l'avantage supplémentaire que vous pouvez l'utiliser comme une validation algorthim trop. Modifier le premier + {11,12} pour faire correspondre à un total de 15 ou 16 caractères et puis vous pouvez utiliser x.IsMatch pour déterminer la validité.

MODIFIER

Sinon, si vous voulez toujours un 16 char résultat qui vient d'utilisation
```
 return x.Replace(source,new String('*',12));
```

Un moyen simple

   string s = "1234567890123"; //example
   int l = s.Length;
   s = s.Substring(l - 4);
   string r = new string('*', l);
   r = r + s;

Essayez ceci:

static string Mask(string str)
{
    if (str.Length <= 4) return str;
    Regex rgx = new Regex(@"(.*?)(\d{4})$");
    string result = String.Empty;
    if (rgx.IsMatch(str))
    {
        for (int i = 0; i < rgx.Matches(str)[0].Groups[1].Length; i++)
            result += "*";
        result += rgx.Matches(str)[0].Groups[2];
        return result;
    }
    return str;
}

Vous devez vous connecter pour publier un commentaire.