Это может быть маловероятно, но это может сработать. Попробуйте установить для текста текстового поля символ пробела нулевой ширины \u200B. Когда клавиша Backspace нажимается в текстовом поле, которое кажется пустым, оно фактически удаляет ваше пространство. Затем вы можете просто вставить пробел заново.

Может не работать, если пользователю удастся переместить курсор влево от места.

Swift 4:

Подкласс UITextField:

// MyTextField.swift
import UIKit

protocol MyTextFieldDelegate: AnyObject {
    func textFieldDidDelete()
}

class MyTextField: UITextField {

    weak var myDelegate: MyTextFieldDelegate?

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

}

Реализация:

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

}

Цель-C:

Подкласс 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

Теперь просто добавьте MyTextFieldDelegate в свой UIViewController и установите для UITextFields myDelegate значение 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");
}

Обновление: см. ответ Джейкоба Карабалло для примера, который отменяет -[UITextField deleteBackward].

Ознакомьтесь с UITextInput, в частности _ 3_ имеет _ 4_ метод делегата, который всегда вызывается при нажатии клавиши удаления. Если вы делаете что-то простое, вы можете просто создать подкласс UILabel и привести его в соответствие с протоколом UIKeyInput, как это сделано с помощью SimpleTextInput и этот Пример iPhone UIKeyInput. Примечание. UITextInput и его родственники (включая UIKeyInput) доступны только в iOS 3.2 и новее.

Код, подобный следующему:

@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

Наконец, не забудьте изменить свойство Custom Class текстового поля на MyTextField.

Быстрая реализация:

import UIKit

// Extend from PinTextFieldDelegate instead of UITextFieldDelegate in your class
protocol PinTextFieldDelegate : 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? PinTextFieldDelegate {
            pinDelegate.didPressBackspace(self)
        }
    }
}

Я нашел другой способ проще, чем subclass решение. Даже немного странно, но работает нормально.

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

Немного странно, результат сравнения -8. Может я ошибаюсь в каком-то пункте C Programming. Но его правильная работа;)

Попробуйте delegate

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

Затем проверьте, есть ли range.length == 1, который, кажется, имеет место при попадании в backspace.

пожалуйста, используйте приведенный ниже код, это поможет вам обнаружить клавишу удаления клавиатуры, даже если текстовое поле пусто.

Цель C:

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

Swift:

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

Ответ Никласа Альвеуса помог мне с аналогичной проблемой

Я ограничивал ввод определенным набором символов, но игнорировал обратные пробелы. Поэтому я попросил его проверить range.length == 1 перед обрезкой NSString. Если это правда, я просто возвращаю строку и не обрезаю ее. См. ниже

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

Для тех, у кого есть проблемы с ответом Джейкоба, я реализовал свой подкласс текстового поля следующим образом, и он отлично работает!

#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

Да, используйте метод ниже, чтобы обнаружить обратное пространство, когда textField пуст.

Необходимо добавить UITextFieldDelegate

yourTextField.delegate = self (ОБЯЗАТЕЛЬНО ТРЕБУЕТСЯ)

Swift:

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

Цель C:

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

Лучшее использование, которое я нашел для обнаружения обратного пространства, - это обнаружение, когда пользователь нажимает обратное пространство в пустом UITextField. Например, если у вас есть «пузырьковые» получатели в почтовом приложении, когда вы нажимаете backspace в UITextField, он выбирает последнего «пузырькового» получателя.

Это можно сделать аналогично ответу Джейкоба Карабальо. Но в ответе Джейкоба, если у UITextField остался один символ, когда вы нажмете backspace, к моменту получения сообщения делегата UITextField уже будет пустым, поэтому вы эффективно обнаруживаете backspace в текстовом поле с не более чем одним символом.

Фактически, если вы хотите обнаружить backspace на UITextField с ровно нулевыми символами (пустыми), вы должны отправить сообщение на delegate перед вызовом super deleteBackward. Например:

#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

Интерфейс такого текстового поля будет выглядеть примерно так:

@protocol MyTextFieldDelegate;

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

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

В iOS 6 метод deleteBackward вызывается в UITextField при нажатии клавиши Backspace, в том числе при пустом поле. Таким образом, вы можете создать подкласс UITextField и предоставить свою собственную реализацию deleteBackward (также вызывая super).

Я все еще поддерживаю iOS 5, поэтому мне понадобится комбинация ответа Эндрю и этого.

:) просто для заголовка "Обнаружить обратное пространство", где я использую UIKeyboardTypeNumberPad.

Сегодня вечером я также встречу тот же вопрос, и вот мой код, чтобы узнать его:

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

Поскольку с UIKeyboardTypeNumberPad пользователь может вводить только Number или backspace, поэтому, когда длина строки равна 0, это должна быть клавиша backspace.

Надеюсь, это поможет.

Вместо того, чтобы пытаться заранее сконструировать, что БУДЕТ в текстовом поле, или выяснить, какой специальный символ был введен в метод shouldChangeCharactersInRange, я бы предложил сделать следующее:

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

Это позволяет вызывать метод сразу после завершения текущей операции. Что в этом круто, так это то, что к моменту его завершения измененное значение уже будет в UITextField. На этом этапе вы можете просто проверить его длину и / или подтвердить, исходя из того, что там есть.

Создание подклассов UITextField у меня не сработало на iOS 8.3, deleteBackward никогда не вызывался.

Вот решение, которое я использовал, работает на всех версиях iOS 8 и также должно работать на других версиях 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
}

В файле .h добавьте делегата 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;
}   

улучшенное форматирование

Я реализовал аналогичное решение с небольшими улучшениями, которые сообщают мне, имеет ли текстовое поле какое-либо значение, когда пользователь нажал на обратное пространство. Это полезно для моего случая, когда мне нужно сосредоточиться только на другом текстовом поле, если текстовое поле пусто при нажатии клавиши 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)
    }
}

Самый популярный ответ упускает одну вещь - способность определять, было ли текстовое поле пустым или нет.

То есть, когда вы переопределяете метод deleteBackwards () подкласса TextField, вы все равно не знаете, было ли текстовое поле уже пустым. (И до, и после deleteBackwards () textField.text! является пустой строкой: "")

Вот мое улучшение с проверкой на пустоту перед удалением.

1. Создайте протокол делегата, расширяющий UITextFieldDelegate

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

2. Подкласс 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. Внедрите новый протокол делегата.

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

Комплексный обработчик текстового поля с однозначным номером для Swift 5.1:

• Предполагая, что у вас есть выходная коллекция текстовых полей (также с подключенными делегатами)

1 шаг

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 шаг

final class ViewController: UIViewController {

    @IBOutlet private var textFields: [MyTextField]!

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

3 шаг

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

Вот мое решение, основанное на идее @andrew:

где-нибудь например в viewDidLoad

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

а потом

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

Все ответы очень полезны, и я не знаю, почему все идут по протоколу. Вы можете сделать это с гораздо меньшим количеством кода с функцией обратного вызова, например:

Swift 5.0 или выше

1. Создайте собственный класс текстового поля, расширяющий UITextField, и переопределите функцию deleteBackward -

   class CustomTextField: UITextField {

    var backButtonPressedInEmptyTextField: (()->())?
   
    override func deleteBackward() {
        super.deleteBackward()
        if let text = self.text, text.count == 0{
            backButtonPressedInEmptyTextField?()
            print("Back space clicked when textfield is empty")
        }
    }
   

   }

2. Предположим, вы хотите что-то сделать на основе этого в вашем ViewController, MyViewController. Итак, в MyViewController просто сделайте следующее:

   class MyViewController: UIViewController {@IBOutlet weak var sampleTextField: CustomTextField! {didSet {sampleTextField.backButtonPressedInEmptyTextField = backButtonPressed ()}}

    func backButtonPressed(){
        //do whatever you want
    }
   

   }

Я чувствую, что с функцией закрытия или обратного вызова она намного чище.

Что-то вроде этого:

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

конечно, хеш для одной символьной строки.

Используя метод делегата TextField:

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

Добавьте следующий код в метод выше, чтобы обнаружить событие удаления

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

Вы можете проверить текст текстового представления / поля, чтобы убедиться, что он пуст, и убедиться, что замещающий текст также пуст в методе делегата shouldChangeTextIn.

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

Чтобы не усложнять, вот единственное условие, которое вам нужно проверить

     if (range.length==1)

In UITextViewDelegate:

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

у меня работает нормально.

обновление для упрощенного китайского пиньинь и китайского рукописного ввода:

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

на основании документа сказано:

«Если пользователь нажимает deleteKey, длина диапазона равна 1, и пустой строковый объект заменяет этот единственный символ».