Come posso rimuovere l'ultimo carattere dalla variabile String usando Swift? Non riesco a trovarlo nella documentazione.

Ecco un esempio completo:

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

Swift 4.0 (anche 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

Le API sono diventate un po 'più veloci e, di conseguenza, l'estensione della Fondazione è cambiata un po':

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

O la versione sul posto:

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

Grazie Zmey, Rob Allen!

Swift 2.0+ Way

Ci sono alcuni modi per ottenere questo risultato:

Tramite l'estensione Foundation, nonostante non faccia parte della libreria Swift:

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

Utilizzando il removeRange()metodo (che modifica il name):

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

Utilizzando la dropLast()funzione:

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

Old String.Index (Xcode 6 Beta 4 +) Way

Poiché i Stringtipi in Swift mirano a fornire un eccellente supporto UTF-8, non è più possibile accedere agli indici / intervalli / sottostringhe di caratteri utilizzando i Inttipi. Invece, usi 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"

In alternativa (per un esempio più pratico, ma meno educativo) puoi usare endIndex:

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

Nota: ho trovato che questo è un ottimo punto di partenza per la comprensioneString.Index

Old (pre-Beta 4) Way

Puoi semplicemente usare la substringToIndex()funzione, fornendola una in meno della lunghezza di String:

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

La dropLast()funzione globale funziona su sequenze e quindi su stringhe:

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

In Swift 2, fai come segue:

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

Consiglio questo link per comprendere le stringhe Swift.

Swift 4/5

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

Questo è un modulo di estensione stringa :

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

per versioni di Swift precedenti alla 1.2:

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

Uso:

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

Riferimento:

Le estensioni aggiungono nuove funzionalità a una classe, struttura o tipo di enumerazione esistente. Ciò include la possibilità di estendere tipi per i quali non si ha accesso al codice sorgente originale (noto come modellazione retroattiva). Le estensioni sono simili alle categorie in Objective-C. (A differenza delle categorie Objective-C, le estensioni Swift non hanno nomi.)

Vedi DOCS

Usa la funzione removeAtIndex(i: String.Index) -> Character:

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

Il modo più semplice per tagliare l'ultimo carattere della stringa è:

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

Swift 4

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

o

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

o

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"

Una categoria rapida che sta mutando:

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

Uso:

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

Risposta breve (valida dal 16-04-2015): removeAtIndex(myString.endIndex.predecessor())

Esempio:

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

Meta:

La lingua continua la sua rapida evoluzione, rendendo l'emivita per molte risposte già buone di SO pericolosamente brevi. È sempre meglio imparare la lingua e fare riferimento alla documentazione reale .

Con il nuovo tipo di utilizzo Sottostringa:

Swift 4:

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

Modo più breve:

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

Usa la funzione advance(startIndex, endIndex):

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

Un altro modo Se si desidera rimuovere uno o più personaggi dalla fine.

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

Dove XX è il numero di caratteri che si desidera rimuovere.

Swift 3 (secondo i documenti ) 20 nov 2016

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

Consiglierei di usare NSString per le stringhe che vuoi manipolare. In realtà sono arrivato a pensarlo come uno sviluppatore che non ho mai incontrato un problema con NSString che Swift String avrebbe risolto ... Capisco le sottigliezze. Ma devo ancora averne un reale bisogno.

var foo = someSwiftString as NSString

o

var foo = "Foo" as NSString

o

var foo: NSString = "blah"

E poi l'intero mondo delle semplici operazioni su stringa NSString è aperto a te.

Come risposta alla domanda

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

La dropLast()funzione rimuove l'ultimo elemento della stringa.

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

Swift 3 : quando si desidera rimuovere la stringa finale:

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

Rapido 4.2

Inoltre elimino il mio ultimo carattere da String (ovvero testo UILabel ) nell'app 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

}

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

complementare al codice sopra ho voluto rimuovere l'inizio della stringa e non sono riuscito a trovare un riferimento da nessuna parte. Ecco come l'ho fatto:

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

Questo taglia 17 caratteri dall'inizio della stringa (la lunghezza totale della stringa è 67 avanziamo di -50 dalla fine e il gioco è fatto.