Establecer la longitud máxima de caracteres de un UITextField

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

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

C objective

 - (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 el campo de texto cambie, UITextField pregunta al delegado si el texto especificado debe cambiarse. El campo de texto no ha cambiado en este punto, así que tomamos su longitud actual y la longitud de 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 en un solo carácter al final de un campo de texto, range.location será la longitud del campo actual, y range.length será 0 porque no estamos reemplazando / eliminando nada. Insertar en el medio de un campo de texto solo significa un range.location diferente. range.location , y pegar varios caracteres solo significa que la string tiene más de un carácter.

La eliminación de caracteres individuales o el corte de varios 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 error "deshacer" que se colgaba

Como se menciona en los comentarios, hay un error con UITextField que puede provocar un locking.

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

Afortunadamente, puedes proteger el UITextField no se mate así. Solo necesita 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 funciona 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 sea útil para ti.

¡Gracias augusto! ( Post )

Este es el código que terminé con el 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;} } 

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[.. 

Editar: problema de pérdida de memoria solucionado.

enter image description here

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

No probé el código domness , pero el mío no se bloquea si el usuario alcanza el límite, y es compatible con una nueva cadena que sustituye 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); } 

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 

A menudo tiene 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 } } 

La mejor manera sería configurar una notificación sobre el cambio de texto. En su -awakeFromNib de control -awakeFromNib de su 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 la salida myTextField a su UITextField y no le permitirá agregar más caracteres después de llegar al límite. Asegúrese de agregar esto a su método dealloc:

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

Creé esta subclase UITextFieldLimit:

  • Múltiples campos de texto compatibles
  • Establecer el límite de longitud de texto
  • Prevención de pasta
  • Muestra una etiqueta con los caracteres de la izquierda dentro del campo de texto, se oculta cuando se detiene la edición.
  • Agite la animación cuando no queden caracteres.

UITextFieldLimit.h el UITextFieldLimit.h y el UITextFieldLimit.m de este repository de GitHub:

https://github.com/JonathanGurebo/UITextFieldLimit

y comienza a probar!

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

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 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!

Esto debería ser suficiente para resolver el problema (reemplace 4 por el límite que desee). Solo asegúrate 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); } 

Simulo el reemplazo de cadena real que está a punto de suceder para calcular la longitud de la 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; } 

Swift 3 versión // ***** ¡Esto NO funcionará con Swift 2.x! ***** //

Primero crea un nuevo archivo Swift: TextFieldMaxLength.swift, y luego agrega 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á en Storyboard un nuevo campo (Max Length) cuando seleccione cualquier campo de texto

si todavía tiene más preguntas, consulte 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 /

Usando el constructor de Interfaces puede vincular y obtener el evento de “Edición modificada” en cualquiera de sus funciones. Ahora ahí puedes verificar 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; } } 

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 que se ajuste al límite en lugar de rechazar completamente la operación de pegar.

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

Para que funcione con cortar y pegar cadenas de cualquier longitud, sugeriría cambiar la función a algo así 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; } } 

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

 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(prospectiveText.startIndex ..< prospectiveText.startIndex.advancedBy(maxLength)) ) selectedTextRange = selection } } 

Swift 2.0 +

Antes que nada crea una clase para este proceso. Vamos a llamarlo StringValidator.swift.

Luego solo pega el siguiente código dentro de él.

 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 guarde la clase …..

Uso..

Ahora vaya a su clase viewController.swift y haga las salidas de su campo de texto como …

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

Ahora vaya al método de los campos de texto de canChangeSInRange y utilícelo de la siguiente manera.

 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 olvides configurar el protocolo / métodos delegates de los campos de texto.

Déjame explicarte sobre esto ... Estoy usando el proceso de extensión simple de una cadena que escribí dentro de otra clase. Ahora solo estoy llamando a esos métodos de extensión de otra clase donde los necesito agregando cheque y 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 particular.

Tipos ...

containsOnlyCharactersIn // Acepta solo caracteres.

containsCharactersIn // Acepta combinación de caracteres

doesNotContainsCharactersIn // No acepta caracteres

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

rápido 3.0

Este código funciona bien cuando está pegando una cadena más que los límites de su carácter.

 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 🙂

Esta es la forma correcta de manejar la longitud máxima en UITextField, permite que la tecla de retorno salga de la renuncia del campo de texto como primera respuesta y permite al usuario retroceder cuando alcanzan el 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; } } 

Para Xamarin:

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

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 } 

Otras respuestas no manejan el caso donde el usuario puede pegar una cadena larga desde el portapapeles. Si pego una cadena larga, 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' } 

Lo tengo abajo a 1 línea de código 🙂

Establezca el delegado de su vista de texto en “self” y luego agregue el en su .h y el siguiente código en su .m …. puede ajustar el número “7” para que sea lo que quiera su número MÁXIMO de caracteres. 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 explica 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 buena manera de escribir este código con bit-operations 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)); } 

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

ahora cuántos caracteres quieres solo dar 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; } 

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

Hice esto en Swift para un límite de 8 caracteres cuando uso 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 Eliminar funcionara en el teclado numérico, de lo contrario no permitiría eliminar caracteres en el campo de texto una vez que alcanzara su valor máximo.

Implementé una extensión UITextField para agregarle una propiedad maxLength.

Se basa en Xcode 6 IBInspectables, por lo que puede establecer el límite de maxLength en el constructor de interfaz.

Aquí está la implementación:

UITextField + MaxLength.h

 #import  @interface UITextField_MaxLength : UITextField @property (nonatomic)IBInspectable int textMaxLength; @end 

UITextField + MaxLength.m

 #import "UITextField+MaxLength.h" @interface UITextField_MaxLength() @property (nonatomic, assign) id  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)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 

Doy una respuesta complementaria basada en @Frouo. Creo que su respuesta es la más bella. 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 } } 

El problema con algunas de las respuestas dadas anteriormente es, por ejemplo, que 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 y tampoco funciona. Como yo estaba enfrentando el mismo problema. Salió con la solución, dada a continuación. Funciona perfecto para mí

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

Estoy teniendo 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

 (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string { NSString *newString = [textField.text stringByReplacingCharactersInRange:range withString:string]; if ([txt_name.text length]>100) { return NO; } return YES; }