나는 이것에 다른 주제가 있다는 것을 알고 있지만 그것을 구현하는 방법을 찾을 수없는 것 같습니다.

UITextField를 5 자로 제한하려고합니다.

가급적 영숫자 및-및. 및 _

나는이 코드를 보았다

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange,
                       replacementString string: String) -> Bool
{
    let maxLength = 4
    let currentString: NSString = textField.text
    let newString: NSString =
             currentString.stringByReplacingCharactersInRange(range, withString: string)
    return newString.length <= maxLength
}

과

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

    let length = count(textField.text.utf16) + count(string.utf16) - range.length
    return length <= 10 
}

실제로 구현하는 방법이나 UITextField라는 사용자 정의로 교체해야하는 "텍스트 필드"를 모르겠습니다.

1. 뷰 컨트롤러는 UITextFieldDelegate아래와 같이을 준수해야 합니다.

   class MyViewController: UIViewController, UITextFieldDelegate {
   
   }
   

2. 텍스트 필드의 대리자를 설정합니다. myTextField.delegate = self

3. 뷰 컨트롤러에서 메소드를 구현하십시오. textField(_:shouldChangeCharactersInRange:replacementString:)

모두 함께:

class MyViewController: UIViewController,UITextFieldDelegate  //set delegate to class 

@IBOutlet var mytextField: UITextField             //  textfield variable 

override func viewDidLoad() {
    super.viewDidLoad()
    mytextField.delegate = self                  //set delegate
}


func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange,
                       replacementString string: String) -> Bool
{
    let maxLength = 4
    let currentString: NSString = textField.text
    let newString: NSString =
             currentString.stringByReplacingCharactersInRange(range, withString: string)
    return newString.length <= maxLength
}

Swift 4의 경우

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

지정된 텍스트 필드에 지정된 문자 집합 만 입력하도록 허용

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
  var result = true
  
  if mytextField == numberField {
    if count(string) > 0 {
      let disallowedCharacterSet = NSCharacterSet(charactersInString: "0123456789.-").invertedSet
      let replacementStringIsLegal = string.rangeOfCharacterFromSet(disallowedCharacterSet) == nil
      result = replacementStringIsLegal
    }
  }
 
  return result
}

최대 길이의 숫자 입력 만받는 iOS 텍스트 필드를 프로그래밍하는 방법

2017 년 12 월. Swift 4.

주의해야 이 문제에 대해 온라인으로 볼 수있는 예제 코드의 대부분은 아주 오래된입니다 .

프로젝트의 Swift 파일에 다음을 붙여 넣으십시오. 파일 이름은 무엇이든 가능합니다 (예 : "Handy.swift").

이것은 마침내 iOS에서 가장 어리석은 문제 중 하나를 수정합니다.

이제 텍스트 필드에 .maxLength.

개발 중에 스토리 보드에서 해당 값을 설정하거나 앱이 실행되는 동안 코드에서 설정하는 것은 완전히 괜찮습니다.

// simply have this in any Swift file, say, Handy.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?.prefix(maxLength)
    }
}

그렇게 간단합니다.

각주-요즘 String에는 신속하게 안전하게 자르기 위해 간단하게.prefix(n)

더 간단한 일회성 버전 ...

위는 프로젝트의 모든 텍스트 필드를 수정 합니다 .

특정 텍스트 필드 하나 를 "4"로만 제한 하고 싶은 경우 그게 ...

class PinCodeEntry: UITextField {
    
    override func didMoveToSuperview() {
        
        super.didMoveToSuperview()
        addTarget(self, action: #selector(fixMe), for: .editingChanged)
    }
    
    @objc private func fixMe() { text = text?.prefix(4) }
}

휴! 그게 전부입니다.

(단지 BTW, UIText View 와 관련된 매우 유용한 팁 , https://stackoverflow.com/a/42333832/294884 )

OCD 프로그래머 (나와 같은)에게는 ...

@LeoDabus가 상기시켜 주듯이 .prefix는 하위 문자열을 반환합니다. 당신이 엄청나게 관심이 있다면

let t = textField.text
textField.text = t?.prefix(maxLength)

될 것이다

if let t: String = textField.text {
    textField.text = String(t.prefix(maxLength))
}

즐겨!

Swift 4, 간단히 사용 :

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

Steven Schmatz가 한 것과 같은 방식이지만 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
}

Swift 5의 경우 :
한 줄을 작성하여 최대 문자 길이를 설정하십시오.

 self.textField.maxLength = 10

자세한 내용은 여기를 클릭하세요

크레딧 : http://www.swiftdevcenter.com/max-character-limit-of-uitextfield-and-allowed-characters-swift/

확장이 더 편리하다고 생각합니다. 여기에서 전체 답변보기

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
  }

}

위에 게시 된 다른 솔루션은 텍스트 필드 맵으로 인해 유지주기를 생성합니다. 게다가 maxLength인위적인 Int.max구조 대신 설정하지 않으면 속성은 nullable이어야합니다 . maxLength가 변경되면 대상이 여러 번 설정됩니다.

이곳까지 메모리 누출 및 다른 수정을 방지하는 약한지도 Swift4 업데이트 된 용액을

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

델리게이트를 사용하지 않는 간단한 솔루션 :

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

내 Swift 4 버전 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
    }

Aladin의 답변에 추가 할 것이 있습니다.

1. 뷰 컨트롤러는 다음을 준수해야합니다. UITextFieldDelegate

   class MyViewController: UIViewController, UITextViewDelegate {
   
   }
   

2. 텍스트 필드의 델리게이트 설정 : 델리게이트를 설정하려면 텍스트 필드에서 스토리 보드의 뷰 컨트롤러로 드래그를 제어 할 수 있습니다. 나는 이것이 코드로 설정하는 것보다 바람직하다고 생각합니다.

3. 뷰 컨트롤러에서 메소드를 구현하십시오. textField(_:shouldChangeCharactersInRange:replacementString:)

@Frouo를 기반으로 보충 답변을 제공합니다. 그의 대답이 가장 아름다운 방법이라고 생각합니다. 우리가 재사용 할 수있는 일반적인 컨트롤이기 때문입니다. 그리고 여기에는 누출 문제가 없습니다.

    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
        }



    }

이것에 대한 업데이트 Fattie 답변에 대한

감사

extension UITextField {

    /// Runtime key
    private struct AssociatedKeys {
        /// max lenght key
        static var maxlength: UInt8 = 0
        /// temp string key
        static var tempString: UInt8 = 0
    }

    /// Limit the maximum input length of the textfiled
    @IBInspectable var maxLength: Int {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.maxlength) as? Int ?? 0
        }
        set {
            objc_setAssociatedObject(self, &AssociatedKeys.maxlength, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            addTarget(self, action: #selector(handleEditingChanged(textField:)), for: .editingChanged)
        }
    }

    /// temp string
    private var tempString: String? {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.tempString) as? String
        }
        set {
            objc_setAssociatedObject(self, &AssociatedKeys.tempString, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    /// When the text changes, process the amount of text in the input box so that its length is within the controllable range.
    @objc private func handleEditingChanged(textField: UITextField) {

        /// Special Processing for Chinese Input Method
        guard markedTextRange == nil else { return }

        if textField.text?.count == maxLength {

            /// SET lastQualifiedString where text length == max lenght
            tempString = textField.text
        } else if textField.text?.count ?? 0 < maxLength {

            /// clear lastQualifiedString when text lengeht > maxlength
            tempString = nil
        }

        /// keep current text range in arcgives
        let archivesEditRange: UITextRange?

        if textField.text?.count ?? 0 > maxLength {

            /// if text length > maxlength,remove last range,to move to -1 postion.
            let position = textField.position(from: safeTextPosition(selectedTextRange?.start), offset: -1) ?? textField.endOfDocument
            archivesEditRange = textField.textRange(from: safeTextPosition(position), to: safeTextPosition(position))
        } else {

            /// just set current select text range
            archivesEditRange = selectedTextRange
        }

        /// main handle string max length
        textField.text = tempString ?? String((textField.text ?? "").prefix(maxLength))

        /// last config edit text range
        textField.selectedTextRange = archivesEditRange
    }

    /// get safe textPosition
    private func safeTextPosition(_ optionlTextPosition: UITextPosition?) -> UITextPosition {

        /* beginningOfDocument -> The end of the the text document. */
        return optionlTextPosition ?? endOfDocument
    }
}

Swift4에서 작업

// 1 단계 UITextFieldDelegate 설정

    class SignUPViewController: UIViewController , UITextFieldDelegate {

       @IBOutlet weak var userMobileNoTextFiled: UITextField!

        override func viewDidLoad() {
            super.viewDidLoad()

// 2 단계 델리게이트 설정
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
    //    }

// 3 단계 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
        }
    }

이 답변은 Swift 4에 대한 것이며 백 스페이스를 통과시키는 기능으로 매우 간단합니다.

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

문자열의 문자 수만 확인하면됩니다.

1. 컨트롤러 및 대리인을보기위한 대리인 추가

    class YorsClassName : UITextFieldDelegate {

    }

2. 텍스트 필드에 허용되는 문자 수 확인

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    if textField.text?.count == 1 {
        return false
    }
    return true
}

참고 : 여기서는 textField에서 허용되는 문자 만 확인했습니다.

Swift 4에서 텍스트 차단 후 TextField 제한 문자

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


    if textField == self.txtDescription {
        let maxLength = 200
        let currentString: NSString = textField.text! as NSString
        let newString: NSString = currentString.replacingCharacters(in: range, with: string) as NSString
        return newString.length <= maxLength
    }

    return true


}

혹시라도 문자열에 적용하기 전에 범위 크기를 보호하는 것을 잊지 마십시오. 그렇지 않으면 사용자가 다음을 수행하면 충돌이 발생합니다.

최대 길이 텍스트 입력 무언가 삽입 (길이 제한으로 인해 아무것도 삽입되지 않지만 iOS는 이에 대해 알지 못함) 삽입 실행 취소 (충돌이 발생하고 범위가 실제 문자열 크기보다 커짐)

또한 iOS 13 사용자는 제스처로 실수로이를 트리거 할 수 있습니다.

프로젝트에 이것을 추가하는 것이 좋습니다.

extension String {
    func replace(with text: String, in range: NSRange) -> String? {
        guard range.location + range.length <= self.count else { return nil }
        return (self as NSString).replacingCharacters(in: range, with: text)
    }
}

다음과 같이 사용하십시오.

func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
    guard let newText = textView.text.replace(with: text, in: range) else { return false }
    return newText.count < maxNumberOfCharacters
}

그렇지 않으면 앱에서 지속적으로 충돌이 발생합니다.

불필요한 문자열 조작을 피하는 Swift 3.2+ 대안이 있습니다. 이 경우 최대 길이는 10입니다.

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

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

이 단계를 사용하여 먼저 viewdidload에서 대리자 texfield를 설정합니다.

    override func viewDidLoad() {
        super.viewDidLoad()

        textfield.delegate = self

    }

UITextFieldDelegate를 포함시킨 후 shouldChangeCharactersIn.

extension viewController: UITextFieldDelegate {
    func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
                let newLength = (textField.text?.utf16.count)! + string.utf16.count - range.length
                if newLength <= 8 { 
                    return true
                } else {
                    return false
                }
            }
    }

한 페이지에 다양한 길이 검사가있는 여러 textField가있는 경우 쉽고 짧은 솔루션을 찾았습니다.

class MultipleTextField: UIViewController {

    let MAX_LENGTH_TEXTFIELD_A = 10
    let MAX_LENGTH_TEXTFIELD_B = 11

    lazy var textFieldA: UITextField = {
        let textField = UITextField()
        textField.tag = MAX_LENGTH_TEXTFIELD_A
        textField.delegate = self
        return textField
    }()
    lazy var textFieldB: UITextField = {
        let textField = UITextField()
        textField.tag = MAX_LENGTH_TEXTFIELD_B
        textField.delegate = self
        return textField
    }()
}

extension MultipleTextField: UITextFieldDelegate {
    func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
        return (range.location < textField.tag) && (string.count < textField.tag)
    }
}