Existe-t-il un moyen de détecter lorsque la touche Backspace/ Deleteest enfoncée dans le clavier de l'iPhone sur un UITextFieldqui est vide? Je veux savoir quand Backspaceest pressé seulement si le UITextFieldest vide.

Sur la base de la suggestion de @Alex Reynolds dans un commentaire, j'ai ajouté le code suivant lors de la création de mon champ de texte:

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

Cette notification est reçue (la handleTextFieldChangedfonction est appelée), mais toujours pas lorsque j'appuie sur la Backspacetouche dans un champ vide. Des idées?

Il semble y avoir une certaine confusion autour de cette question. Je souhaite recevoir une notification lorsque la Backspacetouche est enfoncée. C'est tout. Mais la solution doit également fonctionner lorsque le UITextFieldest déjà vide.

Cela peut être long, mais cela pourrait fonctionner. Essayez de définir le texte du champ de texte sur un caractère d'espace de largeur zéro \u200B. Lorsque vous appuyez sur Retour arrière sur un champ de texte qui apparaît vide, cela supprimera votre espace. Ensuite, vous pouvez simplement réinsérer l'espace.

Peut ne pas fonctionner si l'utilisateur parvient à déplacer le curseur vers la gauche de l'espace.

Swift 4:

Sous UITextField- classe :

// MyTextField.swift
import UIKit

protocol MyTextFieldDelegate: AnyObject {
    func textFieldDidDelete()
}

class MyTextField: UITextField {

    weak var myDelegate: MyTextFieldDelegate?

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

}

La mise en oeuvre:

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

}

Objectif c:

Sous UITextField- classe :

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

Maintenant, ajoutez simplement MyTextFieldDelegate à votre UIViewControlleret définissez votre UITextFields myDelegate sur 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");
}

Mise à jour: voir la réponse de JacobCaraballo pour un exemple qui remplace -[UITextField deleteBackward].

Check out UITextInput, a spécifiquement UIKeyInputune deleteBackwardméthode de délégué qui est toujours appelée lorsque la touche de suppression est enfoncée. Si vous faites quelque chose de simple, vous pouvez envisager de simplement sous-classer UILabelet de le rendre conforme au UIKeyInputprotocole, comme le font SimpleTextInput et cet exemple d'iPhone UIKeyInput . Remarque: UITextInputet ses proches (y compris UIKeyInput) ne sont disponibles que dans iOS 3.2 et versions ultérieures.

Code comme suit:

@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

Enfin, n'oubliez pas de modifier la propriété Classe personnalisée du champ de texte en "MyTextField"

Mise en œuvre rapide:

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

J'ai fondé une autre manière plus simple que la subclasssolution. Même c'est un peu étrange mais ça marche bien.

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

C'est un peu étrange car le résultat de la comparaison est de -8. Peut-être que je me trompe à un moment donné C Programming. Mais son bon travail;)

Essaie le delegate

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

Ensuite, vérifiez si le range.length == 1qui semble être le cas quand backspaceest frappé.

Veuillez utiliser le code ci-dessous, il vous aidera à détecter la touche de suppression du clavier même si votre champ de texte est vide.

Objectif c :

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

Rapide :

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

La réponse de Niklas Alvaeus m'a aidé avec un problème similaire

Je limitais l'entrée à un jeu de caractères spécifique, mais j'ignorais les espaces arrière. Je l'ai donc fait vérifier range.length == 1avant de couper le fichier NSString. Si c'est vrai, je renvoie simplement la chaîne et je ne la coupe pas. Voir ci-dessous

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

Pour ceux qui ont des problèmes avec la réponse de Jacob, j'ai implémenté ma sous-classe textfield comme suit et cela fonctionne très bien!

#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

Oui, utilisez la méthode ci-dessous pour détecter le retour arrière, lorsque textField est vide.

Besoin d'ajouter UITextFieldDelegate

yourTextField.delegate = self (DOIT REQUIS)

Rapide:

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

Objectif c:

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

La meilleure utilisation que j'ai trouvée pour détecter le retour arrière est de détecter lorsque l'utilisateur a appuyé sur retour arrière dans un vide UITextField. Par exemple, si vous avez des destinataires «en bulles» dans l'application de messagerie, lorsque vous appuyez sur retour arrière dans le UITextField, il sélectionne le dernier destinataire «en bulles».

Cela peut être fait de la même manière que la réponse de Jacob Caraballo. Mais dans la réponse de Jacob, s'il UITextFieldreste un caractère lorsque vous appuyez sur retour arrière, au moment où le message du délégué est reçu, le UITextFieldsera déjà vide, de sorte que vous détectez efficacement backspacesur un champ de texte avec au plus un caractère.

En fait, si vous voulez détecter backspacesur un UITextFieldavec exactement zéro caractère (vide), vous devez envoyer le message au delegateavant l'appel à super deleteBackward. Par exemple:

#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'interface d'un tel champ de texte ressemblerait à ceci:

@protocol MyTextFieldDelegate;

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

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

Dans iOS 6, la méthode deleteBackward est appelée sur UITextField lorsque vous appuyez sur Retour arrière, y compris lorsque le champ est vide. Vous pouvez donc sous-classer UITextField et fournir votre propre implémentation de deleteBackward (en invoquant également les super.)

Je supporte toujours iOS 5, donc j'aurai besoin d'une combinaison de la réponse d'Andrew et celle-ci.

:) juste pour le titre "Détecter le retour arrière", où j'utilise UIKeyboardTypeNumberPad.

Je rencontre également la même question ce soir, et voici mon code pour le découvrir:

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

Parce qu'avec UIKeyboardTypeNumberPad, l'utilisateur ne peut entrer que Number ou Backspace, donc lorsque la longueur de la chaîne est 0, il doit s'agir d'une touche de retour arrière.

J'espère que ce qui précède vous aidera.

Plutôt que d'essayer de préconstruire ce qui SERA dans le champ de texte ou de déterminer quel caractère spécial a été entré dans la shouldChangeCharactersInRangeméthode, je suggérerais de faire ce qui suit:

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

Cela vous permet d'appeler une méthode directement après la fin de l'opération en cours. Ce qui est cool à ce sujet, c'est que, au moment où il se termine, la valeur modifiée sera déjà dans le fichier UITextField. À ce stade, vous pouvez simplement vérifier sa longueur et / ou valider en fonction de ce qu'il y a.

Le sous-classement UITextField ne fonctionnait pas pour moi sur iOS 8.3, deleteBackward n'a jamais été appelé.

Voici la solution que j'ai utilisée, fonctionne sur toutes les versions d'iOS 8 et devrait également fonctionner sur d'autres versions d'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
}

Dans le fichier .h, ajoutez un délégué 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;
}   

Formatage amélioré

J'ai implémenté la solution similaire avec des améliorations mineures qui me diront que si le champ de texte a une valeur alors que l'utilisateur a tapé sur le retour arrière. Ceci est utile dans mon cas lorsque je ne devrais me concentrer sur un autre champ de texte que si le champ de texte est vide lorsque vous appuyez sur Retour arrière.

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 réponse la plus peuplée manque une chose - la capacité de détecter si le champ de texte était vide ou non.

Autrement dit, lorsque vous remplacez la méthode deleteBackwards () d'une sous-classe TextField, vous ne savez toujours pas si le champ de texte était déjà vide. (Avant et après deleteBackwards (), textField.text!est une chaîne vide: "")

Voici mon amélioration, avec un contrôle de la vacuité avant la suppression.

1. Créez un protocole délégué qui étend UITextFieldDelegate

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

2. Sous-classe 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. Implémentez votre nouveau protocole de délégué

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

Gestionnaire complet pour champ de texte avec numéro à un chiffre pour Swift 5.1 :

• En supposant que vous ayez une collection de sortie de textFields (avec des délégués connectés également)

1 étape

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 étape

final class ViewController: UIViewController {

    @IBOutlet private var textFields: [MyTextField]!

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

3 étape

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

Voici ma solution basée sur l'idée @andrew:

quelque part, par exemple dans viewDidLoad

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

puis

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

Vous pouvez vérifier le texte de la vue / du champ de texte pour voir s'il est vide et vous assurer que le texte de remplacement est également vide dans la méthode déléguée shouldChangeTextIn.

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

Quelque chose comme ça:

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

bien sûr, le hachage est pour une chaîne de caractères.

À l'aide de la méthode TextField Delegate:

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

Ajoutez le code suivant dans la méthode ci-dessus pour détecter l'événement de suppression

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

Pour garder les choses simples, voici la seule condition que vous devez vérifier

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

Dans UITextViewDelegate:

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

ça marche bien pour moi.

mise à jour pour le pinyin simplifié chinois et la saisie manuscrite chinoise:

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

base sur le document dit:

"Si l'utilisateur appuie sur deleteKey, la longueur de la plage est de 1 et un objet chaîne vide remplace ce caractère unique."