Eliminar el último carácter de la cadena. Lenguaje rápido

La función global dropLast() 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 obtener una comprensión de las cadenas Swift.

Esta es una cadena Forma de extensión:

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 añaden una nueva funcionalidad a una clase, estructura o tipo de enumeración existente. Esto incluye la capacidad de extender tipos para los que 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 Objective-C, las extensiones Swift no tienen nombres.)

Véase DOCUMENTOS

Utilice 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"

Respuesta corta (válida a partir de 2015-04-16): 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 semivida para muchas respuestas anteriormente buenas S. O. sea peligrosamente breve. Siempre es mejor aprender el idioma y consultar la documentación real .

Con el nuevo tipo de Subcadena uso:

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

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

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

Una categoría swift 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))
    }
}

Uso:

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

De otra manera Si desea eliminar uno o más de un carácter 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)

Recomendaría usar NSString para cadenas que desea manipular. En realidad, ahora que lo pienso como un desarrollador, nunca me he encontrado con un problema con NSString que Swift String resolvería... Entiendo las sutilezas. Pero aún no tengo una necesidad real de ellos.

var foo = someSwiftString as NSString

O

var foo = "Foo" as NSString

O

var foo: NSString = "blah"

Y entonces todo el mundo de operaciones simples de cadena 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)

Complementario al código anterior Quería eliminar el principio de la cadena y no pude encontrar una referencia en ningún lugar. 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 principio de la cadena (la longitud total de la cadena es 67 avanzamos -50 desde el final y ahí lo tienes.

La función dropLast() elimina el último elemento de la cadena.

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