¿Cómo puedo eliminar el último carácter de la variable de cadena usando Swift? No puedo encontrarlo en la documentación.

Aquí hay un ejemplo completo:

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

Swift 4.0 (también 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

Las API se han vuelto un poco más rápidas y, como resultado, la extensión de Foundation ha cambiado un poco:

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

O la versión en el lugar:

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

Gracias Zmey, Rob Allen!

Swift 2.0+ Way

Hay algunas formas de lograr esto:

A través de la extensión Foundation, a pesar de no ser parte de la biblioteca Swift:

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

Usando el removeRange()método (que altera el name):

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

Usando la dropLast()función:

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

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

Dado que los Stringtipos en Swift tienen como objetivo proporcionar una excelente compatibilidad con UTF-8, ya no puede acceder a índices / rangos / subcadenas de caracteres mediante Inttipos. En cambio, usas 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"

Alternativamente (para un ejemplo más práctico, pero menos educativo) puede usar endIndex:

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

Nota: He encontrado esto para ser un gran punto de partida para la comprensiónString.Index

Manera antigua (pre-Beta 4)

Simplemente puede usar la substringToIndex()función, proporcionándola una menos que la longitud de String:

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

La dropLast()función global funciona en secuencias y, por lo tanto, en cadenas:

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

En Swift 2, haz esto:

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

Recomiendo este enlace para comprender las cadenas Swift.

Swift 4/5

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

Este es un formulario de extensión de cadena :

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

Para versiones de Swift anteriores a 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))") // ""

Referencia:

Las extensiones agregan nueva funcionalidad a una clase, estructura o tipo de enumeración existente. Esto incluye la capacidad de extender tipos para los cuales no tiene acceso al código fuente original (conocido como modelado retroactivo). Las extensiones son similares a las categorías en Objective-C. (A diferencia de las categorías de Objective-C, las extensiones Swift no tienen nombres).

Ver DOCUMENTOS

Usa la función removeAtIndex(i: String.Index) -> Character:

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

La forma más fácil de recortar el último carácter de la cadena es:

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 categoría rápida que está 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))
    }
}

Utilizar:

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

Respuesta corta (válida a partir del 16/04/2015): removeAtIndex(myString.endIndex.predecessor())

Ejemplo:

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

Meta:

El lenguaje continúa su rápida evolución, haciendo que la vida media de muchas respuestas SO anteriormente buenas sea peligrosamente breve. Siempre es mejor aprender el idioma y consultar documentación real .

Con el nuevo uso del tipo de subcadena:

Swift 4:

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

Camino más corto:

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

Usa la función advance(startIndex, endIndex):

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

Otra forma Si desea eliminar uno o más de un personaje del final.

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

Donde XX es el número de caracteres que desea eliminar.

Swift 3 (según los documentos ) 20 de noviembre de 2016

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

Recomiendo usar NSString para las cadenas que desea manipular. En realidad, pienso en ello como un desarrollador. Nunca he tenido un problema con NSString que Swift String resolvería ... Entiendo las sutilezas. Pero todavía tengo una necesidad real de ellos.

var foo = someSwiftString as NSString

o

var foo = "Foo" as NSString

o

var foo: NSString = "blah"

Y luego, todo el mundo de operaciones simples de cadenas NSString está abierto para usted.

Como respuesta a la pregunta

// 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()función elimina el último elemento de la cadena.

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

Swift 3 : cuando desee eliminar la cadena final:

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

También elimino mi último personaje de String (es decir, texto UILabel ) en la aplicación 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

Como complemento al código anterior, quería eliminar el comienzo de la cadena y no pude encontrar una referencia en ningún lado. Así es como lo hice:

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

Esto recorta 17 caracteres desde el comienzo de la cadena (la longitud total de la cadena es 67, avanzamos -50 desde el final y ahí lo tiene.