Esiste un modo per rilevare quando si preme il tasto Backspace/ Deletenella tastiera dell'iPhone su un dispositivo UITextFieldvuoto? Voglio sapere quando Backspaceviene premuto solo se UITextFieldè vuoto.

Sulla base del suggerimento di @Alex Reynolds in un commento, ho aggiunto il seguente codice durante la creazione del mio campo di testo:

[[NSNotificationCenter defaultCenter] addObserver:self
          selector:@selector(handleTextFieldChanged:)
              name:UITextFieldTextDidChangeNotification
            object:searchTextField];

Questa notifica viene ricevuta (la handleTextFieldChangedfunzione viene chiamata), ma non ancora quando premo il Backspacetasto in un campo vuoto. Qualche idea?

Sembra esserci un po 'di confusione su questa domanda. Voglio ricevere una notifica quando Backspaceviene premuto il tasto. Questo è tutto. Ma la soluzione deve funzionare anche quando UITextFieldè già vuota.

Potrebbe essere un tiro lungo ma potrebbe funzionare. Prova a impostare il testo del campo di testo su un carattere spazio di larghezza zero \u200B. Quando il backspace viene premuto su un campo di testo che appare vuoto, in realtà cancellerà il tuo spazio. Quindi puoi semplicemente reinserire lo spazio.

Potrebbe non funzionare se l'utente riesce a spostare il cursore a sinistra dello spazio.

Swift 4:

Sottoclasse UITextField:

// MyTextField.swift
import UIKit

protocol MyTextFieldDelegate: AnyObject {
    func textFieldDidDelete()
}

class MyTextField: UITextField {

    weak var myDelegate: MyTextFieldDelegate?

    override func deleteBackward() {
        super.deleteBackward()
        myDelegate?.textFieldDidDelete()
    }

}

Implementazione:

// ViewController.swift

import UIKit

class ViewController: UIViewController, MyTextFieldDelegate {

    override func viewDidLoad() {
        super.viewDidLoad()

        // initialize textField
        let input = MyTextField(frame: CGRect(x: 50, y: 50, width: 150, height: 40))

        // set viewController as "myDelegate"
        input.myDelegate = self

        // add textField to view
        view.addSubview(input)

        // focus the text field
        input.becomeFirstResponder()
    }

    func textFieldDidDelete() {
        print("delete")
    }

}

Objective-C:

Sottoclasse UITextField:

//Header
//MyTextField.h

//create delegate protocol
@protocol MyTextFieldDelegate <NSObject>
@optional
- (void)textFieldDidDelete;
@end

@interface MyTextField : UITextField<UIKeyInput>

//create "myDelegate"
@property (nonatomic, assign) id<MyTextFieldDelegate> myDelegate;
@end

//Implementation
#import "MyTextField.h"

@implementation MyTextField

- (void)deleteBackward {
    [super deleteBackward];

    if ([_myDelegate respondsToSelector:@selector(textFieldDidDelete)]){
        [_myDelegate textFieldDidDelete];
    }
}

@end

Ora aggiungi semplicemente MyTextFieldDelegate al tuo UIViewControllere imposta UITextFields myDelegate su self:

//View Controller Header
#import "MyTextField.h"

//add "MyTextFieldDelegate" to you view controller
@interface ViewController : UIViewController <MyTextFieldDelegate>
@end

//View Controller Implementation
- (void)viewDidLoad {
    //initialize your text field
    MyTextField *input = 
     [[MyTextField alloc] initWithFrame:CGRectMake(0, 0, 70, 30)];

    //set your view controller as "myDelegate"
    input.myDelegate = self;

    //add your text field to the view
    [self.view addSubview:input];
}

//MyTextField Delegate
- (void)textFieldDidDelete {
    NSLog(@"delete");
}

Aggiornamento: vedi la risposta di JacobCaraballo per un esempio che ha la precedenza -[UITextField deleteBackward].

Dai un'occhiata UITextInput, UIKeyInputha in particolare un deleteBackwardmetodo delegato che viene sempre chiamato quando viene premuto il tasto Canc. Se stai facendo qualcosa di semplice, potresti considerare solo la sottoclasse UILabele renderlo conforme al UIKeyInputprotocollo, come fatto da SimpleTextInput e da questo esempio di UIKeyInput di iPhone . Nota: UITextInpute i suoi parenti (incluso UIKeyInput) sono disponibili solo in iOS 3.2 e versioni successive.

Codice come il seguente:

@interface MyTextField : UITextField
@end

@implementation MyTextField

- (void)deleteBackward
{
    [super deleteBackward];

    //At here, you can handle backspace key pressed event even the text field is empty
}

@end

Alla fine, dimentica di cambiare la proprietà Classe personalizzata del campo di testo in "MyTextField"

Implementazione rapida:

import UIKit

protocol PinTexFieldDelegate : UITextFieldDelegate {
    func didPressBackspace(textField : PinTextField)
}

class PinTextField: UITextField {

    override func deleteBackward() {
        super.deleteBackward()

        // If conforming to our extension protocol
        if let pinDelegate = self.delegate as? PinTexFieldDelegate {
            pinDelegate.didPressBackspace(self)
        }
    }
}

Ho trovato un modo più semplice della subclasssoluzione. Anche è un po 'strano ma funziona bene.

- (BOOL)textView:(UITextView *)textView 
        shouldChangeTextInRange:(NSRange)range 
        replacementText:(NSString *)text
{
    const char * _char = [text cStringUsingEncoding:NSUTF8StringEncoding];
    int isBackSpace = strcmp(_char, "\b");

    if (isBackSpace == -8) {
       // is backspace
    }

    return YES;
}

È un po 'strano perché il risultato del confronto è -8. Forse mi sbaglierò in qualche punto di C Programming. Ma è il lavoro giusto;)

Prova il delegate

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

Quindi controlla se il range.length == 1che sembra essere il caso quando backspaceviene colpito.

si prega di utilizzare sotto il codice che ti aiuterà a rilevare il tasto di cancellazione della tastiera anche se il campo di testo è vuoto.

Obiettivo C:

- (BOOL)keyboardInputShouldDelete:(UITextField *)textField { return YES; }

Veloce:

func keyboardInputShouldDelete(_ textField: UITextField) -> Bool { return true }

La risposta di Niklas Alvaeus mi ha aiutato con un problema simile

Stavo limitando l'ingresso a un set di caratteri specifico, ma ignoravo i backspaces. Quindi l'ho fatto controllare range.length == 1prima di tagliare il file NSString. Se è vero, restituisco semplicemente la stringa e non la taglio. Vedi sotto

 - (BOOL) textField:(UITextField *)textField 
          shouldChangeCharactersInRange:(NSRange)range 
          replacementString:(NSString *)string
 {
     NSCharacterSet *nonNumberSet = 
      [[NSCharacterSet characterSetWithCharactersInString:@"0123456789."] 
         invertedSet];

    if (range.length == 1) {
       return string;
    }
    else {
       return ([string stringByTrimmingCharactersInSet:nonNumberSet].length > 0);
    }   
 }

Per quelli che hanno problemi con la risposta di Jacob ho implementato la mia sottoclasse del campo di testo come segue e funziona alla grande!

#import <UIKit/UIKit.h>

@class HTTextField;

@protocol HTBackspaceDelegate <NSObject>

@optional
- (void)textFieldDidBackspace:(HTTextField*)textField;
@end

@interface HTTextField : UITextField<UIKeyInput>

@property (nonatomic, assign) id<HTBackspaceDelegate> backspaceDelegate;

@end


#import "HTTextField.h"

@implementation HTTextField

- (void)deleteBackward {
    [super deleteBackward];
    if ([self.backspaceDelegate respondsToSelector:@selector(textFieldDidBackspace:)]){
        [self.backspaceDelegate textFieldDidBackspace:self];
    }
}

- (BOOL)keyboardInputShouldDelete:(UITextField *)textField {
    BOOL shouldDelete = YES;

    if ([UITextField instancesRespondToSelector:_cmd]) {
        BOOL (*keyboardInputShouldDelete)(id, SEL, UITextField *) = (BOOL (*)(id, SEL, UITextField *))[UITextField instanceMethodForSelector:_cmd];

        if (keyboardInputShouldDelete) {
            shouldDelete = keyboardInputShouldDelete(self, _cmd, textField);
        }
    }

    if (![textField.text length] && [[[UIDevice currentDevice] systemVersion] intValue] >= 8) {
        [self deleteBackward];
    }

    return shouldDelete;
}

@end

Sì, usa il metodo seguente per rilevare backspace, quando textField è vuoto.

È necessario aggiungere UITextFieldDelegate

yourTextField.delegate = self (DEVE RICHIESTO)

Swift:

func keyboardInputShouldDelete(_ textField: UITextField) -> Bool { 
    return true
}

Obiettivo C:

- (BOOL)keyboardInputShouldDelete:(UITextField *)textField { 
    return YES; 
}

L'uso migliore che ho trovato per rilevare backspace è rilevare quando l'utente ha premuto backspace in uno spazio vuoto UITextField. Ad esempio, se hai appannato i destinatari nell'app di posta, quando premi backspace inUITextField , seleziona l'ultimo destinatario "gorgogliante".

Questo può essere fatto in modo simile alla risposta di Jacob Caraballo. Ma nella risposta di Jacob, se UITextFieldè rimasto un carattere quando si colpisce backspace, al momento della ricezione del messaggio delegato, UITextFieldsarà già vuoto, quindi si sta effettivamente rilevando backspacesu un campo di testo con al massimo un carattere.

In realtà, se si desidera rilevare backspaceun UITextFieldcon esattamente zero caratteri (vuoto), è necessario inviare il messaggio a delegateprima della chiamata a super deleteBackward. Per esempio:

#import "MyTextField.h"

//Text field that detects when backspace is hit with empty text
@implementation MyTextField

#pragma mark - UIKeyInput protocol
-(void)deleteBackward
{
  BOOL isTextFieldEmpty = (self.text.length == 0);
  if (isTextFieldEmpty) {
    if ([self.delegate 
         respondsToSelector:@selector(textFieldDidHitBackspaceWithEmptyText:)]) {

        [self.delegate textFieldDidHitBackspaceWithEmptyText:self];
        }
    }
    [super deleteBackward];
}
@end

L'interfaccia per un tale campo di testo sarebbe simile a questa:

@protocol MyTextFieldDelegate;

@interface MyTextField : UITextField
@property(nonatomic, weak) id<MyTextFieldDelegate> delegate;
@end

@protocol MyTextFieldDelegate <UITextFieldDelegate>
@optional
-(void)textFieldDidHitBackspaceWithEmptyText:(MyTextField *)textField;
@end

In iOS 6, il metodo deleteBackward viene chiamato su UITextField quando viene premuto backspace, anche quando il campo è vuoto. Quindi puoi sottoclassare UITextField e fornire la tua implementazione deleteBackward (invocando anche i super.)

Sto ancora supportando iOS 5, quindi avrò bisogno di una combinazione della risposta di Andrew e questa.

:) solo per il titolo "Rileva backspace", dove uso UIKeyboardTypeNumberPad.

Stasera incontro anche la stessa domanda e il seguente codice è per scoprirlo:

- (BOOL)textField:(UITextField *)textField 
        shouldChangeCharactersInRange:(NSRange)range 
        replacementString:(NSString *)string
{
    NSLog([NSString stringWithFormat:@"%d", [string length]]);
}

Perché con UIKeyboardTypeNumberPad, l'utente può solo inserire Numero o backspace, quindi quando la lunghezza della stringa è 0, deve essere una chiave backspace.

Spero che quanto sopra possa aiutare.

Invece di provare a precostruire ciò che SARÀ nel campo di testo o capire quale carattere speciale è stato inserito nel shouldChangeCharactersInRangemetodo, suggerirei di fare quanto segue:

[self performSelector:@selector(manageSearchResultsDisplay) 
           withObject:nil 
           afterDelay:0];

Ciò consente di chiamare un metodo direttamente dopo il completamento dell'operazione corrente. La cosa interessante di questo è che, al termine, il valore modificato sarà già in UITextField. A quel punto, puoi semplicemente controllarne la lunghezza e / o confermare in base a cosa c'è.

La sottoclasse di UITextField non ha funzionato per me su iOS 8.3, deleteBackward non è mai stato chiamato.

Ecco la soluzione che ho usato, funziona su tutte le versioni di iOS 8 e dovrebbe funzionare anche su altre versioni di iOS

for textField in textFields {
            textField.text = " "
}

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
        if string == "" && textField.text == " "   {
            // Do stuff here
            return false
        }
        return true
}

Nel file .h aggiungi il delegato UIKeyInput

- (BOOL)keyboardInputShouldDelete:(UITextField *)textField {

if ([textField isEqual:_txtFirstDigit]) {

}else if([textField isEqual:_txtSecondDigit]) {
    [_txtFirstDigit becomeFirstResponder];

}else if([textField isEqual:_txtThirdDigit]) {
    [_txtSecondDigit becomeFirstResponder];

}else if([textField isEqual:_txtFourthDigit]) {
    [_txtThirdDigit becomeFirstResponder];
}
return YES;
}   

formattazione migliorata

Ho implementato la soluzione simile con piccoli miglioramenti che mi diranno che se il campo di testo ha qualche valore mentre l'utente ha toccato il backspace. Questo è utile per il mio caso quando dovrei concentrarmi su un altro campo di testo se il campo di testo è vuoto quando viene premuto backspace.

protocol MyTextFieldDelegate : UITextFieldDelegate {
    func textFieldDidDelete(textField: MyTextField, hasValue: Bool)
}

override func deleteBackward() {
    let currentText = self.text ?? ""
    super.deleteBackward()
    let hasValue = currentText.isEmpty ? false : true
    if let delegate = self.delegate as? MyTextFieldDelegate {
        delegate.textFieldDidDelete(textField: self, hasValue: hasValue)
    }
}

La risposta alla maggior parte dei pioppi manca di una cosa: la capacità di rilevare se il campo di testo era vuoto o meno.

Cioè, quando si sovrascrive il metodo deleteBackwards () di una sottoclasse TextField, non si sa ancora se il campo di testo era già vuoto. (Sia prima che dopo deleteBackwards (), textField.text!è una stringa vuota:"" )

Ecco il mio miglioramento, con un controllo del vuoto prima della cancellazione.

1. Creare un protocollo delegato che estende UITextFieldDelegate

protocol MyTextFieldDelegate: UITextFieldDelegate {
    func textField(_ textField: UITextField, didDeleteBackwardAnd wasEmpty: Bool)
}

2. Sottoclasse UITextField

class MyTextField: UITextField {
    override func deleteBackward() {
        // see if text was empty
        let wasEmpty = text == nil || text! == ""

        // then perform normal behavior
        super.deleteBackward()

        // now, notify delegate (if existent)
        (delegate as? MyTextFieldDelegate)?.textField(self, didDeleteBackwardAnd: wasEmpty)
    }
}

3. Implementa il tuo nuovo protocollo delegato

extension MyViewController: MyTextFieldDelegate {
    func textField(_ textField: UITextField, didDeleteBackwardAnd wasEmpty: Bool) {
        if wasEmpty {
            // do what you want here...
        }
    }
}

Gestore completo per il campo di testo con numero a una cifra per Swift 5.1 :

• Supponendo di disporre di una raccolta di outlet di campi di testo (anche con delegati connessi)

1 passaggio

protocol MyTextFieldDelegate: class {
    func textField(_ textField: UITextField, didDeleteBackwardAnd wasEmpty: Bool) 
}

final class MyTextField: UITextField {

    weak var myDelegate: MyTextFieldDelegate?

    override func deleteBackward() {
        let wasEmpty = text == nil || text == ""

        // then perform normal behavior
        super.deleteBackward()

        // now, notify delegate (if existent)
        (delegate as? MyTextFieldDelegate)?.textField(self, didDeleteBackwardAnd: wasEmpty)
    }
}

2 passaggi

final class ViewController: UIViewController {

    @IBOutlet private var textFields: [MyTextField]!

    override func viewDidLoad() {
        super.viewDidLoad()
        textFields.forEach {
            $0.delegate = self
            $0.myDelegate = self
        }
    }
}

3 passaggi

extension ViewController: UITextFieldDelegate, MyTextFieldDelegate {
    func textFieldHasChanged(with text: String, _ tag: Int, for textField: UITextField) {
        textField.text = text

        if let someTextField = (textFields.filter { $0.tag == tag }).first {
            someTextField.becomeFirstResponder()
        } else {
            view.endEditing(true)
        }
    }

    func textField(_ textField: UITextField, didDeleteBackwardAnd wasEmpty: Bool) {
        // If the user was pressing backward and the value was empty, go to previous textField
        textFieldHasChanged(with: "", textField.tag - 1, for: textField)
    }

    func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
        // Restrict to only digits
        let aSet = NSCharacterSet(charactersIn: "0123456789").inverted
        let compSepByCharInSet = string.components(separatedBy: aSet)
        let numberFiltered = compSepByCharInSet.joined(separator: "")

        guard string == numberFiltered, let text = textField.text else { return false }

        if text.count >= 1 && string.isEmpty {
            // If the user is deleting the value
            textFieldHasChanged(with: "", textField.tag - 1, for: textField)
        } else {
            textFieldHasChanged(with: string, textField.tag + 1, for: textField)
        }

        return false
    }
}

Ecco la mia soluzione basata sull'idea di @andrew:

da qualche parte, ad esempio in viewDidLoad

        textField.delegate = self
        textField.addTarget(self, action: #selector(valueChanged(_:)), for: .editingDidBegin)

e poi

    @objc func valueChanged(_ textField: UITextField) {
        textField.text = "\u{200B}"
    }

    override func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
        textField.text = string
        if string == "" {
            //backpaspace pressed 
        }

Puoi controllare il testo della vista / campo del testo per vedere se è vuoto e assicurarti che anche il testo sostitutivo sia vuoto nel metodo delegato shouldChangeTextIn.

func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
    if (textView.text == "" && text == "") {
        print("Backspace on empty text field.")
    }
    return true
}

Qualcosa come questo:

- (BOOL)textField:(UITextField *)textField 
        shouldChangeCharactersInRange:(NSRange)range 
        replacementString:(NSString *)string       
{  
    if (![text hash] && ![textField.text length])  
        [self backspaceInEmptyTextField];  
}

ovviamente l'hash è per una stringa di caratteri.

Utilizzando il metodo Delegato TextField:

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

Aggiungi il seguente codice nel metodo sopra per rilevare l'evento di eliminazione

if(textField == YourTextField)
{
    if ([string length] == 0 && range.length > 0)
    {
        // Your Code after deletion of character
    }
}

Per mantenerlo semplice qui è l'unica condizione che devi controllare

     if (range.length==1)

+ (BOOL)detectBackspaceOnly:(NSString *)string
{
    for(int i=0 ; i<string.length ; i++){
        unichar caract = [string characterAtIndex:i];
        if(caract != ' ' && caract != '\n')
            return NO;
    }

    return YES;
}

In UITextViewDelegate:

- (BOOL)               textView:(UITextView *)textView 
        shouldChangeTextInRange:(NSRange)range 
                replacementText:(NSString *)text
{
    if(text isEqualToString:@"");
    {
        NSLog(@"press backspace.");
    }
}

funziona bene per me.

aggiornamento per pinyin cinese semplificato e input per la scrittura cinese:

- (BOOL)               textView:(UITextView *)textView 
        shouldChangeTextInRange:(NSRange)range 
                replacementText:(NSString *)text
{
    if (range.length > 0 && [text isEqualToString:@""]) {
        NSLog(@"press Backspace.");
    }
    return YES;
}

base sul documento dice:

"Se l'utente preme il tasto deleteKey, la lunghezza dell'intervallo è 1 e un oggetto stringa vuoto sostituisce quel singolo carattere."