Entfernen Sie das letzte Zeichen aus der Zeichenfolge. Schnelle Sprache

Wie kann ich Sie entfernen Letzte Zeichen aus dem String-variable mit Swift? Es nicht finden können in der Dokumentation.

Hier ist voller Beispiel:

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

Kommentar zu dem Problem

2017, MODERNE ANTWORT auf: stackoverflow.com/a/39610807/294884 Kommentarautor: Fattie

InformationsquelleAutor der Frage Konstantin Cherkasov | 2014-06-09

421

Swift 4.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)

Swift 3.0

Die APIs bekommen haben ein bisschen mehr swifty, und als Ergebnis die Foundation extension etwas geändert hat:

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

Oder die in-place-version:

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

Dank Zmey, Rob Allen!

Swift 2.0+ Weg

Gibt es ein paar Möglichkeiten, dies zu erreichen:

Über die Stiftung die Erweiterung, obwohl Sie nicht Teil der Swift-Bibliothek:

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

Mithilfe der removeRange() - Methode (die verändert die name):

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

Mithilfe der dropLast() Funktion:

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

Alten Zeichenfolge).Index (Xcode 6 Beta 4 +) Weg

Seit String Arten im Swift-Ziel, die für eine hervorragende Unterstützung für UTF-8, können Sie nicht mehr zugreifen, Zeichen-Indizes/- Bereiche/Teilstrings mit Int Arten. Verwenden Sie stattdessen 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"

Alternativ (für eine praktischere, aber weniger pädagogische Beispiel), die Sie verwenden können endIndex:

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

Hinweis: fand ich diese ein großer Ausgangspunkt für das Verständnis String.Index

Alten (pre-Beta 4) Weg

Können Sie einfach die substringToIndex() Funktion werden, sofern es sich um eins kleiner als die Länge der String:

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

InformationsquelleAutor der Antwort Craig Otis

Den globalen dropLast() Funktion arbeitet auf Sequenzen und somit auf die Saiten:

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

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

InformationsquelleAutor der Antwort gui_dos

64

Swift 4:
```
let choppedString = String(theString.dropLast())
```
In Swift 2:
```
let choppedString = String(theString.characters.dropLast())
```
Empfehle ich diese link erhalten Sie einen Einblick in Swift-strings.

InformationsquelleAutor der Antwort jrc

Dies ist ein String Extension Form:

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

für Versionen von Swift früher als 1.2:

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

Verwendung:

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

Referenz:

Erweiterungen hinzufügen von neuen Funktionen zu einer vorhandenen Klasse, Struktur oder enumeration-Typ. Dies beinhaltet auch die Möglichkeit zu verlängern-Typen, für die Sie nicht haben, Zugang zu den original-source-code (bekannt als nachträgliche Modellierung). Erweiterungen sind ähnlich wie Kategorien in Objective-C. (im Gegensatz zu Objektive-C Kategorien, Swift-Erweiterungen haben keine Namen.)

Sehen DOCS

InformationsquelleAutor der Antwort Maxim Shoustin

6

Verwenden Sie die Funktion removeAtIndex(i: String.Index) -> Character:
```
var s = "abc"    
s.removeAtIndex(s.endIndex.predecessor())  // "ab"
```
InformationsquelleAutor der Antwort Anton Serkov
5

Der einfachste Weg, um schneiden Sie die letzten Zeichen des Strings ist:
```
title = title[title.startIndex ..< title.endIndex.advancedBy(-1)]
```
InformationsquelleAutor der Antwort Kunal

Swift 4

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

oder

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

oder

welcome = String(welcome.dropLast())

InformationsquelleAutor der Antwort Carien van Zyl

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

InformationsquelleAutor der Antwort Channing

var str = "Hello, playground"

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

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

InformationsquelleAutor der Antwort Leo Dabus

2

Kurze Antwort (gültig ab 2015-04-16): removeAtIndex(myString.endIndex.predecessor())

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

Die Sprache setzt seine rasante Entwicklung, so dass die Halbwertszeit für viele früher-gut S. O. Antworten zu gefährlich kurz. Es ist immer am besten, um die Sprache zu lernen und beziehen sich auf Reale Dokumentation.

InformationsquelleAutor der Antwort cweekly

Mit der neuen Substring Typ Verwendung:

Swift 4:

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

Kürzeren Weg:

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

InformationsquelleAutor der Antwort Jorge Ramírez

Verwenden Sie die Funktion advance(startIndex, endIndex):

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

InformationsquelleAutor der Antwort Chen Rui

Swift Kategorie, das mutierend:

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

Verwenden:

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

InformationsquelleAutor der Antwort Sunkas

1

Anderen Weise, Wenn Sie entfernen möchten eine oder mehrere als ein Zeichen vom Ende.
```
var myStr = "Hello World!"
myStr = (myStr as NSString).substringToIndex((myStr as NSString).length-XX)
```
Wo XX ist die Anzahl der Zeichen, die Sie entfernen möchten.

InformationsquelleAutor der Antwort Kaiusee

Swift 3 (nach der docs) 20th Nov 2016

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

InformationsquelleAutor der Antwort narco

0

Ich würde empfehlen, mit NSString für Zeichenfolgen, die Sie manipulieren möchten. Eigentlich kommen zu denken, der es als Entwickler habe ich noch nie ein problem mit NSString, dass die Swift-String lösen würde... ich verstehe die Feinheiten. Aber ich habe noch eine tatsächliche Notwendigkeit für Sie.
```
var foo = someSwiftString as NSString
```
oder
```
var foo = "Foo" as NSString
```
oder
```
var foo: NSString = "blah"
```
Und dann die ganze Welt der einfachen NSString string-Operationen steht Ihnen offen.

Als Antwort auf die Frage
```
//check bounds before you do this, e.g. foo.length > 0
//Note shortFoo is of type NSString
var shortFoo = foo.substringToIndex(foo.length-1)
```
InformationsquelleAutor der Antwort n13
0

kostenlos zu den oben genannten code, den ich entfernen wollte am Anfang der Zeichenfolge und konnte nicht finden, einen Verweis überall. Hier ist, wie ich es gemacht habe:
```
            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
```
Diese Borten 17 Zeichen vom Anfang der Zeichenfolge (er insgesamt string-Länge ist 67 wir Voraus -50 aus dem Ende und da haben Sie es.

InformationsquelleAutor der Antwort Sophman
0

Den dropLast() - Funktion entfernt das Letzte element des Strings.
```
var expression = "45+22"
expression = expression.dropLast()
```
InformationsquelleAutor der Antwort Jogendra Singh

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.