Existe alguma maneira de detectar quando a tecla Backspace/ Deleteé pressionada no teclado do iPhone em um UITextFieldque está vazio? Quero saber quando Backspaceé pressionado apenas se o UITextFieldestiver vazio.

Com base na sugestão de @Alex Reynolds em um comentário, adicionamos o seguinte código ao criar meu campo de texto:

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

Essa notificação é recebida (a handleTextFieldChangedfunção é chamada), mas ainda não é quando pressiono a Backspacetecla em um campo vazio. Alguma ideia?

Parece haver alguma confusão em torno dessa questão. Quero receber uma notificação quando a Backspacetecla for pressionada. É isso aí. Mas a solução também deve funcionar quando a UITextFieldjá estiver vazia.

Isso pode ser um tiro no escuro, mas pode funcionar. Tente definir o texto do campo de texto como um caractere de espaço com largura zero \u200B. Quando o backspace é pressionado em um campo de texto que parece vazio, na verdade ele exclui seu espaço. Então você pode apenas reinserir o espaço.

Pode não funcionar se o usuário conseguir mover o cursor para a esquerda do espaço.

Swift 4:

Subclasse UITextField:

// MyTextField.swift
import UIKit

protocol MyTextFieldDelegate: AnyObject {
    func textFieldDidDelete()
}

class MyTextField: UITextField {

    weak var myDelegate: MyTextFieldDelegate?

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

}

Implementação:

// 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")
    }

}

Objetivo-C:

Subclasse 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

Agora basta adicionar MyTextFieldDelegate ao seu UIViewControllere defina seu UITextFields myDelegate como 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");
}

Atualização: Veja a resposta de JacobCaraballo para um exemplo que substitui -[UITextField deleteBackward].

Confira UITextInput, especificamente, UIKeyInputtem um deleteBackwardmétodo delegado que sempre é chamado quando a tecla Delete é pressionada. Se você estiver fazendo algo simples, considere apenas subclassificar UILabele torná-lo em conformidade com o UIKeyInputprotocolo, conforme feito por SimpleTextInput e por este exemplo de UIKeyInput do iPhone . Nota: UITextInpute seus parentes (inclusive UIKeyInput) estão disponíveis apenas no iOS 3.2 e posterior.

Código como a seguir:

@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

Por fim, esqueça de alterar a propriedade Custom Class do campo de texto para "MyTextField"

Implementação rápida:

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)
        }
    }
}

Eu fundei de outra maneira mais fácil do que subclasssolução. Mesmo um pouco estranho, mas funciona bem.

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

É um pouco estranho, pois o resultado da comparação é -8. Talvez eu esteja errado em algum momento C Programming. Mas o seu trabalho certo;)

Tente o delegate

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

Em seguida, verifique se o range.length == 1que parece ser o caso quando backspaceé atingido.

use o código abaixo para ajudá-lo a detectar a tecla de exclusão do teclado, mesmo se o campo de texto estiver vazio.

Objetivo C:

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

Rápido :

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

A resposta de Niklas Alvaeus me ajudou com um problema semelhante

Eu estava limitando a entrada para um conjunto de caracteres específico, mas estava ignorando os backspaces. Então eu tive que verificar range.length == 1antes de aparar o NSString. Se for verdade, eu apenas retorno a string e não a corto. Ver abaixo

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

Para quem tem problemas com a resposta de Jacob, implementei minha subclasse de campo de texto da seguinte maneira e funciona muito bem!

#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

Sim, use o método abaixo para detectar backspace, quando textField estiver vazio.

Precisa adicionar UITextFieldDelegate

yourTextField.delegate = self (DEVE NECESSÁRIO)

Rápido:

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

Objetivo C:

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

O melhor uso que encontrei para detectar o backspace é detectar quando o usuário pressionou o backspace em um vazio UITextField. Por exemplo, se você tiver 'borbulhado' nos destinatários do aplicativo de email, ao pressionar backspace no UITextField, ele selecionará o último destinatário 'borbulhado'.

Isso pode ser feito de maneira semelhante à resposta de Jacob Caraballo. Mas na resposta de Jacob, se UITextFieldhouver um caractere quando você pressionar backspace, no momento em que a mensagem do delegado for recebida, UITextFieldela já estará vazia, então você estará efetivamente detectando backspaceem um campo de texto com no máximo um caractere.

Na verdade, se você deseja detectar backspaceem um UITextFieldcom exatamente zero caracteres (vazio), envie a mensagem para delegateantes da chamada super deleteBackward. Por exemplo:

#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

A interface para esse campo de texto seria algo como isto:

@protocol MyTextFieldDelegate;

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

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

No iOS 6, o método deleteBackward é chamado no UITextField quando o backspace é pressionado, inclusive quando o campo está vazio. Assim, você pode subclassificar UITextField e fornecer sua própria implementação deleteBackward (invocando super's também.)

Ainda estou suportando o iOS 5, portanto, precisarei de uma combinação da resposta de Andrew e isso.

:) apenas para o título "Detectar backspace", onde eu uso UIKeyboardTypeNumberPad.

Também encontro a mesma pergunta hoje à noite, e a seguir está o meu código para descobrir:

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

Como com UIKeyboardTypeNumberPad, o usuário pode inserir apenas Number ou backspace; portanto, quando o comprimento da string for 0, ele deverá ser a chave de backspace.

Espero que o acima faça alguma ajuda.

Em vez de tentar pré-construir o que VAI SER no campo de texto ou descobrir qual caractere especial foi inserido no shouldChangeCharactersInRangemétodo, sugiro fazer o seguinte:

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

Isso permite que você chame um método diretamente após a conclusão da operação atual. O que é interessante sobre isso é que, quando terminar, o valor modificado já estará no UITextField. Nesse ponto, você pode apenas verificar seu comprimento e / ou validar com base no que está lá.

Subclassificar UITextField não funcionou para mim no iOS 8.3, deleteBackward nunca foi chamado.

Aqui está a solução que usei, funciona em todas as versões do iOS 8 e também em outras versões do 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
}

No arquivo .h, adicione o delegado 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;
}   

Formatação aprimorada

Eu implementei a solução semelhante com pequenas melhorias que me dirão que, se o campo de texto tiver algum valor enquanto o usuário tocar no backspace. Isso é útil para o meu caso, quando devo focar apenas em outro campo de texto se o campo de texto estiver vazio quando o backspace for pressionado.

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)
    }
}

A resposta mais poplar está faltando uma coisa - a capacidade de detectar se o campo de texto estava vazio ou não.

Ou seja, quando você substitui o método deleteBackwards () de uma subclasse TextField, ainda não sabe se o campo de texto já estava vazio. (Antes e depois de deleteBackwards (), textField.text!é uma sequência vazia:"" )

Aqui está a minha melhoria, com uma verificação do vazio antes da exclusão.

1. Crie um protocolo de delegação que estenda UITextFieldDelegate

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

2. Subclasse 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. Implemente seu novo protocolo de delegação

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

Manipulador abrangente para campo de texto com número de um dígito para o Swift 5.1 :

• Supondo que você tenha uma coleção de saída de textFields (também com delegados conectados)

1 passo

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 Etapa

final class ViewController: UIViewController {

    @IBOutlet private var textFields: [MyTextField]!

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

3 Etapa

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

Aqui minha solução baseada na idéia @andrew:

em algum lugar, por exemplo, em viewDidLoad

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

e depois

    @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 
        }

Você pode verificar o texto da visualização / campo de texto para ver se está vazio e garantir que o texto de substituição também esteja vazio no método delegado shouldChangeTextIn.

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

Algo assim:

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

é claro que o hash é para uma sequência de caracteres.

Usando o método TextField Delegate:

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

Adicione o seguinte código no método acima para detectar o evento de exclusão

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

Para simplificar, aqui está a única condição que você precisa verificar

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

Em UITextViewDelegate:

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

funciona bem para mim.

atualização para pinyin simplificado chinês e entrada de caligrafia chinesa:

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

base no documento diz:

"Se o usuário pressionar o deleteKey, o comprimento do intervalo será 1 e um objeto de string vazio substituirá esse caractere único."