स्ट्रिंग से अंतिम वर्ण निकालें। स्विफ्ट भाषा

Question

मैं स्विफ्ट का उपयोग करते हुए स्ट्रिंग चर से अंतिम चरित्र कैसे निकाल सकता हूं? इसे दस्तावेज़ में नहीं ढूंढा जा सकता।

यहाँ पूरा उदाहरण है:

var expression = "45+22"
expression = expression.substringToIndex(countElements(expression) - 1)

Comments

2017, आधुनिक उत्तर: stackoverflow.com/a/39610807/294884

— fattie

Answer 1

स्विफ्ट 4.0 (स्विफ्ट 5.0 भी)

var str = "Hello, World"                           // "Hello, World"
str.dropLast()                                     // "Hello, Worl" (non-modifying)
str                                                // "Hello, World"
String(str.dropLast())                             // "Hello, Worl"

str.remove(at: str.index(before: str.endIndex))    // "d"
str                                                // "Hello, Worl" (modifying)

स्विफ्ट 3.0

एपीआई में थोड़ा और अधिक मिल गया है Swifty , और एक परिणाम के रूप में फाउंडेशन विस्तार थोड़ा बदल गया है:

var name: String = "Dolphin"
var truncated = name.substring(to: name.index(before: name.endIndex))
print(name)      // "Dolphin"
print(truncated) // "Dolphi"

या जगह में संस्करण:

var name: String = "Dolphin"
name.remove(at: name.index(before: name.endIndex))
print(name)      // "Dolphi"

धन्यवाद Zmey, रोब एलन!

स्विफ्ट 2.0+ रास्ता

इसे पूरा करने के कुछ तरीके हैं:

स्विफ्ट लाइब्रेरी का हिस्सा नहीं होने के बावजूद फाउंडेशन एक्सटेंशन के माध्यम से:

var name: String = "Dolphin"
var truncated = name.substringToIndex(name.endIndex.predecessor())
print(name)      // "Dolphin"
print(truncated) // "Dolphi"

removeRange()विधि का उपयोग करना (जो बदल जाता है name):

var name: String = "Dolphin"    
name.removeAtIndex(name.endIndex.predecessor())
print(name) // "Dolphi"

dropLast()फ़ंक्शन का उपयोग करना :

var name: String = "Dolphin"
var truncated = String(name.characters.dropLast())
print(name)      // "Dolphin"
print(truncated) // "Dolphi"

ओल्ड स्ट्रिंग.इंडेक्स (एक्सकोड 6 बीटा 4 +) रास्ता

चूंकि Stringस्विफ्ट का उद्देश्य उत्कृष्ट UTF-8 सहायता प्रदान करना है, इसलिए आप Intप्रकारों का उपयोग करके वर्ण अनुक्रमणिका / श्रेणी / सबस्ट्रिंग तक नहीं पहुँच सकते हैं। इसके बजाय, आप उपयोग करते हैं String.Index:

let name: String = "Dolphin"
let stringLength = count(name) // Since swift1.2 `countElements` became `count`
let substringIndex = stringLength - 1
name.substringToIndex(advance(name.startIndex, substringIndex)) // "Dolphi"

वैकल्पिक रूप से (अधिक व्यावहारिक, लेकिन कम शैक्षिक उदाहरण के लिए) आप उपयोग कर सकते हैं endIndex:

let name: String = "Dolphin"
name.substringToIndex(name.endIndex.predecessor()) // "Dolphi"

नोट: मैंने इसे समझने के लिए एक शानदार शुरुआती बिंदु पायाString.Index

पुराना (पूर्व-बीटा 4) रास्ता

आप केवल substringToIndex()फ़ंक्शन का उपयोग कर सकते हैं , इसे प्रदान कर सकते हैं String:

let name: String = "Dolphin"
name.substringToIndex(countElements(name) - 1) // "Dolphi"

Comments

Xcode 6 बीटा 6 पर: 'स्ट्रिंग' में सदस्य नहीं है जिसका नाम हैsubstringToIndex

— ielyamani

अरे, सिर ऊपर करो, सुनिश्चित करें कि यह substringToIndexनहीं है substringFromIndex। यह आपको बुद्धिमान समझ में नहीं आता है, मैं आपको बता दूं।

— लूई बर्टोनिन

यह सच है, 21 जुलाई तक, Xcode 7 Beta 4 का कहना है कि 'स्ट्रिंग' में एक सदस्य का नाम नहीं है substringToIndex। इसके अलावा, Xcode 7 के रूप में, स्ट्रिंग में अब कोई .countसंपत्ति नहीं है, यह अब केवल पात्रों पर लागू होता है:string.characters.count

— kakubei

स्विफ्ट 3:var truncated = name.substring(to: name.index(before: name.endIndex))

— ज़मी

आपका उत्तर स्विफ्ट विकास का इतिहास है।

— डॉनसॉन्ग

Answer 2

वैश्विक dropLast()कार्य अनुक्रमों पर और इसलिए स्ट्रिंग्स पर काम करता है:

var expression  = "45+22"
expression = dropLast(expression)  // "45+2"

// in Swift 2.0 (according to cromanelli's comment below)
expression = String(expression.characters.dropLast())

Comments

स्विफ्ट 2.0 में charactersएक स्ट्रिंग पर संपत्ति एक अनुक्रम को आउटपुट करती है, इसलिए अब आपको उपयोग करना होगा:expression = expression.characters.dropLast()

— gui_dos

स्विफ्ट 2.0 में परिणाम को ठीक से डालने के लिए expression = String(expression.characters.dropLast())यदि आप इसे एक स्ट्रिंग के रूप में वापस चाहते हैं

— cromanelli

Answer 3

स्विफ्ट 4:

let choppedString = String(theString.dropLast())

स्विफ्ट 2 में, यह करें:

let choppedString = String(theString.characters.dropLast())

मैं इस लिंक को स्विफ्ट स्ट्रिंग्स की समझ प्राप्त करने की सलाह देता हूं ।

Answer 4

स्विफ्ट 4/5

var str = "bla"
str.removeLast() // returns "a"; str is now "bl"

Answer 5

यह एक स्ट्रिंग एक्सटेंशन फॉर्म है:

extension String {

    func removeCharsFromEnd(count_:Int) -> String {
        let stringLength = count(self)

        let substringIndex = (stringLength < count_) ? 0 : stringLength - count_

        return self.substringToIndex(advance(self.startIndex, substringIndex))
    }
}

1.2 से पहले स्विफ्ट के संस्करणों के लिए:

...
let stringLength = countElements(self)
...

---

उपयोग:

var str_1 = "Maxim"
println("output: \(str_1.removeCharsFromEnd(1))") // "Maxi"
println("output: \(str_1.removeCharsFromEnd(3))") // "Ma"
println("output: \(str_1.removeCharsFromEnd(8))") // ""

---

संदर्भ:

एक्सटेंशन एक मौजूदा वर्ग, संरचना, या गणना प्रकार में नई कार्यक्षमता जोड़ते हैं। इसमें उन प्रकारों को विस्तारित करने की क्षमता शामिल है जिनके लिए आपके पास मूल स्रोत कोड तक पहुंच नहीं है (जिसे रेट्रोएक्टिव मॉडलिंग कहा जाता है)। उद्देश्य-सी में श्रेणियां समान हैं। (उद्देश्य-सी श्रेणियों के विपरीत, स्विफ्ट एक्सटेंशन के नाम नहीं हैं।)

DOCS देखें

Comments

नमस्ते, क्या आपने इमोजीस टेस्ट किया है?

— ZYiOS

@ZuYuan क्या emojis है?

— मैक्सिम शाओतिन

Answer 6

फ़ंक्शन का उपयोग करें removeAtIndex(i: String.Index) -> Character:

var s = "abc"    
s.removeAtIndex(s.endIndex.predecessor())  // "ab"

Answer 7

स्ट्रिंग के अंतिम वर्ण को ट्रिम करने का सबसे आसान तरीका है:

title = title[title.startIndex ..< title.endIndex.advancedBy(-1)]

Comments

धन्यवाद, एक स्ट्रिंग के अंत से जितने चाहें उतने पात्र निकालने के लिए एक बहुत ही सुंदर तरीका।

— लेटैफ अच्राफ

Answer 8

स्विफ्ट 4

var welcome = "Hello World!"
welcome = String(welcome[..<welcome.index(before:welcome.endIndex)])

या

welcome.remove(at: welcome.index(before: welcome.endIndex))

या

welcome = String(welcome.dropLast())

Answer 9

let str = "abc"
let substr = str.substringToIndex(str.endIndex.predecessor())  // "ab"

Answer 10

var str = "Hello, playground"

extension String {
    var stringByDeletingLastCharacter: String {
        return dropLast(self)
    }
}

println(str.stringByDeletingLastCharacter)   // "Hello, playgroun"

Comments

kkkk मुझे यह भी याद नहीं है (स्विफ्ट 1.2 ऊपर)। स्विफ्ट 3 संस्करण के लिए stackoverflow.com/a/40028338/2303865

— लियो डबस

Answer 11

एक तेज़ श्रेणी जो परिवर्तनशील है:

extension String {
    mutating func removeCharsFromEnd(removeCount:Int)
    {
        let stringLength = count(self)
        let substringIndex = max(0, stringLength - removeCount)
        self = self.substringToIndex(advance(self.startIndex, substringIndex))
    }
}

उपयोग:

var myString = "abcd"
myString.removeCharsFromEnd(2)
println(myString) // "ab"

Answer 12

संक्षिप्त उत्तर (2015-04-16 तक मान्य): removeAtIndex(myString.endIndex.predecessor())

उदाहरण:

var howToBeHappy = "Practice compassion, attention and gratitude. And smile!!"
howToBeHappy.removeAtIndex(howToBeHappy.endIndex.predecessor())
println(howToBeHappy)
// "Practice compassion, attention and gratitude. And smile!"

मेटा:

भाषा अपना तेजी से विकास जारी रखती है, जिससे कई पूर्व-अच्छे एसओ उत्तर के लिए आधा जीवन खतरनाक रूप से संक्षिप्त हो जाते हैं। हमेशा भाषा सीखना और वास्तविक प्रलेखन का संदर्भ देना सबसे अच्छा होता है ।

Answer 13

नए सबस्ट्रिंग प्रकार के उपयोग के साथ:

स्विफ्ट 4:

var before: String = "Hello world!"
var lastCharIndex: Int = before.endIndex
var after:String = String(before[..<lastCharIndex])
print(after) // Hello world

छोटा रास्ता:

var before: String = "Hello world!"
after = String(before[..<before.endIndex])
print(after) // Hello world

Answer 14

फ़ंक्शन का उपयोग करें advance(startIndex, endIndex):

var str = "45+22"
str = str.substringToIndex(advance(str.startIndex, countElements(str) - 1))

Answer 15

दूसरा तरीका यदि आप अंत में एक या एक से अधिक वर्ण हटाना चाहते हैं ।

var myStr = "Hello World!"
myStr = (myStr as NSString).substringToIndex((myStr as NSString).length-XX)

जहां XX उन वर्णों की संख्या है जिन्हें आप हटाना चाहते हैं।

Answer 16

स्विफ्ट 3 ( डॉक्स के अनुसार ) 20 नवंबर 2016

let range = expression.index(expression.endIndex, offsetBy: -numberOfCharactersToRemove)..<expression.endIndex
expression.removeSubrange(range)

Answer 17

मैं उन स्ट्रिंग्स के लिए NSString का उपयोग करने की सलाह दूंगा जिन्हें आप हेरफेर करना चाहते हैं। वास्तव में इसे एक डेवलपर के रूप में सोचने के लिए आया हूं कि मैंने कभी भी एनएसएसटीरिंग के साथ एक समस्या में नहीं चला है कि स्विफ्ट स्ट्रिंग को हल किया जाएगा ... मुझे सूक्ष्मताएं समझ में आती हैं। लेकिन मुझे अभी उनके लिए एक वास्तविक आवश्यकता है।

var foo = someSwiftString as NSString

या

var foo = "Foo" as NSString

या

var foo: NSString = "blah"

और फिर सरल NSString स्ट्रिंग संचालन की पूरी दुनिया आपके लिए खुली है।

सवाल के जवाब के रूप में

// check bounds before you do this, e.g. foo.length > 0
// Note shortFoo is of type NSString
var shortFoo = foo.substringToIndex(foo.length-1)

Answer 18

dropLast()समारोह स्ट्रिंग के अंतिम तत्व निकाल देता है।

var expression = "45+22"
expression = expression.dropLast()

Answer 19

स्विफ्ट 3 : जब आप ट्रेलिंग स्ट्रिंग निकालना चाहते हैं:

func replaceSuffix(_ suffix: String, replacement: String) -> String {
    if hasSuffix(suffix) {
        let sufsize = suffix.count < count ? -suffix.count : 0
        let toIndex = index(endIndex, offsetBy: sufsize)
        return substring(to: toIndex) + replacement
    }
    else
    {
        return self
    }
}

Answer 20

स्विफ्ट 4.2

मैं अपने अंतिम चरित्र को स्ट्रिंग (यानी UILabel पाठ ) से IOS ऐप में हटा देता हूं

@IBOutlet weak var labelText: UILabel! // Do Connection with UILabel

@IBAction func whenXButtonPress(_ sender: UIButton) { // Do Connection With X Button

    labelText.text = String((labelText.text?.dropLast())!) // Delete the last caracter and assign it

}

Answer 21

import UIKit

var str1 = "Hello, playground"
str1.removeLast()
print(str1)

var str2 = "Hello, playground"
str2.removeLast(3)
print(str2)

var str3 = "Hello, playground"
str3.removeFirst(2)
print(str3)

Output:-
Hello, playgroun
Hello, playgro
llo, playground

Answer 22

उपरोक्त कोड के लिए मानदंड मैं स्ट्रिंग की शुरुआत को दूर करना चाहता था और कहीं भी एक संदर्भ नहीं मिल सका। यहाँ देखें कि मैंने यह कैसे किया:

var mac = peripheral.identifier.description
let range = mac.startIndex..<mac.endIndex.advancedBy(-50)
mac.removeRange(range)  // trim 17 characters from the beginning
let txPower = peripheral.advertisements.txPower?.description

यह स्ट्रिंग की शुरुआत से 17 वर्णों को विभाजित करता है (वह कुल स्ट्रिंग लंबाई 67 है हम अंत से -50 अग्रिम करते हैं और वहां आपके पास है।