Maske alle Ziffern außer der 6 ersten und 4 letzten Ziffern der Zeichenfolge( Länge variiert )

Ich würde so etwas tun (pseudo-C# - nehmen Sie als grobe Idee aufbauen).

Ungetesteten code vor...

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

InformationsquelleAutor der Antwort David Votrubec

Mögliche Umsetzung (acccepts varios Formate z.B. zahlen können in Gruppen unterteilt werden 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"));

diese Umsetzung nur Masken, die Ziffern und das format beibehalten.

InformationsquelleAutor der Antwort Dmitry Bychenko

Ich bin sicher, es gibt eine bessere Möglichkeit, dies zu tun:

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

InformationsquelleAutor der Antwort Ted James

Viele der gegebenen Lösungen analysieren Sie die Eingabe mehrmals.
Unten präsentiere ich eine Lösung, die analysiert den input nur einmal.
Aber ich habe keine Erfahrung in C#, so wird die Funktion geschrieben ist in Schema.

Die Funktion ist in zwei Teile unterteilt:

(1) besuchen-ersten-6 analysiert die ersten sechs Zeichen und verkettet diese, um den rest der Berechnung.
Beim Besuch des-ersten-6 analysiert die ersten sechs Zeichen, ruft besuchen-rest.

(2) besuchen-rest nutzt die Tatsache, dass wir verzögern können einige Berechnungen, bis wir gewonnen haben, mehr wissen.
In diesem Fall werden wir warten, um festzustellen, ob das element in der Liste angezeigt werden soll, bis wir wissen, wie viele Zeichen noch übrig sind.

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

Ausgeführt Maske in der Petite Chez Scheme-interpreter

> (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. Ich sah dies als eine lustige übung, und ich dachte, ich könnte genauso gut teilen.
Yannick Meeus hat schon eine leicht verständliche Lösung.
So, dies dient nur für die interessiert.

InformationsquelleAutor der Antwort Little Helper