ios - स्विफ्ट के साथ स्ट्रिंग को int में कनवर्ट करना




swift uitextfield (17)

आवेदन मूल रूप से प्रारंभिक और अंतिम वेग और समय इनपुट करके त्वरण की गणना करता है और फिर त्वरण की गणना करने के लिए एक सूत्र का उपयोग करता है। हालांकि, चूंकि टेक्स्ट बॉक्स में मान स्ट्रिंग हैं, इसलिए मैं उन्हें पूर्णांक में बदलने में असमर्थ हूं।

@IBOutlet var txtBox1 : UITextField
@IBOutlet var txtBox2 : UITextField
@IBOutlet var txtBox3 : UITextField
@IBOutlet var lblAnswer : UILabel


@IBAction func btn1(sender : AnyObject) {

    let answer1 = "The acceleration is"
    var answer2 = txtBox1
    var answer3 = txtBox2
    var answer4 = txtBox3

Int () और स्विफ्ट 2.x के बारे में: यदि आपको रूपांतरण संख्या के बाद शून्य मूल्य मिलता है, तो यदि आप किसी बड़ी संख्या के साथ स्ट्रिंग को कन्वर्ट करने का प्रयास करते हैं (उदाहरण के लिए: 1073741824), इस मामले में प्रयास करें:

let bytesInternet : Int64 = Int64(bytesInternetString)!

Swift3.x के लिए

extension String {
    func toInt(defaultValue: Int) -> Int {
        if let n = Int(self.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)) {
            return n
        } else {
            return defaultValue
        }
    }
}

इसे इस्तेमाल करो:

// get the values from text boxes
    let a:Double = firstText.text.bridgeToObjectiveC().doubleValue
    let b:Double = secondText.text.bridgeToObjectiveC().doubleValue

//  we checking against 0.0, because above function return 0.0 if it gets failed to convert
    if (a != 0.0) && (b != 0.0) {
        var ans = a + b
        answerLabel.text = "Answer is \(ans)"
    } else {
        answerLabel.text = "Input values are not numberic"
    }

या

अपने यूआईटीक्स्टफाल्ड कीबोर्ड टाइप को अपने एक्सआईबी या स्टोरीबोर्ड से डेसिमलटैब के रूप में बनाएं, और किसी भी गणना करने के लिए शर्त के लिए किसी भी स्थिति को हटा दें, यानी।

var ans = a + b
answerLabel.text = "Answer is \(ans)"

चूंकि कीबोर्ड प्रकार DecimalPad है, तो 0-9 या अन्य दर्ज करने का कोई मौका नहीं है।

उममीद है कि इससे मदद मिलेगी !!


चूंकि किसी स्ट्रिंग में गैर-संख्यात्मक वर्ण हो सकते हैं, इसलिए आपको ऑपरेशन की सुरक्षा के लिए guard का उपयोग करना चाहिए। उदाहरण:

guard let labelInt:Int = Int(labelString) else {
    return
}

useLabelInt()

बेसिक आइडिया, ध्यान दें कि यह केवल स्विफ्ट 1.x में काम करता है (यह देखने के लिए पैरासारा का जवाब देखें कि यह स्विफ्ट 2.x में कैसे काम करता है):

    // toInt returns optional that's why we used a:Int?
    let a:Int? = firstText.text.toInt() // firstText is UITextField
    let b:Int? = secondText.text.toInt() // secondText is UITextField

    // check a and b before unwrapping using !
    if a && b {
        var ans = a! + b!
        answerLabel.text = "Answer is \(ans)" // answerLabel ie UILabel
    } else {
        answerLabel.text = "Input values are not numeric"
    }

स्विफ्ट 4 के लिए अद्यतन करें

...
let a:Int? = Int(firstText.text) // firstText is UITextField
let b:Int? = Int(secondText.text) // secondText is UITextField
...

मुझे हाल ही में एक ही समस्या मिली है। समाधान के नीचे मेरे लिए काम है:

        let strValue = "123"
        let result = (strValue as NSString).integerValue

मैंने एक साधारण प्रोग्राम बनाया है, जहां आपके पास 2 txt फ़ील्ड है, आप उपयोगकर्ता को इनपुट फॉर्म लेते हैं और इसे समझने में आसान बनाने के लिए उन्हें जोड़ते हैं, कृपया नीचे दिए गए कोड को ढूंढें।

@IBOutlet weak var result: UILabel!
@IBOutlet weak var one: UITextField!
@IBOutlet weak var two: UITextField!

@IBAction func add(sender: AnyObject) {        
    let count = Int(one.text!)
    let cal = Int(two.text!)
    let sum = count! + cal!
    result.text = "Sum is \(sum)"
}

उम्मीद है की यह मदद करेगा।


यह मेरे लिए काम करता है

var a:Int? = Int(userInput.text!)

स्विफ्ट 4 में:

extension String {            
    var numberValue:NSNumber? {
        let formatter = NumberFormatter()
        formatter.numberStyle = .decimal
        return formatter.number(from: self)
    }
}
let someFloat = "12".numberValue

myString.toInt() - स्ट्रिंग मान int में कनवर्ट करें।

स्विफ्ट 3.x

यदि आपके पास स्ट्रिंग के अंदर एक पूर्णांक छिपाना है, तो आप इस तरह के पूर्णांक के कन्स्ट्रक्टर का उपयोग करके कन्वर्टबी कर सकते हैं:

let myInt = Int(textField.text)

अन्य डेटा प्रकारों (फ्लोट और डबल) के साथ ही आप एनएसएसटींग का उपयोग करके भी परिवर्तित कर सकते हैं:

let myString = "556"
let myInt = (myString as NSString).integerValue

// एक्सकोड 8.1 और स्विफ्ट 3.0

हम इसे वैकल्पिक बाध्यकारी द्वारा भी संभाल सकते हैं

let occur = "10"

if let occ = Int(occur) {
        print("By optional binding :", occ*2) // 20

    }

एक्सकोड 8.3.2 • स्विफ्ट 3.1

class IntegerField: UITextField {
    var integer: Int {
        return string.digits.integer
    }
    override func willMove(toSuperview newSuperview: UIView?) {
        addTarget(self, action: #selector(editingChanged), for: .editingChanged)
        keyboardType = .numberPad
        textAlignment = .right
        editingChanged()
    }
    func editingChanged() {
        text = Formatter.decimal.string(for: integer)
        print(integer)
    }
}

आवश्यक एक्सटेंशन, structs और प्रारंभकर्ता:

extension Sequence where Iterator.Element == UnicodeScalar {
    var string: String { return String(String.UnicodeScalarView(self)) }
}

extension Formatter {
    static let decimal = NumberFormatter(numberStyle: .decimal)
}

extension UITextField {
    var string: String { return text ?? "" }
}

extension String {
    private static var digitsPattern = UnicodeScalar("0")..."9"
    var digits: String {
        return unicodeScalars.filter { String.digitsPattern ~= $0 }.string
    }
    var integer: Int { return Int(self) ?? 0 }
}

extension NumberFormatter {
    convenience init(numberStyle: Style) {
        self.init()
        self.numberStyle = numberStyle
    }
}

नवीनतम स्विफ्ट 3 यह कोड स्ट्रिंग को int में कनवर्ट करने के लिए है

let myString = "556"
let myInt = Int(myString)

स्विफ्ट 2.0 के लिए उत्तर अपडेट करें :

toInt() विधि को एक त्रुटि दी गई है। क्योंकि, स्विफ्ट 2.x में, .toInt() फ़ंक्शन स्ट्रिंग से हटा दिया गया था। प्रतिस्थापन में, इंटेल में अब एक प्रारंभकर्ता है जो स्ट्रिंग स्वीकार करता है:

let a:Int? = Int(firstText.text)     // firstText is UITextField  
let b:Int? = Int(secondText.text)   // secondText is UITextField

स्विफ्ट 3

सबसे सरल और अधिक सुरक्षित तरीका है:

@IBOutlet var textFieldA  : UITextField
@IBOutlet var textFieldB  : UITextField
@IBOutlet var answerLabel : UILabel

@IBAction func calculate(sender : AnyObject) {

      if let intValueA = Int(textFieldA),
            let intValueB = Int(textFieldB) {
            let result = intValueA + intValueB
            answerLabel.text = "The acceleration is \(result)"
      }
      else {
             answerLabel.text = "The value \(intValueA) and/or \(intValueB) are not a valid integer value"
      }        
}

कुंजीपटल प्रकार को संख्या पैड पर सेट करने वाले अमान्य मानों से बचें:

 textFieldA.keyboardType = .numberPad
 textFieldB.keyboardType = .numberPad

स्विफ्ट 4.0

let stringNumber = "123"
let number = Int(stringNumber) //here number is of type "Int?"


//using Forced Unwrapping

if number != nil {         
 //string is converted to Int
}

आप मजबूर बाध्यकारी के अलावा वैकल्पिक बाध्यकारी का भी उपयोग कर सकते हैं।

उदाहरण के लिए:

  if let number = Int(stringNumber) { 
   // number is of type Int 
  }

@IBAction func calculateAclr(_ sender: Any) {
    if let addition = addition(arrayString: [txtBox1.text, txtBox2.text, txtBox3.text]) {
      print("Answer = \(addition)")
      lblAnswer.text = "\(addition)"
    }
}

func addition(arrayString: [Any?]) -> Int? {

    var answer:Int?
    for arrayElement in arrayString {
        if let stringValue = arrayElement, let intValue = Int(stringValue)  {
            answer = (answer ?? 0) + intValue
        }
    }

    return answer
}




uitextfield