Swift를 사용하여 String 변수에서 마지막 문자를 제거하려면 어떻게합니까? 설명서에서 찾을 수 없습니다.

전체 예는 다음과 같습니다.

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

스위프트 4.0 (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)

스위프트 3.0

API가 조금 더 빨라 졌으며 결과적으로 Foundation 확장이 약간 변경되었습니다.

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

또는 전체 버전 :

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

감사합니다 Zmey, Rob Allen!

스위프트 2.0 이상

이를 수행하는 몇 가지 방법이 있습니다.

Swift 라이브러리의 일부가 아니지만 Foundation 확장을 통해 :

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

은 Using removeRange()(이 방법 달라져 를 name)

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

dropLast()기능 사용하기 :

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

Old String.Index (Xcode 6 Beta 4 +) 방식

이후 String스위프트의 유형이 우수한 UTF-8 지원을 제공하는 것을 목표로, 당신은 더 이상 액세스 문자 인덱스 / 범위 / 문자열을 사용 할 수 있습니다 Int유형. 대신 다음을 사용하십시오 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"

또는 (실용적이지만 덜 교육적인 예를 위해) 다음을 사용할 수 있습니다 endIndex.

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

참고 : 나는 이것을 이해하기위한 훌륭한 출발점이라고 생각했다.String.Index

올드 (베타 4 이전) 방식

단순히 substringToIndex()함수의 길이를 1보다 짧게 제공하여 사용할 수 있습니다 String.

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

전역 dropLast()함수는 시퀀스와 문자열에서 작동합니다.

var expression  = "45+22"
expression = dropLast(expression)  // "45+2"

// in Swift 2.0 (according to cromanelli's comment below)
expression = String(expression.characters.dropLast())

스위프트 4 :

let choppedString = String(theString.dropLast())

Swift 2에서 다음을 수행하십시오.

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

Swift 문자열을 이해하려면 이 링크를 사용하는 것이 좋습니다 .

스위프트 4/5

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

이것은 문자열 확장 양식입니다.

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

1.2 이전의 Swift 버전 :

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

용법:

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

참고:

확장은 기존 클래스, 구조 또는 열거 유형에 새로운 기능을 추가합니다. 여기에는 원본 소스 코드에 액세스 할 수없는 유형을 확장하는 기능 (소급 적 모델링이라고 함)이 포함됩니다. 확장은 Objective-C의 범주와 유사합니다. Objective-C 범주와 달리 Swift 확장에는 이름이 없습니다.

DOCS 참조

기능을 사용하십시오 removeAtIndex(i: String.Index) -> Character:

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

문자열의 마지막 문자를 자르는 가장 쉬운 방법은 다음과 같습니다.

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

스위프트 4

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

또는

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

또는

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"

변화하는 신속한 카테고리 :

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

사용하다:

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

짧은 답변 (2015-04-16 기준) : removeAtIndex(myString.endIndex.predecessor())

예:

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

메타 :

이 언어는 빠른 발전을 이어가고 있으며, 이전에 좋은 SO 답변의 반감기가 위험하게 짧아졌습니다. 언어를 배우고 실제 문서를 참조하는 것이 가장 좋습니다 .

새로운 하위 문자열 유형 사용법 :

스위프트 4 :

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

더 짧은 방법 :

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

기능을 사용하십시오 advance(startIndex, endIndex):

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

또 다른 방법은 당신이 제거하려는 경우 하나 이상의 끝에서 이상의 문자를.

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

여기서 XX 는 제거 할 문자 수입니다.

스위프트 3 ( 문서 에 따라 ) 2016 년 11 월 20 일

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

조작하려는 문자열에 NSString을 사용하는 것이 좋습니다. 실제로 Swift String이 해결할 NSString 관련 문제를 결코 겪지 않은 개발자로 생각하게됩니다 ... 미묘한 점을 이해합니다. 그러나 아직 실제적으로 필요한 것은 없습니다.

var foo = someSwiftString as NSString

또는

var foo = "Foo" as NSString

또는

var foo: NSString = "blah"

그리고 간단한 NSString 문자열 연산의 전 세계가 열려 있습니다.

질문에 대한 답변으로

// 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()함수는 문자열의 마지막 요소를 제거합니다.

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

Swift 3 : 후행 문자열을 제거하려는 경우 :

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

스위프트 4.2

또한 IOS 앱의 String (예 : UILabel text )에서 마지막 문자를 삭제 합니다.

@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

위의 코드를 무료로 사용하여 문자열의 시작 부분을 제거하고 어디에서나 참조를 찾을 수 없었습니다. 내가 한 방법은 다음과 같습니다.

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

이것은 문자열의 시작 부분에서 17 문자를 다듬습니다 (총 문자열 길이는 67입니다.