ios - fields - Establecer la longitud máxima de caracteres de un UITextField

text field ios 11

Question

¿Cómo puedo configurar la cantidad máxima de caracteres en un UITextField en el iPhone SDK cuando carga una UIView ?

Answer 1

Swift 4

import UIKit

private var kAssociationKeyMaxLength: Int = 0

extension UITextField {

    @IBInspectable var maxLength: Int {
        get {
            if let length = objc_getAssociatedObject(self, &kAssociationKeyMaxLength) as? Int {
                return length
            } else {
                return Int.max
            }
        }
        set {
            objc_setAssociatedObject(self, &kAssociationKeyMaxLength, newValue, .OBJC_ASSOCIATION_RETAIN)
            addTarget(self, action: #selector(checkMaxLength), for: .editingChanged)
        }
    }

    @objc func checkMaxLength(textField: UITextField) {
        guard let prospectiveText = self.text,
            prospectiveText.count > maxLength
            else {
                return
        }

        let selection = selectedTextRange

        let indexEndOfText = prospectiveText.index(prospectiveText.startIndex, offsetBy: maxLength)
        let substring = prospectiveText[..<indexEndOfText]
        text = String(substring)

        selectedTextRange = selection
    }
}

Edición: problema de pérdida de memoria solucionado.

Answer 2

swift 3.0

Este código funciona bien cuando pegas una cadena más que tus límites de caracteres.

func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
        let str = (textView.text + text)
        if str.characters.count <= 10 {
            return true
        }
        textView.text = str.substring(to: str.index(str.startIndex, offsetBy: 10))
        return false
    }

Gracias por tus votos. :)

Answer 3

¡Gracias agosto! ( Post )

Este es el código con el que terminé y que funciona:

#define MAX_LENGTH 20

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string
{
    if (textField.text.length >= MAX_LENGTH && range.length == 0)
    {
        return NO; // return NO to not change text
    }
    else
    {return YES;}
}

Answer 4

A menudo tienes múltiples campos de entrada con una longitud diferente.

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {
    int allowedLength;
    switch(textField.tag) {
        case 1: 
            allowedLength = MAXLENGTHNAME;      // triggered for input fields with tag = 1
            break;
        case 2:
            allowedLength = MAXLENGTHADDRESS;   // triggered for input fields with tag = 2
            break;
        default:
            allowedLength = MAXLENGTHDEFAULT;   // length default when no tag (=0) value =255
            break;
    }

    if (textField.text.length >= allowedLength && range.length == 0) {
        return NO; // Change not allowed
    } else {
        return YES; // Change allowed
    }
}

Answer 5

Doy una respuesta complementaria basada en @Frouo. Creo que su respuesta es la más hermosa. Porque es un control común que podemos reutilizar.

private var kAssociationKeyMaxLength: Int = 0

extension UITextField {

    @IBInspectable var maxLength: Int {
        get {
            if let length = objc_getAssociatedObject(self, &kAssociationKeyMaxLength) as? Int {
                return length
            } else {
                return Int.max
            }
        }
        set {
            objc_setAssociatedObject(self, &kAssociationKeyMaxLength, newValue, .OBJC_ASSOCIATION_RETAIN)
            self.addTarget(self, action: #selector(checkMaxLength), for: .editingChanged)
        }
    }

    func checkMaxLength(textField: UITextField) {

        guard !self.isInputMethod(), let prospectiveText = self.text,
            prospectiveText.count > maxLength
            else {
                return
        }

        let selection = selectedTextRange
        let maxCharIndex = prospectiveText.index(prospectiveText.startIndex, offsetBy: maxLength)
        text = prospectiveText.substring(to: maxCharIndex)
        selectedTextRange = selection
    }

    //The method is used to cancel the check when use Chinese Pinyin input method.
    //Becuase the alphabet also appears in the textfield when inputting, we should cancel the check.
    func isInputMethod() -> Bool {
        if let positionRange = self.markedTextRange {
            if let _ = self.position(from: positionRange.start, offset: 0) {
                return true
            }
        }
        return false
    }

}

Answer 6

El problema con algunas de las respuestas dadas anteriormente es: Por ejemplo, tengo un campo de texto y tengo que establecer un límite de entrada de 15 caracteres, luego se detiene después de ingresar el 15º carácter. pero no permiten eliminar. Ese es el botón de borrar que tampoco funciona. Como me enfrentaba al mismo problema. Salió con la solución, A continuación. Funciona perfecto para mi

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string
{
 if(textField.tag==6)
 {
    if ([textField.text length]<=30)
    {
        return YES;   
    }
    else if([@"" isEqualToString:string])
    {
        textField.text=[textField.text substringToIndex:30 ];
    }

    return NO;
 }
 else
 {
    return YES;
 }
}

Tengo un campo de texto, cuya etiqueta he establecido "6" y he restringido el límite máximo de caracteres = 30; funciona bien en todos los casos

Answer 7

El siguiente código es similar a la respuesta de sickp pero maneja correctamente las operaciones de copiar y pegar. Si intenta pegar un texto que es más largo que el límite, el siguiente código truncará el texto para ajustarlo al límite en lugar de rechazar completamente la operación de pegado.

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {
    static const NSUInteger limit = 70; // we limit to 70 characters
    NSUInteger allowedLength = limit - [textField.text length] + range.length;
    if (string.length > allowedLength) {
        if (string.length > 1) {
            // get at least the part of the new string that fits
            NSString *limitedString = [string substringToIndex:allowedLength];
            NSMutableString *newString = [textField.text mutableCopy];
            [newString replaceCharactersInRange:range withString:limitedString];
            textField.text = newString;
        }
        return NO;
    } else {
        return YES;
    }
}

Answer 8

Esta es la forma correcta de manejar la longitud máxima en UITextField, permite que la tecla de retorno salga del campo de texto como primer respondedor y permite que el usuario retroceda cuando llega al límite

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {
int MAX_LENGHT = 5;
    if([string isEqualToString:@"/n"])
    {
        [textField resignFirstResponder];
        return FALSE;
    }
    else if(textField.text.length > MAX_LENGHT-1)
    {
        if([string isEqualToString:@""] && range.length == 1)
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
    else
    {
        return TRUE;
    }
}

Answer 9

Esto debería ser suficiente para resolver el problema (reemplaza 4 por el límite que quieres). Sólo asegúrese de agregar delegado en IB.

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string
{
     NSString *newString = [textField.text stringByReplacingCharactersInRange:range withString:string];
     return (newString.length<=4);
}

Answer 10

Hay una solución genérica para establecer la longitud máxima en Swift. Por IBInspectable puede agregar un nuevo atributo en Xcode Attribute Inspector.

import UIKit
private var maxLengths = [UITextField: Int]()
extension UITextField {

    @IBInspectable var maxLength: Int {
        get {
            guard let length = maxLengths[self]
            else {
                return Int.max
            }
            return length
        }
        set {
            maxLengths[self] = newValue
            addTarget(
                self,
                action: Selector("limitLength:"),
                forControlEvents: UIControlEvents.EditingChanged
            )
        }
    }

    func limitLength(textField: UITextField) {
        guard let prospectiveText = textField.text
            where prospectiveText.characters.count > maxLength else {
                return
        }
        let selection = selectedTextRange
        text = prospectiveText.substringWithRange(
            Range<String.Index>(prospectiveText.startIndex ..< prospectiveText.startIndex.advancedBy(maxLength))
        )
        selectedTextRange = selection
    }

}

Answer 11

He abierto una subclase de UITextField, STATextField , que ofrece esta funcionalidad (y mucho más) con su propiedad maxCharacterLength .

Answer 12

He creado this subclase UITextFieldLimit:

• Varios campos de texto soportados
• Establecer el límite de longitud de texto
• Prevención de la pasta
• Muestra una etiqueta de caracteres izquierdos dentro del campo de texto, se oculta cuando detiene la edición.
• Sacuda la animación cuando no queden caracteres.

UITextFieldLimit.h el UITextFieldLimit.h y UITextFieldLimit.m desde este repositorio de GitHub:

this

y empieza a probar!

Marque su UITextField creado por el guión gráfico y vincúlelo a mi subclase utilizando el Inspector de identidad:

Luego puede vincularlo a un IBOutlet y establecer el límite (el valor predeterminado es 10).

Su archivo ViewController.h debe contener: (si no desea modificar la configuración, como el límite)

#import "UITextFieldLimit.h"

/.../

@property (weak, nonatomic) IBOutlet UITextFieldLimit *textFieldLimit; // <--Your IBOutlet

Su archivo ViewController.m debe @synthesize textFieldLimit .

Establezca el límite de longitud de texto en su archivo ViewController.m:

- (void)viewDidLoad
{
    [super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.

    [textFieldLimit setLimit:25];// <-- and you won''t be able to put more than 25 characters in the TextField.
}

Espero que la clase te ayude. ¡Buena suerte!

Answer 13

He implementado una extensión UITextField para agregarle una propiedad maxLength.

Está basado en Xcode 6 IBInspectables, por lo que puede establecer el límite de maxLength en el generador de interfaces.

Aquí está la implementación:

UITextField + MaxLength.h

#import <UIKit/UIKit.h>

@interface UITextField_MaxLength : UITextField<UITextFieldDelegate>

@property (nonatomic)IBInspectable int textMaxLength;
@end

UITextField + MaxLength.m

#import "UITextField+MaxLength.h"

@interface UITextField_MaxLength()

@property (nonatomic, assign) id <UITextFieldDelegate> superDelegate;

@end

@implementation UITextField_MaxLength

- (BOOL)textField:(UITextField *) textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {

    //validate the length, only if it''s set to a non zero value
    if (self.textMaxLength>0) {
        if(range.length + range.location > textField.text.length)
            return NO;

        if (textField.text.length+string.length - range.length>self.textMaxLength) {
            return NO;
        }
    }

    //if length validation was passed, query the super class to see if the delegate method is implemented there
    if (self.superDelegate && [self.superDelegate respondsToSelector:@selector(textField:shouldChangeCharactersInRange:replacementString:)]) {
        return [self.superDelegate textField:textField shouldChangeCharactersInRange:range replacementString:string];
    }
    else{
        //if the super class does not implement the delegate method, simply return YES as the length validation was passed
        return YES;
    }
}

- (void)setDelegate:(id<UITextFieldDelegate>)delegate {
    if (delegate == self)
        return;
    self.superDelegate = delegate;
    [super setDelegate:self];
}

//forward all non overriden delegate methods
- (id)forwardingTargetForSelector:(SEL)aSelector {
    if ([self.superDelegate  respondsToSelector:aSelector])
        return self.superDelegate;

    return [super forwardingTargetForSelector:aSelector];
}

- (BOOL)respondsToSelector:(SEL)aSelector {
    if ([self.superDelegate respondsToSelector:aSelector])
        return YES;

    return [super respondsToSelector:aSelector];
}
@end

Answer 14

Hice esto en Swift para un límite de 8 caracteres al usar un teclado numérico.

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    return !(textField.text?.characters.count == MAX_LENGTH && string != "")
}

Tuve que probar la cadena! = "" Para permitir que el botón de eliminación funcione en el teclado numérico, de lo contrario no permitiría eliminar caracteres en el campo de texto después de que alcanzara su máximo.

Answer 15

La mejor manera sería configurar una notificación sobre el cambio de texto. En su -awakeFromNib de su método de controlador de vista querrá:

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(limitTextField:) name:@"UITextFieldTextDidChangeNotification" object:myTextField];

Luego en la misma clase agregue:

- (void)limitTextField:(NSNotification *)note {
    int limit = 20;
    if ([[myTextField stringValue] length] > limit) {
        [myTextField setStringValue:[[myTextField stringValue] substringToIndex:limit]];
    }
}

Luego, myTextField el outlet myTextField a tu UITextField y no te permitirá agregar más caracteres después de haber alcanzado el límite. Asegúrese de agregar esto a su método de dealloc:

[[NSNotificationCenter defaultCenter] removeObserver:self name:@"UITextFieldTextDidChangeNotification" object:myTextField];

Answer 16

Lo tengo hasta 1 línea de código :)

Establezca el delegado de la vista de texto en "self" y luego agregue <UITextViewDelegate> en su .h y el siguiente código en su .m .... puede ajustar el número "7" para que sea el número MÁXIMO de caracteres que desee. ser.

-(BOOL)textView:(UITextView *)a shouldChangeTextInRange:(NSRange)b replacementText:(NSString *)c {
    return ((a.text.length+c.length<=7)+(c.length<1)+(b.length>=c.length)>0);
}

Este código cuenta para escribir nuevos caracteres, eliminar caracteres, seleccionar caracteres y luego escribir o eliminar, seleccionar caracteres y cortar, pegar en general, y seleccionar caracteres y pegar.

¡Hecho!

Alternativamente, otra forma interesante de escribir este código con operaciones de bits sería

-(BOOL)textView:(UITextView *)a shouldChangeTextInRange:(NSRange)b replacementText:(NSString *)c {
    return 0^((a.text.length+c.length<=7)+(c.length<1)+(b.length>=c.length));
}

Answer 17

No puede hacer esto directamente: UITextField no tiene ningún atributo maxLength , pero puede establecer el delegado UITextField''s y luego usar:

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string

Answer 18

Otras respuestas no manejan el caso donde el usuario puede pegar una cadena larga desde el portapapeles. Si pego una cadena larga, solo se debe truncar pero se muestra. Use esto en su delegado:

static const NSUInteger maxNoOfCharacters = 5;

-(IBAction)textdidChange:(UITextField * )textField
{
NSString * text = textField.text;

if(text.length > maxNoOfCharacters)
{
    text = [text substringWithRange:NSMakeRange(0, maxNoOfCharacters)];
    textField.text = text;
}

// use ''text''

}

Answer 19

Para Xamarin:

YourTextField.ShouldChangeCharacters = 
delegate(UITextField textField, NSRange range, string replacementString)
        {
            return (range.Location + replacementString.Length) <= 4; // MaxLength == 4
        };

Answer 20

Para completar la respuesta de agosto , una posible implementación de la función propuesta (consulte el delegado de UITextField ).

No probé el código de dominio , pero el mío no se atasca si el usuario alcanza el límite, y es compatible con una nueva cadena que viene reemplaza a una más pequeña o igual.

-(BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {
    //limit the size :
    int limit = 20;
    return !([textField.text length]>limit && [string length] > range.length);
}

Answer 21

Para hacer que funcione con cortar y pegar cadenas de cualquier longitud, sugeriría cambiar la función a algo como:

#define MAX_LENGTH 20

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string
    {
        NSInteger insertDelta = string.length - range.length;

        if (textField.text.length + insertDelta > MAX_LENGTH)
        {
           return NO; // the new string would be longer than MAX_LENGTH
        }
        else {
            return YES;
        }
    }

Answer 22

Si bien la clase UITextField no tiene una propiedad de longitud máxima, es relativamente sencillo obtener esta funcionalidad configurando el delegate del campo de texto e implementando el siguiente método de delegado:

C objetivo

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {
    // Prevent crashing undo bug – see note below.
    if(range.length + range.location > textField.text.length)
    {
        return NO;
    }

    NSUInteger newLength = [textField.text length] + [string length] - range.length;
    return newLength <= 25;
}

Rápido

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {

    let currentCharacterCount = textField.text?.characters.count ?? 0
    if (range.length + range.location > currentCharacterCount){
        return false
    }
    let newLength = currentCharacterCount + string.characters.count - range.length
    return newLength <= 25
}

Antes de que cambie el campo de texto, el UITextField le pregunta al delegado si se debe cambiar el texto especificado. El campo de texto no ha cambiado en este punto, por lo que capturamos la longitud actual y la longitud de la cadena que estamos insertando (ya sea pegando texto copiado o escribiendo un solo carácter usando el teclado), menos la longitud del rango. Si este valor es demasiado largo (más de 25 caracteres en este ejemplo), devuelva NO para prohibir el cambio.

Al escribir un solo carácter al final de un campo de texto, la range.location será la longitud del campo actual, y la longitud de range.length será 0 porque no estamos reemplazando / eliminando nada. Insertar en el medio de un campo de texto solo significa una range.location diferente, y pegar varios caracteres simplemente significa que la string tiene más de un carácter.

La eliminación de caracteres individuales o el corte de múltiples caracteres se especifica mediante un range con una longitud distinta de cero y una cadena vacía. El reemplazo es solo una eliminación de rango con una cadena no vacía.

Una nota sobre el fallo "deshacer"

Como se menciona en los comentarios, hay un error con UITextField que puede provocar una caída.

Si pega en el campo, pero la implementación de la validación impide el pegado, la operación de pegado todavía se registra en el búfer de deshacer de la aplicación. Si luego dispara un deshacer (agitando el dispositivo y confirmando un Deshacer), el UITextField intentará reemplazar la cadena que cree que se pegó con una cadena vacía. Esto se bloqueará porque en realidad nunca pegó la cadena en sí misma. Intentará reemplazar una parte de la cadena que no existe.

Afortunadamente, puedes proteger al UITextField de matarse así mismo. Solo debe asegurarse de que el rango que propone reemplazar existe dentro de su cadena actual. Esto es lo que hace el control de cordura inicial anterior.

Swift 3.0 con copiar y pegar trabajando bien.

func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
        let str = (textView.text + text)
        if str.characters.count <= 10 {
            return true
        }
        textView.text = str.substring(to: str.index(str.startIndex, offsetBy: 10))
        return false
    }

Espero que te sea de ayuda.

Answer 23

Simulo el reemplazo de cadena real que está a punto de ocurrir para calcular la longitud de esa cadena futura:

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {

    NSString *newString = [textField.text stringByReplacingCharactersInRange:range withString:string];

    if([newString length] > maxLength)
       return NO;

    return YES;
}

Answer 24

Swift 3 version // ***** ¡Esto NO funcionará con Swift 2.x! ***** //

Primero cree un nuevo archivo Swift: TextFieldMaxLength.swift, y luego agregue el siguiente código:

import UIKit

private var maxLengths = [UITextField: Int]()

extension UITextField {

   @IBInspectable var maxLength: Int {

      get {

          guard let length = maxLengths[self] 
             else {
                return Int.max
      }
      return length
   }
   set {
      maxLengths[self] = newValue
      addTarget(
         self,
         action: #selector(limitLength),
         for: UIControlEvents.editingChanged
      )
   }
}
func limitLength(textField: UITextField) {
    guard let prospectiveText = textField.text,
        prospectiveText.characters.count > maxLength
    else {
        return
    }

   let selection = selectedTextRange
   let maxCharIndex = prospectiveText.index(prospectiveText.startIndex, offsetBy: maxLength)
   text = prospectiveText.substring(to: maxCharIndex)
   selectedTextRange = selection
   }
}

y luego verás en el Guión gráfico un nuevo campo (Longitud máxima) cuando selecciones cualquier Campo de texto

Si aún tiene más preguntas, visite este enlace: http://www.globalnerdy.com/2016/05/18/ios-programming-trick-how-to-use-xcode-to-set-a-text-fields-maximum-length-visual-studio-style/

Answer 25

Usando Interface builder puedes vincular y obtener el evento para "Edición modificada" en cualquiera de tus funciones. Ahora ahí puedes poner el cheque por la longitud.

- (IBAction)onValueChange:(id)sender 
{
    NSString *text = nil;
    int MAX_LENGTH = 20;
    switch ([sender tag] ) 
    {
        case 1: 
        {
            text = myEditField.text;
            if (MAX_LENGTH < [text length]) {
                myEditField.text = [text substringToIndex:MAX_LENGTH];
            }
        }
            break;
        default:
            break;
    }

}

Answer 26

Use este código aquí RESTRICTED_LENGTH es la longitud que desea restringir para el campo de texto.

   - (BOOL)textField:(UITextField *)textField     shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string
{
    if (textField == nameTF) {
    int limit = RESTRICTED_LENGTH - 1;
    return !([textField.text length]>limit && [string length] > range.length);
    }
   else
   {
    return YES;
   }

return NO;

}

Answer 27

Utilice la siguiente extensión para los límites de caracteres UITextField y UITextView .

    private var kAssociationKeyMaxLength: Int = 0

    extension UITextField {


        @IBInspectable var maxLength: Int {
            get {
                if let length = objc_getAssociatedObject(self, &kAssociationKeyMaxLength) as? Int {
                    return length
                } else {
                    return Int.max
                }
            }
            set {
                objc_setAssociatedObject(self, &kAssociationKeyMaxLength, newValue, .OBJC_ASSOCIATION_RETAIN)
                addTarget(self, action: #selector(checkMaxLength), for: .editingChanged)
            }
        }

        @objc func checkMaxLength(textField: UITextField) {
            guard let prospectiveText = self.text,
                prospectiveText.count > maxLength
                else {
                    return
            }

            let selection = selectedTextRange

            let indexEndOfText = prospectiveText.index(prospectiveText.startIndex, offsetBy: maxLength)
            let substring = prospectiveText[..<indexEndOfText]
            text = String(substring)

            selectedTextRange = selection
        }
    }

    extension UITextView:UITextViewDelegate {


    @IBInspectable var maxLength: Int {
        get {
            if let length = objc_getAssociatedObject(self, &kAssociationKeyMaxLength) as? Int {
                return length
            } else {
                return Int.max
            }
        }
        set {
            self.delegate = self

            objc_setAssociatedObject(self, &kAssociationKeyMaxLength, newValue, .OBJC_ASSOCIATION_RETAIN)
        }
    }

    public func textViewDidChange(_ textView: UITextView) {
        checkMaxLength(textField: self)
    }
    @objc func checkMaxLength(textField: UITextView) {
        guard let prospectiveText = self.text,
            prospectiveText.count > maxLength
            else {
                return
        }

        let selection = selectedTextRange

        let indexEndOfText = prospectiveText.index(prospectiveText.startIndex, offsetBy: maxLength)
        let substring = prospectiveText[..<indexEndOfText]
        text = String(substring)

        selectedTextRange = selection
    }
}

Puede establecer el límite a continuación.

Answer 28

ahora cuantos caracteres quieres dar solo valores

 - (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range   replacementString:(NSString *)string {
     NSUInteger newLength = [textField.text length] + [string length] - range.length;
     return (newLength > 25) ? NO : YES;
  }

Answer 29

Swift 2.0 +

En primer lugar crear una clase para este proceso. Vamos a llamarlo StringValidator.swift.

Luego simplemente pegue el siguiente código en su interior.

import Foundation

extension String {

func containsCharactersIn(matchCharacters: String) -> Bool {
let characterSet = NSCharacterSet(charactersInString: matchCharacters)
return self.rangeOfCharacterFromSet(characterSet) != nil
}

func containsOnlyCharactersIn(matchCharacters: String) -> Bool {
let disallowedCharacterSet = NSCharacterSet(charactersInString: matchCharacters).invertedSet
return self.rangeOfCharacterFromSet(disallowedCharacterSet) == nil
}


func doesNotContainCharactersIn(matchCharacters: String) -> Bool {
let characterSet = NSCharacterSet(charactersInString: matchCharacters)
return self.rangeOfCharacterFromSet(characterSet) == nil
}

func isNumeric() -> Bool
{
let scanner = NSScanner(string: self)
scanner.locale = NSLocale.currentLocale()

return scanner.scanDecimal(nil) && scanner.atEnd
}

}

Ahora salva la clase .....

Uso..

Ahora ve a tu clase viewController.swift y crea salidas de tu campo de texto como ...

@IBOutlet weak var contactEntryTxtFld: UITextField! //First textfield
@IBOutlet weak var contactEntryTxtFld2: UITextField!   //Second textfield

Ahora vaya al método shouldChangeCharactersInRange del campo de texto y use como el siguiente.

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    if string.characters.count == 0 {
        return true
    }
    let latestText = textField.text ?? ""
    let checkAbleText = (latestText as NSString).stringByReplacingCharactersInRange(range, withString: string)


    switch textField {

    case contactEntryTxtFld:
        return checkAbleText.containsOnlyCharactersIn("0123456789") && prospectiveText.characters.count <= 5

    case contactEntryTxtFld2:
        return checkAbleText.containsOnlyCharactersIn("0123456789") && prospectiveText.characters.count <= 5

    default:
        return true
    }

}

No te olvides de configurar el protocolo delegado / métodos de los campos de texto.

Permítanme explicar sobre esto ... Estoy usando el proceso de extensión simple de cadena que escribí dentro de otra clase. Ahora solo estoy llamando a los métodos de extensión de otra clase donde los necesito agregando el valor de verificación y el valor máximo.

Caracteristicas...

1. Establecerá el límite máximo de un campo de texto en particular.
2. Establecerá el tipo de claves aceptadas para un campo de texto en particular.

Tipos ...

includesOnlyCharactersIn // Acepta solo caracteres.

contiene CharactersIn // Acepta combinación de caracteres

doesNotContainsCharactersIn // No aceptará caracteres

Espero que esto haya ayudado .... Gracias ..

Answer 30

Swift 4

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    guard let text = textField.text else { return true }
    let newLength = text.count + string.count - range.length
    return newLength <= 10
}