¿Cómo puedo detectar cualquier cambio de texto en un campo de texto? El método delegado shouldChangeCharactersInRangefunciona para algo, pero no satisfizo exactamente mi necesidad. Como hasta que devuelve SÍ, los textos textField no están disponibles para otros métodos de observación.

Por ejemplo, en mi código calculateAndUpdateTextFieldsno recibí el texto actualizado, el usuario ha escrito.

Es su forma de obtener algo como el textChangedcontrolador de eventos Java.

- (BOOL)textField:(UITextField *)textField 
            shouldChangeCharactersInRange:(NSRange)range 
            replacementString:(NSString *)string 
{
    if (textField.tag == kTextFieldTagSubtotal 
        || textField.tag == kTextFieldTagSubtotalDecimal
        || textField.tag == kTextFieldTagShipping
        || textField.tag == kTextFieldTagShippingDecimal) 
    {
        [self calculateAndUpdateTextFields];

    }

    return YES;
}

De la manera correcta de hacer un cambio de texto uitextfield, devuelva la llamada :

Capturo los caracteres enviados a un control UITextField algo como esto:

// Add a "textFieldDidChange" notification method to the text field control.

En el objetivo-C:

[textField addTarget:self 
              action:@selector(textFieldDidChange:) 
    forControlEvents:UIControlEventEditingChanged];

En Swift:

textField.addTarget(self, action: #selector(textFieldDidChange), for: .editingChanged)

Luego, en el textFieldDidChangemétodo, puede examinar el contenido de textField y volver a cargar la vista de tabla según sea necesario.

Podría usar eso y poner CalculateAndUpdateTextFields como su selector.

La respuesta de XenElement es acertada.

Lo anterior también se puede hacer en el generador de interfaces haciendo clic derecho en UITextField y arrastrando el evento de envío "Edición modificada" a su unidad de subclase.

para configurar el oyente del evento:

[self.textField addTarget:self action:@selector(textFieldDidChange:) forControlEvents:UIControlEventEditingChanged];

para escuchar realmente:

- (void)textFieldDidChange:(UITextField *)textField {
    NSLog(@"text changed: %@", textField.text);
}

Rápido:

yourTextfield.addTarget(self, action: #selector(textFieldDidChange(textField:)), for: .editingChanged)

Luego, implemente la función de devolución de llamada:

@objc func textFieldDidChange(textField: UITextField){

print("Text changed")

}

Como se indica aquí: evento de cambio de texto UITextField , parece que a partir de iOS 6 (iOS 6.0 y 6.1 verificado) no es posible detectar completamente los cambios en los UITextFieldobjetos simplemente observando el UITextFieldTextDidChangeNotification.

Parece que ahora solo se rastrean los cambios realizados directamente por el teclado iOS incorporado. Esto significa que si cambia su UITextFieldobjeto simplemente invocando algo como esto: myUITextField.text = @"any_text"no se le notificará ningún cambio.

No sé si esto es un error o si está destinado. Parece un error ya que no he encontrado ninguna explicación razonable en la documentación. Esto también se indica aquí: evento de cambio de texto UITextField .

Mi "solución" para esto es publicar una notificación por mí mismo por cada cambio que realice en mi UITextField(si ese cambio se realiza sin usar el teclado iOS incorporado). Algo como esto:

myUITextField.text = @"I'm_updating_my_UITextField_directly_in_code";

NSNotification *myTextFieldUpdateNotification  = 
  [NSNotification notificationWithName:UITextFieldTextDidChangeNotification
                  object:myUITextField];

[NSNotificationCenter.defaultCenter 
  postNotification:myTextFieldUpdateNotification];

De esta manera, está 100% seguro de que recibirá la misma notificación cuando cambie la .textpropiedad de suUITextField objeto, ya sea cuando lo actualice "manualmente" en su código o mediante el teclado iOS incorporado.

Es importante tener en cuenta que, dado que este no es un comportamiento documentado, este enfoque puede dar lugar a 2 notificaciones recibidas para el mismo cambio en su UITextFieldobjeto. Dependiendo de sus necesidades (lo que realmente hace cuando UITextField.textcambia), esto podría ser un inconveniente para usted.

Un enfoque ligeramente diferente sería publicar una notificación personalizada (es decir, con un nombre personalizado diferente a UITextFieldTextDidChangeNotification) si realmente necesita saber si la notificación fue suya o "hecha por iOS".

EDITAR:

Acabo de encontrar un enfoque diferente que creo que podría ser mejor:

Esto implica la característica de Observación de valores clave (KVO) de Objective-C ( http://developer.apple.com/library/ios/#documentation/cocoa/conceptual/KeyValueObserving/KeyValueObserving.html#//apple_ref/doc/uid / 10000177-BCICJDHA ).

Básicamente, usted se registra como observador de una propiedad y si esta propiedad cambia, se le notificará al respecto. El "principio" es bastante similar a cómo NSNotificationCenterfunciona, siendo la principal ventaja de que este enfoque funciona automáticamente también a partir de iOS 6 (sin ningún ajuste especial como tener que publicar notificaciones manualmente).

Para nuestro UITextField-scenario, esto funciona bien si agrega este código a, por ejemplo, el UIViewControllerque contiene el campo de texto:

static void *myContext = &myContext;

- (void)viewDidLoad {
  [super viewDidLoad];

  //Observing changes to myUITextField.text:
  [myUITextField addObserver:self forKeyPath:@"text"
    options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld 
    context:myContext];

}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object 
change:(NSDictionary *)change context:(void *)context {

  if(context == myContext) {
    //Here you get notified every time myUITextField's "text" property is updated
    NSLog(@"New value: %@ - Old value: %@",
      [change objectForKey:NSKeyValueChangeNewKey],
      [change objectForKey:NSKeyValueChangeOldKey]);
  }
  else 
    [super observeValueForKeyPath:keyPath ofObject:object 
      change:change context:context];

}

Crédito a esta respuesta con respecto a la gestión del "contexto": https://stackoverflow.com/a/12097161/2078512

Nota: Parece que mientras está en el proceso de editar un UITextFieldcon el teclado iOS incorporado, la propiedad "texto" del campo de texto no se actualiza con cada nueva letra escrita / eliminada. En cambio, el objeto de campo de texto se actualiza "en su conjunto" después de que renuncia al primer estado de respuesta del campo de texto.

Podemos configurarlo fácilmente Storyboard, arrastrar CTRL @IBActiony cambiar el evento de la siguiente manera:

Aquí en versión rápida para lo mismo.

textField.addTarget(self, action: "textFieldDidChange:", forControlEvents: UIControlEvents.EditingChanged)

func textFieldDidChange(textField: UITextField) {

}

Gracias

Resolví el problema cambiando el comportamiento de shouldChangeChractersInRange. Si devuelve NO, iOS no aplicará los cambios internamente, sino que tiene la oportunidad de cambiarlos manualmente y realizar cualquier acción después de los cambios.

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {
    //Replace the string manually in the textbox
    textField.text = [textField.text stringByReplacingCharactersInRange:range withString:string];
    //perform any logic here now that you are sure the textbox text has changed
    [self didChangeTextInTextField:textField];
    return NO; //this make iOS not to perform any action
}

Versión Swift probada:

//Somewhere in your UIViewController, like viewDidLoad(){ ... }
self.textField.addTarget(
        self, 
        action: #selector(SearchViewController.textFieldDidChange(_:)),
        forControlEvents: UIControlEvents.EditingChanged
)

Parámetros explicados:

self.textField //-> A UITextField defined somewhere in your UIViewController
self //-> UIViewController
.textFieldDidChange(_:) //-> Can be named anyway you like, as long as it is defined in your UIViewController

Luego agregue el método que creó anteriormente en su UIViewController:

//Gets called everytime the text changes in the textfield.
func textFieldDidChange(textField: UITextField){

    print("Text changed: " + textField.text!)

}

Swift 4

func addNotificationObservers() {

    NotificationCenter.default.addObserver(self, selector: #selector(textFieldDidChangeAction(_:)), name: .UITextFieldTextDidChange, object: nil)

}

@objc func textFieldDidChangeAction(_ notification: NSNotification) {

    let textField = notification.object as! UITextField
    print(textField.text!)

}

Para Swift 3.0:

let textField = UITextField()

textField.addTarget(
    nil,
    action: #selector(MyClass.textChanged(_:)),
    for: UIControlEvents.editingChanged
)

usando clase como:

class MyClass {
    func textChanged(sender: Any!) {

    }
}

Versión Swift 3

yourTextField.addTarget(self, action: #selector(YourControllerName.textChanges(_:)), for: UIControlEvents.editingChanged)

Y obtén los cambios aquí

func textChanges(_ textField: UITextField) {
    let text = textField.text! // your desired text here
    // Now do whatever you want.
}

Espero eso ayude.

Debe usar la notificación para resolver este problema, porque el otro método escuchará el cuadro de entrada, no la entrada real, especialmente cuando usa el método de entrada chino. En vista Descarga

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

entonces

- (void)textFiledEditChanged:(NSNotification *)obj {
UITextField *textField = (UITextField *)obj.object;
NSString *toBestring = textField.text;
NSArray *currentar = [UITextInputMode activeInputModes];
UITextInputMode *currentMode = [currentar firstObject];
if ([currentMode.primaryLanguage isEqualToString:@"zh-Hans"]) {
    UITextRange *selectedRange = [textField markedTextRange];
    UITextPosition *position = [textField positionFromPosition:selectedRange.start offset:0];
    if (!position) {
        if (toBestring.length > kMaxLength)
            textField.text =  toBestring;
} 

}

finalmente, corres, listo.

Swift 3.1:

Selector: ClassName.MethodName

  cell.lblItem.addTarget(self, action: #selector(NewListScreen.fieldChanged(textfieldChange:)), for: .editingChanged)

  func fieldChanged(textfieldChange: UITextField){

    }

Versión Swift 3:

class SomeClass: UIViewController, UITextFieldDelegate { 

   @IBOutlet weak var aTextField: UITextField!


    override func viewDidLoad() {
        super.viewDidLoad()

        aTextField.delegate = self
        aTextField.addTarget(self, action: #selector(SignUpVC.textFieldDidChange), for: UIControlEvents.editingChanged)        
    }

   func textFieldDidChange(_ textField: UITextField) {

       //TEXT FIELD CHANGED..SECRET STUFF

   }

}

No olvide configurar el delegado.

Con cierre:

   class TextFieldWithClosure: UITextField {
    var targetAction: (() -> Void)? {
        didSet {
            self.addTarget(self, action: #selector(self.targetSelector), for: .editingChanged)
        }
    }

    func targetSelector() {
        self.targetAction?()
    }
    }

y usando

textField.targetAction? = {
 // will fire on text changed
 }

1. Las soluciones de KVO no funcionan

KVO NO funciona en iOS para controles: http://stackoverflow.com/a/6352525/1402846 https://developer.apple.com/library/archive/documentation/General/Conceptual/DevPedia-CocoaCore/KVO.html

2. En la clase de observación, haces esto:

Dado que conoce la vista de texto que desea ver:

var watchedTextView: UITextView!

Hacer esto:

NotificationCenter.default.addObserver(
    self,
    selector: #selector(changed),
    name: UITextView.textDidChangeNotification,
    object: watchedTextView)

Sin embargo, tenga cuidado con eso:

• es probable que solo quieras llamar así una vez , así que no lo llames, por ejemplo,layoutSubviews

• es bastante difícil saber cuándo llamarlo mejor durante el proceso de actualización Dependerá de tu situación. Lamentablemente, no existe una solución estándar bloqueada

• por ejemplo, por lo general, no puede llamarlo a inittiempo, ya que, por supuesto watchedTextView, aún no existe

.

3. el siguiente problema es que ...

Ninguna de las notificaciones se llama cuando el texto se cambia mediante programación .

Esta es una molestia enorme, antigua y estúpida en la ingeniería de iOS.

Los controles simplemente no, al final de la historia , llaman a las notificaciones cuando la propiedad .text se cambia mediante programación.

Esto es increíblemente molesto porque, por supuesto, obviamente, cada aplicación creada establece el texto mediante programación, como borrar el campo después de que el usuario publica, etc.

Debe subclasificar la vista de texto (o control similar) de esta manera:

class NonIdioticTextView: UIITextView {

    override var text: String! {
        // boilerplate code needed to make watchers work properly:
        get {
            return super.text
        }
        set {
            super.text = newValue
            NotificationCenter.default.post(
                name: UITextView.textDidChangeNotification,
                object: self)
        }

    }

}

(Consejo: ¡no olvide que la súper llamada tiene que venir antes ! La llamada posterior).

No hay una solución disponible, a menos que arregle el control subclasificando como se muestra arriba. Ese es el unico solución.

Tenga en cuenta que la notificación

UITextView.textDidChangeNotification

resultados en

func textViewDidChangeSelection(_ textView: UITextView) 

siendo llamado.

( No textViewDidChange )

[[NSNotificationCenter defaultCenter] addObserver:self 
selector:@selector(didChangeTextViewText:) 
name:UITextFieldTextDidChangeNotification object:nil];



- (void) didChangeTextViewText {
 //do something
}

Una cosa es que puede tener múltiples UITextFields. Entonces, deles una etiqueta y luego puede encender las etiquetas. Aquí se explica cómo configurar un observador en cualquier clase.

private func setupTextFieldNotification() {
    NotificationCenter.default.addObserver(forName: UITextField.textDidChangeNotification, object: nil, queue: OperationQueue.main) { (notification) in
        if let textField = notification.object as? UITextField, textField.tag == 100, let text = textField.text {
            print(#line, text)
        }
    }
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

Versión Swift 4

Uso de la observación de valores clave Notifique a los objetos sobre los cambios en las propiedades de otros objetos.

var textFieldObserver: NSKeyValueObservation?

textFieldObserver = yourTextField.observe(\.text, options: [.new, .old]) { [weak self] (object, changeValue) in
  guard let strongSelf = self else { return }
  print(changeValue)
}