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


Réponses:


540

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"

Sur Xcode 6 beta 6: 'String' n'a pas de membre nommésubstringToIndex
ielyamani

2
Hé, attention, assurez-vous que ce substringToIndexne l' est pas substringFromIndex. Cela ne vous fait pas vous sentir intelligent en vous trompant, laissez-moi vous dire.
Louie Bertoncin

2
C'est vrai, depuis le 21 juillet, Xcode 7 Beta 4 indique que 'String' n'a pas de membre nommé substringToIndex. De plus, depuis Xcode 7, la chaîne n'a plus de .countpropriété, elle n'est désormais appliquée qu'aux caractères:string.characters.count
kakubei

2
Swift 3:var truncated = name.substring(to: name.index(before: name.endIndex))
Zmey

2
Votre réponse est l'histoire de l'évolution rapide.
DawnSong

89

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

3
Dans Swift 2.0, la characterspropriété sur une chaîne génère une séquence, vous devez donc maintenant utiliser: expression = expression.characters.dropLast()
gui_dos

5
Dans Swift 2.0 pour avoir à lancer correctement le résultat expression = String(expression.characters.dropLast())si vous le souhaitez en tant que chaîne
cromanelli

69

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.


9

Swift 4/5

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

8

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


Salut, avez-vous testé des emojis?
ZYiOS

@ZuYuan qu'est-ce que les emojis?
Maxim Shoustin

6

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

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

5

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

Merci, une manière très élégante de supprimer autant de caractères que vous le souhaitez à la fin d'une chaîne.
Letaief Achraf

5

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

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

2
var str = "Hello, playground"

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

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

kkkk Je ne me souvenais même pas de celui-ci (Swift 1.2 ci-dessus). pour la version Swift 3 stackoverflow.com/a/40028338/2303865
Leo Dabus

2

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"

2

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 .


2

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

1

Utilisez la fonction advance(startIndex, endIndex):

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

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)

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


1

Swift 3 (selon les documents ) 20 novembre 2016

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

0

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)

0

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

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

0

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

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

}

IOS APP StoryBoard


0
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

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.