web-dev-qa-db-fra.com

Supprimer le dernier caractère de la chaîne. Langue rapide

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)
stringcharacterswift
201
Konstantin Cherkasov

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

Les API ont reçu un peu plus de swifty _, ce qui a eu pour conséquence l'extension de l'extension Foundation:

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

Ou la version en 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 y a plusieurs façons d'accomplir cela:

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"

Utilisation de la méthode removeRange() (qui modifie _ la name):

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

Utilisation de la fonction dropLast():

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

Old String.Index (Xcode 6 Beta 4 +)

Étant donné que les types String 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 utilisant les types Int. 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 éducatif), vous pouvez utiliser endIndex:

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

Note: J'ai trouvé ceci être un excellent point de départ pour comprendre String.Index

Ancien (pré-bêta 4) Way

Vous pouvez simplement utiliser la fonction substringToIndex() en lui fournissant une longueur inférieure à la longueur de la variable String:

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

La fonction globale dropLast() 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())
88
gui_dos

Swift 4:

let choppedString = String(theString.dropLast())

Dans Swift 2, procédez comme suit:

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

Je recommande this link pour comprendre les chaînes Swift.

67
jrc

Ceci est une forme de chaîne extension: 

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 existant. Cela inclut la possibilité d'étendre des 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 dans Objective-C. (Contrairement aux catégories Objective-C, les extensions Swift n'ont pas de nom.)

Voir DOCS

8
Maxim Shoustin

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

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

Le moyen le plus simple de couper le dernier caractère de la chaîne est le suivant:

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

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())
5
Carien van Zyl

Avec la nouvelle utilisation du type Substring:

Swift 4:

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

Chemin plus court:

var before: String = "Hello world!"
after = String(before[..<before.endIndex])
print(after) // Hello world
2
Jorge Ramírez
let str = "abc"
let substr = str.substringToIndex(str.endIndex.predecessor())  // "ab"
2
Channing

Réponse courte (valide à partir du 2015-04-16): 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:

La langue poursuit son évolution rapide, faisant de la demi-vie de beaucoup de bons anciens S.O. réponses dangereusement brèves. Il est toujours préférable d'apprendre la langue et de se référer à real documentation .

2
cweekly
var str = "Hello, playground"

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

println(str.stringByDeletingLastCharacter)   // "Hello, playgroun"
2
Leo Dabus

Une catégorie Swift en mutation:

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"
1
Sunkas

Utilisez la fonction advance(startIndex, endIndex):

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

Une autre façon Si vous voulez supprimer un ou plusieurs qu’un caractère de la fin. 

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

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

1
Kaiusee

Swift 3 (selon les docs ) 20 nov. 2016

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

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

Je vous recommande d'utiliser NSString pour les chaînes que vous souhaitez manipuler. En fait, en tant que développeur, 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 eu réellement besoin d'eux. 

var foo = someSwiftString as NSString

ou 

var foo = "Foo" as NSString

ou

var foo: NSString = "blah"

Et tout le monde des opérations simples sur les chaînes NSString vous est ouvert.

En 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)
0
n13

complémentaire du code ci-dessus, je souhaitais supprimer le début de la chaîne et ne trouvais aucune référence. 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 du 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 voilà. 

0
Sophman

Swift 4.2

Je supprime également mon dernier caractère de String (i.e. UILabel text) 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

}

 IOS APP StoryBoard

0
Ashfaqur_Rahman

La fonction dropLast() supprime le dernier élément de la chaîne.

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

Swift 4

var str = "bla"
str.removeLast() // returns "a"; str is now "bl"
0
idrougge
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
0
Deepak Tagadiya