Wie kann ich mit Swift das letzte Zeichen aus der String-Variablen entfernen? Kann es nicht in der Dokumentation finden.

Hier ist ein vollständiges Beispiel:

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

Swift 4.0 (auch Swift 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)

Swift 3.0

Die APIs sind etwas schneller geworden , und infolgedessen hat sich die Foundation-Erweiterung etwas geändert:

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"

Danke Zmey, Rob Allen!

Schneller 2.0+ Weg

Es gibt einige Möglichkeiten, dies zu erreichen:

Über die Foundation-Erweiterung, obwohl sie nicht Teil der Swift-Bibliothek ist:

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

Unter Verwendung der removeRange()Methode (die Abspaltungen der name):

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

Verwenden der dropLast()Funktion:

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

Alter String.Index (Xcode 6 Beta 4 +) Weg

Da StringTypen in Swift eine hervorragende UTF-8-Unterstützung bieten sollen, können Sie mit IntTypen nicht mehr auf Zeichenindizes / -bereiche / Teilzeichenfolgen zugreifen . Stattdessen verwenden Sie 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 ein praktischeres, aber weniger lehrreiches Beispiel) können Sie Folgendes verwenden endIndex:

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

Hinweis: Ich fand dies ein guter Ausgangspunkt für das Verständnis zu seinString.Index

Alter (Pre-Beta 4) Weg

Sie können die substringToIndex()Funktion einfach verwenden und eine weniger als die Länge der String:

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

Die globale dropLast()Funktion arbeitet mit Sequenzen und daher mit Strings:

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

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

Swift 4:

let choppedString = String(theString.dropLast())

Gehen Sie in Swift 2 folgendermaßen vor:

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

Ich empfehle diesen Link, um Swift-Strings besser zu verstehen.

Swift 4/5

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

Dies ist ein String- Erweiterungsformular:

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 vor 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 fügen einer vorhandenen Klasse, Struktur oder einem Aufzählungstyp neue Funktionen hinzu. Dies umfasst die Möglichkeit, Typen zu erweitern, für die Sie keinen Zugriff auf den ursprünglichen Quellcode haben (als rückwirkende Modellierung bezeichnet). Erweiterungen ähneln Kategorien in Objective-C. (Im Gegensatz zu Objective-C-Kategorien haben Swift-Erweiterungen keine Namen.)

Siehe DOCS

Verwenden Sie die Funktion removeAtIndex(i: String.Index) -> Character:

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

Der einfachste Weg, das letzte Zeichen der Zeichenfolge zu kürzen, ist:

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

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

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

var str = "Hello, playground"

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

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

Eine schnelle Kategorie, die mutiert:

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"

Kurze Antwort (gültig ab 16.04.2015): 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 ihre rasante Entwicklung fort und macht die Halbwertszeit für viele ehemals gute SO-Antworten gefährlich kurz. Es ist immer am besten, die Sprache zu lernen und sich auf echte Dokumentation zu beziehen .

Mit der neuen Verwendung des Teilstringtyps:

Swift 4:

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

Kürzere Art:

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

Verwenden Sie die Funktion advance(startIndex, endIndex):

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

Ein anderer Weg Wenn Sie ein oder mehrere Zeichen am Ende entfernen möchten .

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

Wobei XX die Anzahl der Zeichen ist, die Sie entfernen möchten.

Swift 3 (laut Dokumentation ) 20. November 2016

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

Ich würde empfehlen, NSString für Zeichenfolgen zu verwenden, die Sie bearbeiten möchten. Wenn ich es mir als Entwickler vorstelle, bin ich nie auf ein Problem mit NSString gestoßen, das Swift String lösen würde ... Ich verstehe die Feinheiten. Aber ich habe noch keinen tatsächlichen Bedarf für sie.

var foo = someSwiftString as NSString

oder

var foo = "Foo" as NSString

oder

var foo: NSString = "blah"

Und dann steht Ihnen die ganze Welt der einfachen NSString-String-Operationen 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)

Die dropLast()Funktion entfernt das letzte Element der Zeichenfolge.

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

Swift 3 : Wenn Sie die nachfolgende Zeichenfolge entfernen möchten:

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

Swift 4.2

Ich lösche auch mein letztes Zeichen aus String (dh UILabel-Text ) in der IOS-App

@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

}

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

Ergänzend zum obigen Code wollte ich den Anfang der Zeichenfolge entfernen und konnte nirgendwo eine Referenz finden. So habe ich es gemacht:

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

Dies schneidet 17 Zeichen vom Anfang der Zeichenfolge ab (die Gesamtlänge der Zeichenfolge beträgt 67, wir rücken vom Ende bis -50 vor und da haben Sie es.