Comment puis-je supprimer le dernier caractère de la variable String à l'aide de Swift? Impossible de le trouver dans la documentation.

Voici un exemple complet:

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

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

Les API sont devenues un peu plus rapides et, par conséquent, l'extension Foundation a un peu changé:

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

Ou la version sur place:

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

Merci Zmey, Rob Allen!

Swift 2.0+ Way

Il existe plusieurs façons d'y parvenir:

Via l'extension Foundation, bien que ne faisant pas partie de la bibliothèque Swift:

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

En utilisant la removeRange()méthode (qui modifie laname ):

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

En utilisant le dropLast() fonction:

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

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

Étant donné que les Stringtypes dans Swift visent à fournir une excellente prise en charge UTF-8, vous ne pouvez plus accéder aux index / plages / sous-chaînes de caractères à l'aide de Inttypes. Au lieu de cela, vous utilisez 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"

Alternativement (pour un exemple plus pratique, mais moins pédagogique), vous pouvez utiliser endIndex:

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

Remarque: j'ai trouvé cela un excellent point de départ pour comprendreString.Index

Ancienne (pré-bêta 4)

Vous pouvez simplement utiliser la substringToIndex()fonction, en lui fournissant un de moins que la longueur de String:

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

La dropLast()fonction globale fonctionne sur les séquences et donc sur les chaînes:

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

Dans Swift 2, procédez comme suit:

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

Je recommande ce lien pour comprendre les chaînes Swift.

Swift 4/5

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

Il s'agit d'un formulaire d'extension de chaîne :

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

pour les versions de Swift antérieures à 1.2:

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

Usage:

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

Référence:

Les extensions ajoutent de nouvelles fonctionnalités à une classe, une structure ou un type d'énumération existants. Cela inclut la possibilité d'étendre les types pour lesquels vous n'avez pas accès au code source d'origine (connu sous le nom de modélisation rétroactive). Les extensions sont similaires aux catégories d'Objective-C. (Contrairement aux catégories Objective-C, les extensions Swift n'ont pas de nom.)

Voir DOCS

Utilisez la fonction removeAtIndex(i: String.Index) -> Character:

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

La façon la plus simple de couper le dernier caractère de la chaîne est:

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

Swift 4

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

ou

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

ou

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"

Une catégorie rapide qui mute:

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

Utilisation:

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

Réponse courte (valable à partir du 16/04/2015): removeAtIndex(myString.endIndex.predecessor())

Exemple:

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

Meta:

Le langage poursuit son évolution rapide, ce qui rend la demi-vie de nombreuses réponses SO autrefois bonnes dangereusement brèves. Il est toujours préférable d'apprendre la langue et de se référer à une vraie documentation .

Avec la nouvelle utilisation du type de sous-chaîne:

Swift 4:

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

Manière plus courte:

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

Utilisez la fonction advance(startIndex, endIndex):

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

Une autre façon Si vous souhaitez supprimer un ou plusieurs caractères de la fin.

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

Où XX est le nombre de caractères que vous souhaitez supprimer.

Swift 3 (selon les documents ) 20 novembre 2016

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

Je recommanderais d'utiliser NSString pour les chaînes que vous souhaitez manipuler. En fait, j'y pense en tant que développeur que je n'ai jamais rencontré de problème avec NSString que Swift String pourrait résoudre ... Je comprends les subtilités. Mais je n'ai pas encore vraiment besoin d'eux.

var foo = someSwiftString as NSString

ou

var foo = "Foo" as NSString

ou

var foo: NSString = "blah"

Et puis le monde entier des opérations de chaîne NSString simples vous est ouvert.

Comme réponse à la question

// 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()fonction supprime le dernier élément de la chaîne.

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

Swift 3 : Lorsque vous souhaitez supprimer la chaîne de fin:

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

Je supprime également mon dernier caractère de la chaîne (c'est-à- dire le texte UILabel ) dans l'application 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

complémentaire au code ci-dessus, je voulais supprimer le début de la chaîne et je n'ai trouvé aucune référence nulle part. Voici comment je l'ai fait:

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

Cela coupe 17 caractères depuis le début de la chaîne (la longueur totale de la chaîne est de 67, nous avançons de -50 à partir de la fin et vous l'avez.