ultimo - eliminar primer caracter string java

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

Question

¿Cómo puedo eliminar el último carácter de la variable String usando Swift? No se puede encontrar en la documentación.

Aquí está el ejemplo completo:

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

Answer 1

Como complemento al código anterior, quería eliminar el principio de la cadena y no podía 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 tienen).

Answer 2

Con el nuevo uso del tipo Substring:

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

Answer 3

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 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 de Objective-C, las extensiones Swift no tienen nombres).

Ver DOCS

Answer 4

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

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

Answer 5

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

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

Answer 6

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

Answer 7

Otra forma 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.

Answer 8

Recomiendo usar NSString para las cadenas que desea manipular. 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 todavía tengo que tener una necesidad real para 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 cadenas NSString está abierto para ti.

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)

Answer 9

Respuesta corta (válida a partir del 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, lo que hace que la vida media de muchas respuestas de SO que antes eran buenas sea peligrosamente breve. Siempre es mejor aprender el idioma y consultar la documentation real.

Answer 10

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

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

Answer 11

Swift 4:

let choppedString = String(theString.dropLast())

En Swift 2, haz esto:

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

Recomiendo this enlace para obtener una comprensión de las cadenas Swift.

Answer 12

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"

Answer 13

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

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

Answer 14

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

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

Answer 15

Swift 3 : cuando quieres eliminar una 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
    }
}

Answer 16

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

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 maneras de lograr esto:

A través de la extensión de la Fundación, 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 método removeRange() (que altera el name ):

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

Usando la función dropLast() :

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

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

Dado que los tipos String en Swift pretenden proporcionar un excelente soporte UTF-8, ya no puede acceder a los índices / rangos / subcadenas de caracteres utilizando los tipos Int . En su lugar, utiliza 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: encontré que this es un gran punto de partida para comprender String.Index

Viejo (pre-Beta 4) Camino

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

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

Answer 17

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

Answer 18

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

Answer 19

var str = "Hello, playground"

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

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