ios - स्विफ्ट में एक UITextField की अधिकतम वर्ण लंबाई निर्धारित करें




string swift (12)

दिसंबर 2017. स्विफ्ट 4।

ध्यान रखें कि इस समस्या के बारे में ऑनलाइन जो बहुत सारे उदाहरण कोड आपको दिखाई देंगे, वे बहुत पुराने हैं

अपनी परियोजना में किसी भी स्विफ्ट फ़ाइल में निम्नलिखित पेस्ट करें। आप फ़ाइल को कुछ भी नाम दे सकते हैं, उदाहरण के लिए, "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 व्यू , https://stackoverflow.com/a/42333832/294884 से संबंधित एक बहुत ही उपयोगी टिप दी गई है)

मुझे पता है कि इस पर अन्य विषय हैं लेकिन मुझे यह पता नहीं लग सकता है कि इसे कैसे लागू किया जाए।

मैं एक 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 के लिए स्वैप करूं


टेक्स्ट स्विफ्ट 4 में टेक्स्ट को ब्लॉक करने के बाद टेक्स्ट लिमिट कैरेक्टर

 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 } 

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

उसी तरह स्टीवन शमाटज़ ने भी स्विफ्ट 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
}

बस स्ट्रिंग में वर्णों की संख्या के साथ जांचें

  1. नियंत्रक ans प्रतिनिधि को देखने के लिए एक प्रतिनिधि जोड़ें
    class YorsClassName : UITextFieldDelegate {

    }
  1. टेक्स्टफील्ड के लिए अनुमति दी गई संख्या की जांच करें
func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    if textField.text?.count == 1 {
        return false
    }
    return true
}

नोट: यहां मैंने केवल टेक्स्टफिल्ड में अनुमति दी गई चार के लिए जाँच की


मुझे अलादीन के जवाब में कुछ जोड़ना है:

  1. आपका दृश्य नियंत्रक UITextFieldDelegate अनुरूप होना चाहिए

    class MyViewController: UIViewController, UITextViewDelegate {
    
    }
  2. अपने टेक्स्टफील्ड के प्रतिनिधि को सेट करें: प्रतिनिधि को सेट करने के लिए, आप टेक्स्टबोर्ड से ड्रैगबोर्ड में अपने व्यू कंट्रोलर तक ड्रैग को नियंत्रित कर सकते हैं। मुझे लगता है कि इसे कोड में सेट करना बेहतर है

  3. अपने दृश्य नियंत्रक में विधि को लागू करें: textField(_:shouldChangeCharactersInRange:replacementString:)


मेरे Swift के 4 संस्करण

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
    }

मैं @ पूरक के आधार पर एक पूरक उत्तर देता हूं। मुझे लगता है कि उनका जवाब सबसे सुंदर तरीका है। Beuase यह एक सामान्य नियंत्रण है जिसका हम पुन: उपयोग कर सकते हैं। और यहाँ कोई लीक समस्या नहीं है।

    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
        }



    }

यह उत्तर स्विफ्ट 4 के लिए है, और बैकस्पेस के माध्यम से जाने की क्षमता के साथ बहुत सीधा है।

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

यहां एक स्विफ्ट 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
}

Swift4 में काम करना

// STEP 1 सेट UITextFieldDelegate

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

// STEP 2 सेट प्रतिनिधि
userMobileNoTextFiled.delegate = आत्म // सेट प्रतिनिधि}

    class SignUPViewController: UIViewController , UITextFieldDelegate {

       @IBOutlet weak var userMobileNoTextFiled: UITextField!

        override func viewDidLoad() {
            super.viewDidLoad()

// STEP 3 कॉल फंक

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

प्रतिनिधि का उपयोग किए बिना सरल समाधान:

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






character