it-swarm.com.de

Entferne das letzte Zeichen aus der Zeichenkette. Schnelle Sprache

Wie kann ich mit Swift das letzte Zeichen aus der String-Variablen entfernen? Kann es nicht in der Dokumentation finden.

Hier ist ein vollständiges Beispiel:

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

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

Die APIs haben etwas mehr swifty bekommen, und die Foundation-Erweiterung hat sich dadurch etwas geändert:

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

Oder die In-Place-Version:

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

Danke Zmey, Rob Allen!

Swift 2.0+ Way

Dafür gibt es mehrere Möglichkeiten:

Über die Erweiterung der Stiftung, obwohl sie nicht Teil der Swift-Bibliothek ist:

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

Verwenden der removeRange()-Methode (welche ändert die name):

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

Verwenden der dropLast()-Funktion:

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

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

Da String-Typen in Swift exzellente UTF-8-Unterstützung bieten, können Sie nicht mehr auf Zeichenindizes/Bereiche/Teilzeichenfolgen mit Int-Typen zugreifen. Stattdessen verwenden Sie 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"

Alternativ (für ein praktischeres, aber weniger lehrreiches Beispiel) können Sie endIndex verwenden:

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

Hinweis: Ich fand, dass this ein guter Ausgangspunkt für das Verständnis von String.Index ist

Alter (vor Beta 4) Weg

Sie können einfach die substringToIndex()-Funktion verwenden, die weniger als die Länge der String ist:

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

Die globale Funktion dropLast() funktioniert in Sequenzen und somit in Strings: 

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

Schnell 4:

let choppedString = String(theString.dropLast())

In Swift 2 tun Sie dies:

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

Ich empfehle this link, um Swift-Strings zu verstehen.

67
jrc

Dies ist ein String Erweiterungsformular: 

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

für Versionen von Swift vor 1.2:

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

Verwendungszweck:

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

Referenz:

Erweiterungen fügen einer vorhandenen Klasse, Struktur oder Aufzählungstyp neue Funktionen hinzu. Dies beinhaltet die Möglichkeit, Typen zu erweitern, für die Sie keinen Zugriff auf den ursprünglichen Quellcode haben (als rückwirkende Modellierung bezeichnet). Erweiterungen ähneln Kategorien in Objective-C. (Im Gegensatz zu Objective-C-Kategorien haben Swift-Erweiterungen keine Namen.)

Siehe DOCS

8
Maxim Shoustin

Verwenden Sie die Funktion removeAtIndex(i: String.Index) -> Character:

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

Das letzte Zeichen der Zeichenfolge kann am einfachsten getrimmt werden:

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

Swift 4

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

oder

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

oder

welcome = String(welcome.dropLast())
5
Carien van Zyl

Mit der neuen Verwendung des Substring-Typs:

Schnell 4:

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

Kürzerer Weg:

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

Kurze Antwort (gültig ab 16.04.2015): removeAtIndex(myString.endIndex.predecessor())

Beispiel:

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

Meta:

Die Sprache setzt ihre rasante Entwicklung fort und macht die Halbwertszeit für viele ehemals gute S.O. antwortet gefährlich kurz. Es ist immer am besten, die Sprache zu lernen und auf echte Dokumentation zu verweisen.

2
cweekly
var str = "Hello, playground"

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

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

Eine schnelle Kategorie, die mutiert:

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

Benutzen: 

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

Verwenden Sie die Funktion advance(startIndex, endIndex):

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

Ein anderer Weg Wenn Sie ein oder mehrere als ein Zeichen vom Ende entfernen möchten. 

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

Dabei istXXdie Anzahl der Zeichen, die Sie entfernen möchten. 

1
Kaiusee

Swift 3 (laut docs ) 20. November 2016

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

Swift 3 : Wenn Sie die nachfolgende Zeichenfolge entfernen möchten:

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

Ich würde empfehlen, NSString für Strings zu verwenden, die Sie bearbeiten möchten. Eigentlich denke ich daran, dass ich als Entwickler noch nie ein Problem mit NSString hatte, das Swift String lösen würde ... Ich verstehe die Feinheiten. Aber ich habe noch keine Notwendigkeit für sie. 

var foo = someSwiftString as NSString

oder 

var foo = "Foo" as NSString

oder

var foo: NSString = "blah"

Und dann steht Ihnen die ganze Welt der einfachen NSString-Stringoperationen offen.

Als Antwort auf die Frage

// 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

ergänzend zum obigen Code wollte ich den Anfang des Strings entfernen und konnte nirgendwo einen Verweis finden. So habe ich es gemacht:

            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

Dies schneidet 17 Zeichen ab dem Anfang der Zeichenfolge ab (die Gesamtlänge der Zeichenfolge beträgt 67, wir gehen um -50 vom Ende aus und haben es dort. 

0
Sophman

Swift 4.2

Ich lösche auch mein letztes Zeichen aus String (d. H. UILabel text) in der App 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

Die Funktion dropLast() entfernt das letzte Element der Zeichenfolge.

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

Schnell 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