2017

Grudzień 2017. Swift 4.

Cały przykładowy kod jest bardzo Nieaktualny.

Wystarczy wkleić następujące elementy do dowolnego pliku Swift w projekcie. (Możesz nazwać plik dowolną nazwą, na przykład " Handy.swift")

Twoje pola tekstowe mają teraz .maxLength.

Jest całkowicie OK, aby ustawić tę wartość w storyboard, lub ustawić ją w kod.

// simply have this in a file called, say, Handy.swift or TextUtility.swift

import UIKit
private var __maxLengths = [UITextField: Int]()
extension UITextField {
    @IBInspectable var maxLength: Int {
        get {
            guard let l = __maxLengths[self] else {
               return 150 // (global default-limit. or just, Int.max)
            }
            return l
        }
        set {
            __maxLengths[self] = newValue
            addTarget(self, action: #selector(fix), for: .editingChanged)
        }
    }
    func fix(textField: UITextField) {
        let t = textField.text
        textField.text = t?.safelyLimitedTo(length: maxLength)
    }
}

extension String
    {
    func safelyLimitedTo(length n: Int)->String {
        if (self.count <= n) {
            return self
        }
        return String( Array(self).prefix(upTo: n) )
    }
}

(Uwaga: "safelylimited to # length" jest tylko wywołaniem, które przycina Długość Łańcucha. Prawie wszyscy programiści Swift mają do tego swoją własną funkcję, lub możesz po prostu użyć mojej.)

Tylko BTW, oto podobna, niezwykle przydatna wskazówka dotycząca UIText View , https://stackoverflow.com/a/42333832/294884

Ponieważ ten problem jest tak niewiarygodnie irytujące:

Często potrzebujesz tylko jednego konkretnego specjalnego pola tekstowego, które jest po prostu ograniczone ("i to wszystko!") do pewnej długości.

Na przykład kod pin to cztery znaki i tyle.

To takie proste:

class PinCodeEntry: UITextField {

    override func didMoveToSuperview() {

        super.didMoveToSuperview()
        addTarget(self, action: #selector(fixMe), for: .editingChanged)
    }

    @objc private func fixMe() { text = text?.safelyLimitedTo(length 4) }
}

Uff! To wszystko.

Tak samo jak zrobił to Steven Schmatz, ale używając Swift 3.0 :

//max Length
func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange,
               replacementString string: String) -> Bool
{
    let maxLength = 4
    let currentString: NSString = textField.text! as NSString
    let newString: NSString = currentString.replacingCharacters(in: range, with: string) as NSString
    return newString.length <= maxLength
}

Myślę, że rozszerzenie jest bardziej przydatne do tego. Zobacz pełną odpowiedź Tutaj

private var maxLengths = [UITextField: Int]()

// 2
extension UITextField {

  // 3
  @IBInspectable var maxLength: Int {
    get {
      // 4
      guard let length = maxLengths[self] else {
        return Int.max
      }
      return length
    }
    set {
      maxLengths[self] = newValue
      // 5
      addTarget(
        self,
        action: #selector(limitLength),
        forControlEvents: UIControlEvents.EditingChanged
      )
    }
  }

  func limitLength(textField: UITextField) {
    // 6
    guard let prospectiveText = textField.text
      where prospectiveText.characters.count > maxLength else {
        return
    }

    let selection = selectedTextRange
    // 7
    text = prospectiveText.substringWithRange(
      Range<String.Index>(prospectiveText.startIndex ..< prospectiveText.startIndex.advancedBy(maxLength))
    )
    selectedTextRange = selection
  }

}

Ta odpowiedź jest dla Swift 4 i jest dość prosta z możliwością przepuszczenia backspace.

func textField(_ textField: UITextField, 
               shouldChangeCharactersIn range: NSRange, 
               replacementString string: String) -> Bool {
    return textField.text!.count < 10 || string == ""
}

Mam coś do dodania do odpowiedzi Aladyna:

1. Twój kontroler widoku powinien być zgodny z UITextFieldDelegate

   class MyViewController: UIViewController, UITextViewDelegate {
   
   }
   

2. Ustaw delegata pola tekstowego: Aby ustawić delegata, można sterować przeciąganiem z pola tekstowego do kontrolera widoku w storyboardzie. Myślę, że jest to lepsze niż ustawienie go w kodzie

3. Zaimplementuj metodę w kontrolerze widoku: textField(_:shouldChangeCharactersInRange:replacementString:)

Inne rozwiązania zamieszczone powyżej powodują cykl zachowywania ze względu na mapę pola tekstowego. Poza tym Właściwość maxLength powinna być nullable, jeśli nie jest ustawiona zamiast sztucznych konstrukcji Int.max; a cel zostanie ustawiony wiele razy, jeśli zmieni się maxLength.

Tutaj zaktualizowano rozwiązanie dla Swift4 ze słabą mapą, aby zapobiec wyciekom pamięci i innym poprawkom

private var maxLengths = NSMapTable<UITextField, NSNumber>(keyOptions: NSPointerFunctions.Options.weakMemory, valueOptions: NSPointerFunctions.Options.strongMemory)

extension UITextField {

    var maxLength: Int? {
        get {
            return maxLengths.object(forKey: self)?.intValue
        }
        set {
            removeTarget(self, action: #selector(limitLength), for: .editingChanged)
            if let newValue = newValue {
                maxLengths.setObject(NSNumber(value: newValue), forKey: self)
                addTarget(self, action: #selector(limitLength), for: .editingChanged)
            } else {
                maxLengths.removeObject(forKey: self)
            }
        }
    }

    @IBInspectable var maxLengthInspectable: Int {
        get {
            return maxLength ?? Int.max
        }
        set {
            maxLength = newValue
        }
    }

    @objc private func limitLength(_ textField: UITextField) {
        guard let maxLength = maxLength, let prospectiveText = textField.text, prospectiveText.count > maxLength else {
            return
        }
        let selection = selectedTextRange
        text = String(prospectiveText[..<prospectiveText.index(from: maxLength)])
        selectedTextRange = selection
    }
}

Swift 4, wystarczy użyć:

public func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    return range.location < 10
}

Udzielam dodatkowej odpowiedzi na podstawie @Frouo. Myślę, że jego odpowiedź jest najpiękniejsza. Ponieważ to wspólna kontrola, którą możemy użyć ponownie. I nie ma tu problemu z wyciekiem.

    private var kAssociationKeyMaxLength: Int = 0

    extension UITextField {

        @IBInspectable var maxLength: Int {
            get {
                if let length = objc_getAssociatedObject(self, &kAssociationKeyMaxLength) as? Int {
                    return length
                } else {
                    return Int.max
                }
            }
            set {
                objc_setAssociatedObject(self, &kAssociationKeyMaxLength, newValue, .OBJC_ASSOCIATION_RETAIN)
                self.addTarget(self, action: #selector(checkMaxLength), for: .editingChanged)
            }
        }

//The method is used to cancel the check when use Chinese Pinyin input method.
        //Becuase the alphabet also appears in the textfield when inputting, we should cancel the check.
        func isInputMethod() -> Bool {
            if let positionRange = self.markedTextRange {
                if let _ = self.position(from: positionRange.start, offset: 0) {
                    return true
                }
            }
            return false
        }


        func checkMaxLength(textField: UITextField) {

            guard !self.isInputMethod(), let prospectiveText = self.text,
                prospectiveText.count > maxLength
                else {
                    return
            }

            let selection = selectedTextRange
            let maxCharIndex = prospectiveText.index(prospectiveText.startIndex, offsetBy: maxLength)
            text = prospectiveText.substring(to: maxCharIndex)
            selectedTextRange = selection
        }



    }

Proste rozwiązanie bez użycia delegata:

TEXT_FIELD.addTarget(self, action: #selector(editingChanged(sender:)), for: .editingChanged)


@objc private func editingChanged(sender: UITextField) {

        if let text = sender.text, text.count >= MAX_LENGHT {
            sender.text = String(text.dropLast(text.count - MAX_LENGHT))
            return
        }
}

Oto alternatywa Swift 3.2+, która pozwala uniknąć niepotrzebnej manipulacji strunami. W tym przypadku maksymalna długość wynosi 10:

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    let text = textField.text ?? ""

    return text.count - range.length + string.count <= 10
}

Praca W Swift4

// Krok 1 Ustaw UITextFieldDelegate

    class SignUPViewController: UIViewController , UITextFieldDelegate {

       @IBOutlet weak var userMobileNoTextFiled: UITextField!

        override func viewDidLoad() {
            super.viewDidLoad()

// Krok 2 Ustaw delegata
userMobileNoTextFiled.delegate = self / / set delegate }

     func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    //        guard let text = userMobileNoTextFiled.text else { return true }
    //        let newLength = text.count + string.count - range.length
    //        return newLength <= 10
    //    }

// Krok 3 wywołanie func

        func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
            let maxLength = 10          // set your need
            let currentString: NSString = textField.text! as NSString
            let newString: NSString =
                currentString.replacingCharacters(in: range, with: string) as NSString
            return newString.length <= maxLength
        }
    }

My Swift 4 version of shouldChangeCharactersIn

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange,
               replacementString string: String) -> Bool {

        guard let preText = textField.text as NSString?,
            preText.replacingCharacters(in: range, with: string).count <= MAX_TEXT_LENGTH else {
            return false
        }

        return true
    }