Le formatage d'un UITextField pour la carte de crédit d'une entrée comme (xxxx xxxx xxxx xxxx)

Si vous êtes en utilisant Swift, allez lire mon port de cette réponse rapide 4 et l'utiliser à la place.

Si vous êtes en Objective-C...

Tout d'abord, à votre UITextFieldDelegate, l'ajout de ces variables d'instance...

NSString *previousTextFieldContent;
UITextRange *previousSelection;

... et ces méthodes:

//Version 1.3
//Source and explanation: http://stackoverflow.com/a/19161529/1709587
-(void)reformatAsCardNumber:(UITextField *)textField
{
//In order to make the cursor end up positioned correctly, we need to
//explicitly reposition it after we inject spaces into the text.
//targetCursorPosition keeps track of where the cursor needs to end up as
//we modify the string, and at the end we set the cursor position to it.
NSUInteger targetCursorPosition = 
[textField offsetFromPosition:textField.beginningOfDocument
toPosition:textField.selectedTextRange.start];
NSString *cardNumberWithoutSpaces = 
[self removeNonDigits:textField.text
andPreserveCursorPosition:&targetCursorPosition];
if ([cardNumberWithoutSpaces length] > 19) {
//If the user is trying to enter more than 19 digits, we prevent 
//their change, leaving the text field in  its previous state.
//While 16 digits is usual, credit card numbers have a hard 
//maximum of 19 digits defined by ISO standard 7812-1 in section
//3.8 and elsewhere. Applying this hard maximum here rather than
//a maximum of 16 ensures that users with unusual card numbers
//will still be able to enter their card number even if the
//resultant formatting is odd.
[textField setText:previousTextFieldContent];
textField.selectedTextRange = previousSelection;
return;
}
NSString *cardNumberWithSpaces = 
[self insertCreditCardSpaces:cardNumberWithoutSpaces
andPreserveCursorPosition:&targetCursorPosition];
textField.text = cardNumberWithSpaces;
UITextPosition *targetPosition = 
[textField positionFromPosition:[textField beginningOfDocument]
offset:targetCursorPosition];
[textField setSelectedTextRange:
[textField textRangeFromPosition:targetPosition
toPosition:targetPosition]
];
}
-(BOOL)textField:(UITextField *)textField 
shouldChangeCharactersInRange:(NSRange)range 
replacementString:(NSString *)string
{
//Note textField's current state before performing the change, in case
//reformatTextField wants to revert it
previousTextFieldContent = textField.text;
previousSelection = textField.selectedTextRange;
return YES;
}
/*
Removes non-digits from the string, decrementing `cursorPosition` as
appropriate so that, for instance, if we pass in `@"1111 1123 1111"`
and a cursor position of `8`, the cursor position will be changed to
`7` (keeping it between the '2' and the '3' after the spaces are removed).
*/
- (NSString *)removeNonDigits:(NSString *)string
andPreserveCursorPosition:(NSUInteger *)cursorPosition 
{
NSUInteger originalCursorPosition = *cursorPosition;
NSMutableString *digitsOnlyString = [NSMutableString new];
for (NSUInteger i=0; i<[string length]; i++) {
unichar characterToAdd = [string characterAtIndex:i];
if (isdigit(characterToAdd)) {
NSString *stringToAdd = 
[NSString stringWithCharacters:&characterToAdd
length:1];
[digitsOnlyString appendString:stringToAdd];
}
else {
if (i < originalCursorPosition) {
(*cursorPosition)--;
}
}
}
return digitsOnlyString;
}
/*
Detects the card number format from the prefix, then inserts spaces into
the string to format it as a credit card number, incrementing `cursorPosition`
as appropriate so that, for instance, if we pass in `@"111111231111"` and a
cursor position of `7`, the cursor position will be changed to `8` (keeping
it between the '2' and the '3' after the spaces are added).
*/
- (NSString *)insertCreditCardSpaces:(NSString *)string
andPreserveCursorPosition:(NSUInteger *)cursorPosition
{
//Mapping of card prefix to pattern is taken from
//https://baymard.com/checkout-usability/credit-card-patterns
//UATP cards have 4-5-6 (XXXX-XXXXX-XXXXXX) format
bool is456 = [string hasPrefix: @"1"];
//These prefixes reliably indicate either a 4-6-5 or 4-6-4 card. We treat all
//these as 4-6-5-4 to err on the side of always letting the user type more
//digits.
bool is465 = [string hasPrefix: @"34"] ||
[string hasPrefix: @"37"] ||
//Diners Club
[string hasPrefix: @"300"] ||
[string hasPrefix: @"301"] ||
[string hasPrefix: @"302"] ||
[string hasPrefix: @"303"] ||
[string hasPrefix: @"304"] ||
[string hasPrefix: @"305"] ||
[string hasPrefix: @"309"] ||
[string hasPrefix: @"36"] ||
[string hasPrefix: @"38"] ||
[string hasPrefix: @"39"];
//In all other cases, assume 4-4-4-4-3.
//This won't always be correct; for instance, Maestro has 4-4-5 cards
//according to https://baymard.com/checkout-usability/credit-card-patterns,
//but I don't know what prefixes identify particular formats.
bool is4444 = !(is456 || is465);
NSMutableString *stringWithAddedSpaces = [NSMutableString new];
NSUInteger cursorPositionInSpacelessString = *cursorPosition;
for (NSUInteger i=0; i<[string length]; i++) {
bool needs465Spacing = (is465 && (i == 4 || i == 10 || i == 15));
bool needs456Spacing = (is456 && (i == 4 || i == 9 || i == 15));
bool needs4444Spacing = (is4444 && i > 0 && (i % 4) == 0);
if (needs465Spacing || needs456Spacing || needs4444Spacing) {
[stringWithAddedSpaces appendString:@" "];
if (i < cursorPositionInSpacelessString) {
(*cursorPosition)++;
}
}
unichar characterToAdd = [string characterAtIndex:i];
NSString *stringToAdd =
[NSString stringWithCharacters:&characterToAdd length:1];
[stringWithAddedSpaces appendString:stringToAdd];
}
return stringWithAddedSpaces;
}

Ensuite, définissez reformatCardNumber: être appelé à chaque fois que le champ de texte déclenche un UIControlEventEditingChanged événement:

[yourTextField addTarget:yourTextFieldDelegate 
action:@selector(reformatAsCardNumber:)
forControlEvents:UIControlEventEditingChanged];

(Bien sûr, vous aurez besoin de faire cela à un certain moment après votre champ de texte et de son délégué ont été instanciés. Si vous utilisez des storyboards, la viewDidLoad méthode de votre vue-contrôleur est un endroit approprié.

Quelques Explications

C'est un air faussement compliquée problème. Trois questions importantes qui peuvent ne pas être immédiatement évident (et dont les réponses précédentes ici tous ne parviennent pas à prendre en compte):

1. Tandis que le XXXX XXXX XXXX XXXX format de débit et de crédit, des numéros de carte est le plus commun, il n'est pas le seul. Par exemple, des cartes American Express 15 chiffres généralement écrits en XXXX XXXXXX XXXXX format, comme ceci:

   

   Même les cartes Visa peuvent avoir moins de 16 chiffres, et les cartes Maestro pouvez avoir plus de:

   

2. Il y a plus de moyens pour l'utilisateur d'interagir avec un champ de texte que de simplement taper dans de simples caractères à la fin de leur saisie. Vous devez également gérer correctement l'utilisateur d'ajouter des caractères dans le milieu de la chaîne, la suppression de les caractères unique, la suppression de plusieurs caractères sélectionnés, et coller dans de multiples personnages. Certains plus simple/plus naïf des approches à ce problème ne pourront pas gérer certains de ces interactions correctement. Le plus pervers de cas est un utilisateur de coller plusieurs personnages dans le milieu de la chaîne à remplacer les autres personnages, et cette solution est assez générale pour gérer cela.

3. Vous n'avez pas seulement besoin de reformater le texte du champ de texte correctement une fois que l'utilisateur modifie - vous aussi besoin de la position de la curseur de texte raisonnablement. Naïf approches du problème qui ne prennent pas en compte sera presque certainement finir par faire quelque chose de stupide avec le curseur de texte dans certains cas (comme à la fin du champ de texte lorsque l'utilisateur ajoute un chiffre dans le milieu de celui-ci).

Pour traiter de la question #1, nous utilisons la partielle de cartographie de numéro de carte de préfixes de formats, organisée par L'Baymard Institut à https://baymard.com/checkout-usability/credit-card-patterns. Nous pouvons détecter automatiquement la le fournisseur de la carte à partir du premier couple de chiffres (dans certains cas) en déduire le format et ajuster la mise en forme en conséquence. Grâce à cnotethegr8 pour contribuer à cette idée pour cette réponse.

La plus simple et la meilleure façon de traiter de la question #2 (et la manière utilisée dans le code ci-dessus) est de supprimer tous les espaces et réinsérez-les dans la position correcte à chaque fois que le contenu du champ de texte changements, en épargnant nous le besoin de comprendre à quel type de manipulation de texte (une insertion, de suppression ou de remplacement) est en cours et gérer les possibilités différemment.

Pour traiter de la question #3, nous garder une trace de la façon dont l'indice désiré du curseur change comme nous dépouiller non chiffres, puis insérer des espaces. C'est pourquoi le code plutôt avec beaucoup de détails effectue ces manipulations, caractère par caractère à l'aide de NSMutableString, plutôt que d'utiliser NSString's de la chaîne de méthodes de remplacement.

Enfin, il y a un piège, tapie: le retour de NO de textField: shouldChangeCharactersInRange: replacementString sauts de la "coupure" sur le bouton, l'utilisateur obtient quand ils sélectionner du texte dans le champ de texte, c'est pourquoi je ne le fais pas. De retour NO à partir de cette méthode aboutit à "Couper" tout simplement pas la mise à jour du presse-papiers à tous, et je ne connais aucun correctif ou une solution de contournement. En conséquence, nous avons besoin de faire le reformatage du champ de texte dans un UIControlEventEditingChanged gestionnaire au lieu de (évidemment) dans shouldChangeCharactersInRange: lui-même.

Heureusement, la UIControl gestionnaires d'événements semblent avoir appelé avant de l'INTERFACE utilisateur les mises à jour se rincé à l'écran, de sorte que cette approche fonctionne très bien.

Il y a aussi tout un tas de mineur questions sur exactement comment le champ de texte doit se comporter qui n'ont pas évident de corriger les réponses:

• Si l'utilisateur essaie de coller à quelque chose qui serait en cause le contenu du champ de texte pour dépasser les 19 chiffres, si le début de l'collé chaîne inséré (jusqu'à 19 chiffres sont atteints) et le reste recadrée, ou doit rien être inséré?
• Si l'utilisateur tente de supprimer un espace unique en positionnant le curseur et en appuyant sur la touche de retour arrière, devrait rien se produire, et le curseur de rester où il est, doit déplacer le curseur à gauche d'un caractère (le placer avant l'espace), ou si le chiffre à gauche de l'espace de discussion soient supprimées comme si le curseur était déjà parti de l'espace?
• Lorsque l'utilisateur tape dans la quatrième, huitième, ou douzième chiffres, si une place immédiatement être inséré et que le curseur est déplacé après, ou si la place ne soient insérés après les types d'utilisateurs de la cinquième, neuvième, ou treizième chiffres?
• Lorsque l'utilisateur supprime le premier chiffre après un espace, si cela ne cause pas de l'espace pour être entièrement supprimés, cela doit-il conduire à leur curseur étant placé avant ou après l'espace?

Probablement la réponse à une de ces questions sera suffisant, mais je liste juste pour préciser qu'il y a effectivement beaucoup de cas particuliers que vous pourriez vouloir penser soigneusement le sujet ici, si vous étiez assez obsessionnel. Dans le code ci-dessus, j'ai ramassé des réponses à ces questions qui semblait raisonnable pour moi. Si vous avez des sentiments forts au sujet de l'un de ces points qui ne sont pas compatible avec la façon dont mon code se comporte, il devrait être assez facile de l'ajuster à vos besoins.

Ci-dessous est un travail Swift 4 port de Logicopolis réponse (qui est à son tour une Swift 2 port d'une ancienne version de mon accepté de répondre à en Objective-C) le renforcement de la avec cnotethegr8
s'astuce pour soutenir les cartes Amex et puis encore amélioré pour prendre en charge plusieurs formats de carte. Je suggère à la recherche sur les accepté de répondre si vous ne l'avez pas déjà, car il permet d'expliquer la motivation à l'origine de beaucoup de ce code.

Remarque que le minimum d'une série d'étapes nécessaires pour le voir en action est:

1. Créer un nouveau Vue Unique Application en Swift.
2. Sur Main.storyboard, ajouter un Champ de Texte.
3. Faire la ViewController le délégué de la Champ de Texte.
4. Coller le code ci-dessous dans ViewController.swift.
5. Connecter le IBOutlet à la Champ de Texte.
6. D'exécuter votre application et le type dans le Champ de Texte.

---

import UIKit
class ViewController: UIViewController, UITextFieldDelegate {
private var previousTextFieldContent: String?
private var previousSelection: UITextRange?
@IBOutlet var yourTextField: UITextField!;
override func viewDidLoad() {
super.viewDidLoad()
//Do any additional setup after loading the view, typically from a nib
yourTextField.addTarget(self, action: #selector(reformatAsCardNumber), for: .editingChanged)
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
//Dispose of any resources that can be recreated.
}
func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
previousTextFieldContent = textField.text;
previousSelection = textField.selectedTextRange;
return true
}
@objc func reformatAsCardNumber(textField: UITextField) {
var targetCursorPosition = 0
if let startPosition = textField.selectedTextRange?.start {
targetCursorPosition = textField.offset(from: textField.beginningOfDocument, to: startPosition)
}
var cardNumberWithoutSpaces = ""
if let text = textField.text {
cardNumberWithoutSpaces = self.removeNonDigits(string: text, andPreserveCursorPosition: &targetCursorPosition)
}
if cardNumberWithoutSpaces.count > 19 {
textField.text = previousTextFieldContent
textField.selectedTextRange = previousSelection
return
}
let cardNumberWithSpaces = self.insertCreditCardSpaces(cardNumberWithoutSpaces, preserveCursorPosition: &targetCursorPosition)
textField.text = cardNumberWithSpaces
if let targetPosition = textField.position(from: textField.beginningOfDocument, offset: targetCursorPosition) {
textField.selectedTextRange = textField.textRange(from: targetPosition, to: targetPosition)
}
}
func removeNonDigits(string: String, andPreserveCursorPosition cursorPosition: inout Int) -> String {
var digitsOnlyString = ""
let originalCursorPosition = cursorPosition
for i in Swift.stride(from: 0, to: string.count, by: 1) {
let characterToAdd = string[string.index(string.startIndex, offsetBy: i)]
if characterToAdd >= "0" && characterToAdd <= "9" {
digitsOnlyString.append(characterToAdd)
}
else if i < originalCursorPosition {
cursorPosition -= 1
}
}
return digitsOnlyString
}
func insertCreditCardSpaces(_ string: String, preserveCursorPosition cursorPosition: inout Int) -> String {
//Mapping of card prefix to pattern is taken from
//https://baymard.com/checkout-usability/credit-card-patterns
//UATP cards have 4-5-6 (XXXX-XXXXX-XXXXXX) format
let is456 = string.hasPrefix("1")
//These prefixes reliably indicate either a 4-6-5 or 4-6-4 card. We treat all these
//as 4-6-5-4 to err on the side of always letting the user type more digits.
let is465 = [
//Amex
"34", "37",
//Diners Club
"300", "301", "302", "303", "304", "305", "309", "36", "38", "39"
].contains { string.hasPrefix($0) }
//In all other cases, assume 4-4-4-4-3.
//This won't always be correct; for instance, Maestro has 4-4-5 cards according
//to https://baymard.com/checkout-usability/credit-card-patterns, but I don't
//know what prefixes identify particular formats.
let is4444 = !(is456 || is465)
var stringWithAddedSpaces = ""
let cursorPositionInSpacelessString = cursorPosition
for i in 0..<string.count {
let needs465Spacing = (is465 && (i == 4 || i == 10 || i == 15))
let needs456Spacing = (is456 && (i == 4 || i == 9 || i == 15))
let needs4444Spacing = (is4444 && i > 0 && (i % 4) == 0)
if needs465Spacing || needs456Spacing || needs4444Spacing {
stringWithAddedSpaces.append(" ")
if i < cursorPositionInSpacelessString {
cursorPosition += 1
}
}
let characterToAdd = string[string.index(string.startIndex, offsetBy:i)]
stringWithAddedSpaces.append(characterToAdd)
}
return stringWithAddedSpaces
}
}

S'adapter à d'autres situations comme la votre délégué n'étant pas un ViewController - est laissé comme exercice pour le lecteur.

Swift 3 solution à l'aide de Fawkes réponse de base.
Ajout de la Carte Amex en charge du format.
Ajouté réforme lorsque le type de la carte a changé.

D'abord faire une nouvelle classe avec ce code:

extension String {
func containsOnlyDigits() -> Bool
{
let notDigits = NSCharacterSet.decimalDigits.inverted
if rangeOfCharacter(from: notDigits, options: String.CompareOptions.literal, range: nil) == nil
{
return true
}
return false
}
}
import UIKit
var creditCardFormatter : CreditCardFormatter
{
return CreditCardFormatter.sharedInstance
}
class CreditCardFormatter : NSObject
{
static let sharedInstance : CreditCardFormatter = CreditCardFormatter()
func formatToCreditCardNumber(isAmex: Bool, textField : UITextField, withPreviousTextContent previousTextContent : String?, andPreviousCursorPosition previousCursorSelection : UITextRange?) {
var selectedRangeStart = textField.endOfDocument
if textField.selectedTextRange?.start != nil {
selectedRangeStart = (textField.selectedTextRange?.start)!
}
if  let textFieldText = textField.text
{
var targetCursorPosition : UInt = UInt(textField.offset(from:textField.beginningOfDocument, to: selectedRangeStart))
let cardNumberWithoutSpaces : String = removeNonDigitsFromString(string: textFieldText, andPreserveCursorPosition: &targetCursorPosition)
if cardNumberWithoutSpaces.characters.count > 19
{
textField.text = previousTextContent
textField.selectedTextRange = previousCursorSelection
return
}
var cardNumberWithSpaces = ""
if isAmex {
cardNumberWithSpaces = insertSpacesInAmexFormat(string: cardNumberWithoutSpaces, andPreserveCursorPosition: &targetCursorPosition)
}
else
{
cardNumberWithSpaces = insertSpacesIntoEvery4DigitsIntoString(string: cardNumberWithoutSpaces, andPreserveCursorPosition: &targetCursorPosition)
}
textField.text = cardNumberWithSpaces
if let finalCursorPosition = textField.position(from:textField.beginningOfDocument, offset: Int(targetCursorPosition))
{
textField.selectedTextRange = textField.textRange(from: finalCursorPosition, to: finalCursorPosition)
}
}
}
func removeNonDigitsFromString(string : String, andPreserveCursorPosition cursorPosition : inout UInt) -> String {
var digitsOnlyString : String = ""
for index in stride(from: 0, to: string.characters.count, by: 1)
{
let charToAdd : Character = Array(string.characters)[index]
if isDigit(character: charToAdd)
{
digitsOnlyString.append(charToAdd)
}
else
{
if index < Int(cursorPosition)
{
cursorPosition -= 1
}
}
}
return digitsOnlyString
}
private func isDigit(character : Character) -> Bool
{
return "\(character)".containsOnlyDigits()
}
func insertSpacesInAmexFormat(string : String, andPreserveCursorPosition cursorPosition : inout UInt) -> String {
var stringWithAddedSpaces : String = ""
for index in stride(from: 0, to: string.characters.count, by: 1)
{
if index == 4
{
stringWithAddedSpaces += " "
if index < Int(cursorPosition)
{
cursorPosition += 1
}
}
if index == 10 {
stringWithAddedSpaces += " "
if index < Int(cursorPosition)
{
cursorPosition += 1
}
}
if index < 15 {
let characterToAdd : Character = Array(string.characters)[index]
stringWithAddedSpaces.append(characterToAdd)
}
}
return stringWithAddedSpaces
}
func insertSpacesIntoEvery4DigitsIntoString(string : String, andPreserveCursorPosition cursorPosition : inout UInt) -> String {
var stringWithAddedSpaces : String = ""
for index in stride(from: 0, to: string.characters.count, by: 1)
{
if index != 0 && index % 4 == 0 && index < 16
{
stringWithAddedSpaces += " "
if index < Int(cursorPosition)
{
cursorPosition += 1
}
}
if index < 16 {
let characterToAdd : Character = Array(string.characters)[index]
stringWithAddedSpaces.append(characterToAdd)
}
}
return stringWithAddedSpaces
}
}

Dans votre ViewControllerClass ajouter cette fonction

func reformatAsCardNumber(textField:UITextField){
let formatter = CreditCardFormatter()
var isAmex = false
if selectedCardType == "AMEX" {
isAmex = true
}
formatter.formatToCreditCardNumber(isAmex: isAmex, textField: textField, withPreviousTextContent: textField.text, andPreviousCursorPosition: textField.selectedTextRange)
}

Puis ajoutez la cible à votre textField

youtTextField.addTarget(self, action: #selector(self.reformatAsCardNumber(textField:)), for: UIControlEvents.editingChanged)

Enregistrer une nouvelle variable et envoyé type de carte à

var selectedCardType: String? {
didSet{
reformatAsCardNumber(textField: yourTextField)
}
}

Grâce Fawkes pour son code!

Encore une autre version de la accepté de répondre à Swift 2...

Vous assurer que vous avez dans votre instance de délégué:

private var previousTextFieldContent: String?
private var previousSelection: UITextRange?

Et également veiller à ce que votre zone de texte appelle reformatAsCardNumber:

textField.addTarget(self, action: #selector(reformatAsCardNumber(_:)), forControlEvents: .EditingChanged)

Vous champ de texte délégué aurez besoin pour ce faire:

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
previousTextFieldContent = textField.text;
previousSelection = textField.selectedTextRange;
return true
}

Enfin inclure des méthodes suivantes:

func reformatAsCardNumber(textField: UITextField) {
var targetCursorPosition = 0
if let startPosition = textField.selectedTextRange?.start {
targetCursorPosition = textField.offsetFromPosition(textField.beginningOfDocument, toPosition: startPosition)
}
var cardNumberWithoutSpaces = ""
if let text = textField.text {
cardNumberWithoutSpaces = self.removeNonDigits(text, andPreserveCursorPosition: &targetCursorPosition)
}
if cardNumberWithoutSpaces.characters.count > 19 {
textField.text = previousTextFieldContent
textField.selectedTextRange = previousSelection
return
}
let cardNumberWithSpaces = self.insertSpacesEveryFourDigitsIntoString(cardNumberWithoutSpaces, andPreserveCursorPosition: &targetCursorPosition)
textField.text = cardNumberWithSpaces
if let targetPosition = textField.positionFromPosition(textField.beginningOfDocument, offset: targetCursorPosition) {
textField.selectedTextRange = textField.textRangeFromPosition(targetPosition, toPosition: targetPosition)
}
}
func removeNonDigits(string: String, inout andPreserveCursorPosition cursorPosition: Int) -> String {
var digitsOnlyString = ""
let originalCursorPosition = cursorPosition
for i in 0.stride(to: string.characters.count, by: 1) {
let characterToAdd = string[string.startIndex.advancedBy(i)]
if characterToAdd >= "0" && characterToAdd <= "9" {
digitsOnlyString.append(characterToAdd)
}
else if i < originalCursorPosition {
cursorPosition -= 1
}
}
return digitsOnlyString
}
func insertSpacesEveryFourDigitsIntoString(string: String, inout andPreserveCursorPosition cursorPosition: Int) -> String {
var stringWithAddedSpaces = ""
let cursorPositionInSpacelessString = cursorPosition
for i in 0.stride(to: string.characters.count, by: 1) {
if i > 0 && (i % 4) == 0 {
stringWithAddedSpaces.appendContentsOf(" ")
if i < cursorPositionInSpacelessString {
cursorPosition += 1
}
}
let characterToAdd = string[string.startIndex.advancedBy(i)]
stringWithAddedSpaces.append(characterToAdd)
}
return stringWithAddedSpaces
}

Définir la méthode ci-dessous & appel dans UITextfield délégués ou chaque fois que nécessaire

-(NSString*)processString :(NSString*)yourString
{
if(yourString == nil){
return @"";
}
int stringLength = (int)[yourString length];
int len = 4;  //Length after which you need to place added character
NSMutableString *str = [NSMutableString string];
int i = 0;
for (; i < stringLength; i+=len) {
NSRange range = NSMakeRange(i, len);
[str appendString:[yourString substringWithRange:range]];
if(i!=stringLength -4){
[str appendString:@" "]; //If required string format is XXXX-XXXX-XXXX-XXX then just replace [str appendString:@"-"]
}
}
if (i < [str length]-1) {  //add remaining part
[str appendString:[yourString substringFromIndex:i]];
}
//Returning required string
return str;
}

Donc je voulais ce avec moins de code, j'ai donc utilisé le code ici et redéfini un peu. J'ai eu deux champs de l'écran, un pour le nombre et l'autre pour la date d'expiration, alors j'en ai fait plus réutilisable.

Swift 3 autre réponse

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
guard let currentText = (textField.text as NSString?)?.replacingCharacters(in: range, with: string) else { return true }
if textField == cardNumberTextField {
textField.text = currentText.grouping(every: 4, with: " ")
return false
}
else { //Expiry Date Text Field
textField.text = currentText.grouping(every: 2, with: "/")
return false
}
}
extension String {
func grouping(every groupSize: String.IndexDistance, with separator: Character) -> String {
let cleanedUpCopy = replacingOccurrences(of: String(separator), with: "")
return String(cleanedUpCopy.characters.enumerated().map() {
$0.offset % groupSize == 0 ? [separator, $0.element] : [$0.element]
}.joined().dropFirst())
}
}

Swift 3 solution basée sur Marque Amery de l'Objective-C solution:

1. Mettre en œuvre l'action et délégué méthodes:

   textField.addTarget(self, action: #selector(reformatAsCardNumber(_:))
   textField.delegate = self

2. TextField Délégué de méthodes et d'autres méthodes:

   func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
   previousTextFieldContent = textField.text;
   previousSelection = textField.selectedTextRange;
   return true
   }
   func reformatAsCardNumber(_ textField: UITextField) {
   var targetCursorPosition = 0
   if let startPosition = textField.selectedTextRange?.start {
   targetCursorPosition = textField.offset(from:textField.beginningOfDocument, to: startPosition)
   }
   var cardNumberWithoutSpaces = ""
   if let text = textField.text {
   cardNumberWithoutSpaces = removeNonDigits(string: text, andPreserveCursorPosition: &targetCursorPosition)
   }
   if cardNumberWithoutSpaces.characters.count > 19 {
   textField.text = previousTextFieldContent
   textField.selectedTextRange = previousSelection
   return
   }
   let cardNumberWithSpaces = self.insertSpacesEveryFourDigitsIntoString(string: cardNumberWithoutSpaces, andPreserveCursorPosition: &targetCursorPosition)
   textField.text = cardNumberWithSpaces
   if let targetPosition = textField.position(from: textField.beginningOfDocument, offset: targetCursorPosition) {
   textField.selectedTextRange = textField.textRange(from: targetPosition, to: targetPosition)
   }
   }
   func removeNonDigits(string: String, andPreserveCursorPosition cursorPosition: inout Int) -> String {
   var digitsOnlyString = ""
   let originalCursorPosition = cursorPosition
   for i in stride(from: 0, to: string.characters.count, by: 1) {
   let characterToAdd =  string[string.index(string.startIndex, offsetBy: i)]
   if characterToAdd >= "0" && characterToAdd <= "9" {
   digitsOnlyString.append(characterToAdd)
   }
   else if i < originalCursorPosition {
   cursorPosition -= 1
   }
   }
   return digitsOnlyString
   }
   func insertSpacesEveryFourDigitsIntoString(string: String, andPreserveCursorPosition cursorPosition: inout Int) -> String {
   var stringWithAddedSpaces = ""
   let cursorPositionInSpacelessString = cursorPosition
   for i in stride(from: 0, to: string.characters.count, by: 1) {
   if i > 0 && (i % 4) == 0 {
   stringWithAddedSpaces.append(" ")
   if i < cursorPositionInSpacelessString {
   cursorPosition += 1
   }
   }
   let characterToAdd = string[string.index(string.startIndex, offsetBy: i)]
   stringWithAddedSpaces.append(characterToAdd)
   }
   return stringWithAddedSpaces
   }

Ici est un Kotlin réponse en dehors de la Marque de Amery

fun formatCardNumber(cardNumber: String): String {
var trimmedCardNumber = cardNumber.replace(" ","")
//UATP cards have 4-5-6 (XXXX-XXXXX-XXXXXX) format
val is456 = trimmedCardNumber.startsWith("1")
//These prefixes reliably indicate either a 4-6-5 or 4-6-4 card. We treat all these
//as 4-6-5-4 to err on the side of always letting the user type more digits.
val is465 = listOf("34", "37", "300", "301", "302", "303", "304", "305", "309", "36", "38", "39")
.any { trimmedCardNumber.startsWith(it) }
//In all other cases, assume 4-4-4-4.
val is4444 = !(is456 || is465)
trimmedCardNumber = if (is456 || is465) {
trimmedCardNumber.take(cardNumberMaxLengthAmex)
} else {
trimmedCardNumber.take(cardNumberMaxLength)
}
var cardNumberWithAddedSpaces = ""
trimmedCardNumber.forEachIndexed { index, c ->
val needs465Spacing = is465 && (index == 4 || index == 10 || index == 15)
val needs456Spacing = is456 && (index == 4 || index == 9 || index == 15)
val needs4444Spacing = is4444 && index > 0 && index % 4 == 0
if (needs465Spacing || needs456Spacing || needs4444Spacing) {
cardNumberWithAddedSpaces += " "
}
cardNumberWithAddedSpaces += c
}
return cardNumberWithAddedSpaces
}

Puis ajouter un texte changer le port d'écoute sur une modification de texte

var flag = false
editText.addTextChangedListener(object : TextWatcher {
override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
if (flag) { 
flag = false 
} else {
val text = formatCardNumber(s.toString())
flag = true
editText.setText(text)
editText.setSelection(text.count())
}
}
override fun afterTextChanged(s: Editable?) {}
})

Veuillez utiliser formulaire simple de credite de la carte
/**
Voir exemple d'utilisation:
### let str = "41111111111111111"

 let x = yourClassname.setStringAsCardNumberWithSartNumber(4, withString: str!, withStrLenght: 8)
### output:- 4111XXXXXXXX1111
let x = yourClassname.setStringAsCardNumberWithSartNumber(0, withString: str!, withStrLenght: 12)
### output: - XXXXXXXXXXXX1111
*/
func setStringAsCardNumberWithSartNumber(Number:Int,withString str:String ,withStrLenght len:Int ) -> String{
//let aString: String = "41111111111111111"
let arr = str.characters
var CrediteCard : String = ""
if arr.count > (Number + len) {
for (index, element ) in arr.enumerate(){
if index >= Number && index < (Number + len) {
CrediteCard = CrediteCard + String("X")
}else{
CrediteCard = CrediteCard + String(element)
}
}
return CrediteCard
}else{
print("\(Number) plus \(len) are grether than strings chatarter \(arr.count)")
}
print("\(CrediteCard)")
return str
}

J'espère que cela est utile pour vous.

Trouve un RÉSUMÉ dans Github qui fait exactement ce dont j'ai besoin dans Swift3 (https://gist.github.com/nunogoncalves/6a8b4b21f4f69e0fc050190df96a1e56)

Mis en œuvre par la pratique ->

if creditCardNumberTextView.text?.characters.first == "3" {
let validator = Validator(cardType: .americanExpress, value:  self.creditCardNumberTextView.text!).test()
if validator == true {
} else {
}
}

Fonctionne à merveille dans l'APPLICATION que je suis en train de travailler qui utilise des cartes de crédit.

ici est la modification de la réponse de @sleeping_giant pour swift. Cette solution met en forme le texte dans "xxxx-xxxx-xxxx-xxxx-xxxx" format et cesse d'accepter tous les numéros au-delà de cette plage.

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool
{
if string == ""{
return true
}
//range.length will be greater than 0 if user is deleting text - allow it to replace
if range.length > 0
{
return true
}
//Don't allow empty strings
if string == "-"
{
return false
}
//Check for max length including the spacers we added
print(range.location)
if range.location > 23
{
return false
}
var originalText = textField.text
let replacementText = string.replacingOccurrences(of: "-", with: "")
//Verify entered text is a numeric value
let digits = NSCharacterSet.decimalDigits
for char in replacementText.unicodeScalars
{
if !(digits as NSCharacterSet).longCharacterIsMember(char.value)
{
return false
}
}
//Put an empty space after every 4 places
if (originalText?.characters.count)! > 0
{
if (originalText?.characters.count)! < 5 && (originalText?.characters.count)! % 4 == 0{
originalText?.append("-")
}else if(((originalText?.characters.count)! + 1) % 5 == 0){
originalText?.append("-")
}
}
textField.text = originalText
return true
}