Jak mogę usunąć ostatni znak ze zmiennej String za pomocą Swift? Nie mogę tego znaleźć w dokumentacji.

Oto pełny przykład:

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

Swift 4.0 (także 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

Interfejsy API stały się nieco szybsze , w wyniku czego rozszerzenie Foundation zmieniło się nieco:

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

Lub wersja na miejscu:

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

Dzięki Zmey, Rob Allen!

Swift 2.0+ Way

Istnieje kilka sposobów na osiągnięcie tego:

Za pośrednictwem rozszerzenia Foundation, mimo że nie jest częścią biblioteki Swift:

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

Korzystając z removeRange()metody (co ołtarze z name):

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

Korzystanie z dropLast()funkcji:

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

Stary ciąg.Indeks (Xcode 6 Beta 4 +) Sposób

Ponieważ Stringtypy w Swift mają na celu zapewnienie doskonałej obsługi UTF-8, nie można już uzyskać dostępu do indeksów / zakresów / podciągów znaków przy użyciu Inttypów. Zamiast tego używasz 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"

Alternatywnie (dla bardziej praktycznego, ale mniej edukacyjnego przykładu) możesz użyć endIndex:

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

Uwaga: znalazłem to być doskonałym punktem wyjścia do zrozumieniaString.Index

Old (pre-Beta 4) Way

Możesz po prostu użyć substringToIndex()funkcji, podając ją o jeden mniej niż długość String:

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

Funkcja globalna dropLast()działa na sekwencjach, a zatem na ciągach:

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

W Swift 2 wykonaj następujące czynności:

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

Polecam ten link, aby zrozumieć ciągi znaków Swift.

Swift 4/5

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

To jest formularz rozszerzenia ciągu:

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

dla wersji Swift wcześniejszych niż 1.2:

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

Stosowanie:

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

Odniesienie:

Rozszerzenia dodają nową funkcjonalność do istniejącej klasy, struktury lub typu wyliczenia. Obejmuje to możliwość rozszerzenia typów, dla których nie masz dostępu do oryginalnego kodu źródłowego (znanego jako modelowanie retroaktywne). Rozszerzenia są podobne do kategorii w Objective-C. (W przeciwieństwie do kategorii Objective-C rozszerzenia Swift nie mają nazw).

Zobacz DOCS

Użyj funkcji removeAtIndex(i: String.Index) -> Character:

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

Najłatwiejszym sposobem przycięcia ostatniego znaku ciągu jest:

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

Szybki 4

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

lub

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

lub

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"

Szybka kategoria, która mutuje:

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

Posługiwać się:

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

Krótka odpowiedź (aktualna na dzień 16.04.2015): removeAtIndex(myString.endIndex.predecessor())

Przykład:

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

Meta:

Język kontynuuje szybką ewolucję, przez co okres półtrwania dla wielu wcześniej dobrych odpowiedzi SO jest niebezpiecznie krótki. Zawsze najlepiej jest uczyć się języka i odwoływać się do prawdziwej dokumentacji .

Dzięki zastosowaniu nowego typu podciągów:

Swift 4:

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

Krótsza droga:

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

Użyj funkcji advance(startIndex, endIndex):

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

Inny sposób Jeśli chcesz usunąć jedną lub więcej postaci z końca.

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

Gdzie XX to liczba znaków, które chcesz usunąć.

Swift 3 (zgodnie z dokumentami ) 20 listopada 2016

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

Polecam użycie NSString dla ciągów, którymi chcesz manipulować. Właściwie to myślę o tym jako o deweloperze. Nigdy nie miałem problemu z NSString, który rozwiązałby Swift String ... Rozumiem subtelności. Ale jeszcze ich potrzebuję.

var foo = someSwiftString as NSString

lub

var foo = "Foo" as NSString

lub

var foo: NSString = "blah"

A potem cały świat prostych operacji łańcuchowych NSString jest dla Ciebie otwarty.

Jako odpowiedź na pytanie

// check bounds before you do this, e.g. foo.length > 0
// Note shortFoo is of type NSString
var shortFoo = foo.substringToIndex(foo.length-1)

dropLast()Funkcja usuwa ostatni element łańcucha.

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

Swift 3 : Gdy chcesz usunąć końcowy ciąg:

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

Szybki 4.2

Usuwam również mój ostatni znak z ciągu (tj. Tekst UILabel ) w aplikacji 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

Oprócz powyższego kodu chciałem usunąć początek łańcucha i nie mogłem nigdzie znaleźć odwołania. Oto jak to zrobiłem:

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

To przycina 17 znaków od początku łańcucha (jego całkowita długość wynosi 67, awansujemy o -50 od końca i gotowe.