Bất kỳ cách nào để thay thế các ký tự trên Swift String?

Tôi đang tìm cách thay thế các nhân vật trong Swift String.

Ví dụ: "Đây là chuỗi của tôi"

Tôi muốn thay thế "" bằng "+" để có được "This + is + my + string".

Làm thế nào tôi có thể đạt được điều này?

Câu trả lời này đã được cập nhật cho Swift 4 & 5 . Nếu bạn vẫn đang sử dụng Swift 1, 2 hoặc 3, hãy xem lịch sử sửa đổi.

Bạn có một cặp đôi tùy chọn. Bạn có thể làm như @jaumard đề xuất và sử dụngreplacingOccurrences()

let aString = "This is my string"
let newString = aString.replacingOccurrences(of: " ", with: "+", options: .literal, range: nil)

Và như được lưu ý bởi @cprcrack bên dưới, các tham số optionsvà rangelà tùy chọn, vì vậy nếu bạn không muốn chỉ định các tùy chọn so sánh chuỗi hoặc một phạm vi để thực hiện thay thế bên trong, bạn chỉ cần những điều sau đây.

let aString = "This is my string"
let newString = aString.replacingOccurrences(of: " ", with: "+")

Hoặc, nếu dữ liệu có định dạng cụ thể như thế này, khi bạn chỉ thay thế các ký tự phân tách, bạn có thể sử dụng components()để ngắt chuỗi thành và mảng, sau đó bạn có thể sử dụng join()hàm để đặt chúng trở lại cùng với một dấu phân cách được chỉ định .

let toArray = aString.components(separatedBy: " ")
let backToString = toArray.joined(separator: "+")

Hoặc nếu bạn đang tìm kiếm một giải pháp Swifty khác không sử dụng API từ NSString, bạn có thể sử dụng giải pháp này.

let aString = "Some search text"

let replaced = String(aString.map {
    $0 == " " ? "+" : $0
})

Bạn có thể sử dụng điều này:

let s = "This is my string"
let modified = s.replace(" ", withString:"+")    

Nếu bạn thêm phương thức tiện ích mở rộng này vào bất cứ đâu trong mã của bạn:

extension String
{
    func replace(target: String, withString: String) -> String
    {
       return self.stringByReplacingOccurrencesOfString(target, withString: withString, options: NSStringCompareOptions.LiteralSearch, range: nil)
    }
}

Swift 3:

extension String
{
    func replace(target: String, withString: String) -> String
    {
        return self.replacingOccurrences(of: target, with: withString, options: NSString.CompareOptions.literal, range: nil)
    }
}

Giải pháp Swift 3, Swift 4, Swift 5

let exampleString = "Example string"

//Solution suggested above in Swift 3.0
let stringToArray = exampleString.components(separatedBy: " ")
let stringFromArray = stringToArray.joined(separator: "+")

//Swiftiest solution
let swiftyString = exampleString.replacingOccurrences(of: " ", with: "+")

Bạn đã kiểm tra điều này:

var test = "This is my string"

let replaced = test.stringByReplacingOccurrencesOfString(" ", withString: "+", options: nil, range: nil)

Swift 4:

let abc = "Hello world"

let result = abc.replacingOccurrences(of: " ", with: "_", 
    options: NSString.CompareOptions.literal, range:nil)

print(result :\(result))

Đầu ra:

result : Hello_world

Tôi đang sử dụng tiện ích mở rộng này:

extension String {

    func replaceCharacters(characters: String, toSeparator: String) -> String {
        let characterSet = NSCharacterSet(charactersInString: characters)
        let components = self.componentsSeparatedByCharactersInSet(characterSet)
        let result = components.joinWithSeparator("")
        return result
    }

    func wipeCharacters(characters: String) -> String {
        return self.replaceCharacters(characters, toSeparator: "")
    }
}

Sử dụng:

let token = "<34353 43434>"
token.replaceCharacters("< >", toString:"+")

Một giải pháp Swift 3 dọc theo dòng của Sunkas:

extension String {
    mutating func replace(_ originalString:String, with newString:String) {
        self = self.replacingOccurrences(of: originalString, with: newString)
    }
}

Sử dụng:

var string = "foo!"
string.replace("!", with: "?")
print(string)

Đầu ra:

foo?

Một thể loại sửa đổi một chuỗi có thể thay đổi hiện có:

extension String
{
    mutating func replace(originalString:String, withString newString:String)
    {
        let replacedString = self.stringByReplacingOccurrencesOfString(originalString, withString: newString, options: nil, range: nil)
        self = replacedString
    }
}

Sử dụng:

name.replace(" ", withString: "+")

Giải pháp Swift 3 dựa trên câu trả lời của Ramis :

extension String {
    func withReplacedCharacters(_ characters: String, by separator: String) -> String {
        let characterSet = CharacterSet(charactersIn: characters)
        return components(separatedBy: characterSet).joined(separator: separator)
    }
}

Đã thử đưa ra một tên chức năng phù hợp theo quy ước đặt tên Swift 3.

Ít xảy ra với tôi, tôi chỉ muốn thay đổi (một từ hoặc ký tự) trong String

Vì vậy, tôi đã sử dụng Dictionary

  extension String{
    func replace(_ dictionary: [String: String]) -> String{
          var result = String()
          var i = -1
          for (of , with): (String, String)in dictionary{
              i += 1
              if i<1{
                  result = self.replacingOccurrences(of: of, with: with)
              }else{
                  result = result.replacingOccurrences(of: of, with: with)
              }
          }
        return result
     }
    }

sử dụng

let mobile = "+1 (800) 444-9999"
let dictionary = ["+": "00", " ": "", "(": "", ")": "", "-": ""]
let mobileResult = mobile.replace(dictionary)
print(mobileResult) // 001800444999

var str = "This is my string"
str = str.replacingOccurrences(of: " ", with: "+")
print(str)

Tôi nghĩ Regex là cách linh hoạt và vững chắc nhất:

var str = "This is my string"
let regex = try! NSRegularExpression(pattern: " ", options: [])
let output = regex.stringByReplacingMatchesInString(
    str,
    options: [],
    range: NSRange(location: 0, length: str.characters.count),
    withTemplate: "+"
)
// output: "This+is+my+string"

Tiện ích mở rộng:

extension String {

    func stringByReplacing(replaceStrings set: [String], with: String) -> String {
        var stringObject = self
        for string in set {
            stringObject = self.stringByReplacingOccurrencesOfString(string, withString: with)
        }
        return stringObject
    }

}

Tiếp tục và sử dụng nó như let replacedString = yorString.stringByReplacing(replaceStrings: [" ","?","."], with: "+")

Tốc độ của chức năng là điều mà tôi khó có thể tự hào, nhưng bạn có thể vượt qua một mảng Stringtrong một lần để thực hiện nhiều hơn một lần thay thế.

Dưới đây là ví dụ cho Swift 3:

var stringToReplace = "This my string"
if let range = stringToReplace.range(of: "my") {
   stringToReplace?.replaceSubrange(range, with: "your")
} 

Điều này là dễ dàng trong nhanh chóng 4.2. chỉ sử dụng replacingOccurrences(of: " ", with: "_")để thay thế

var myStr = "This is my string"
let replaced = myStr.replacingOccurrences(of: " ", with: "_")
print(replaced)

Xcode 11 • Swift 5.1

Phương thức đột biến của StringProtocol replacingOccurrencescó thể được thực hiện như sau:

extension RangeReplaceableCollection where Self: StringProtocol {
    mutating func replaceOccurrences<Target: StringProtocol, Replacement: StringProtocol>(of target: Target, with replacement: Replacement, options: String.CompareOptions = [], range searchRange: Range<String.Index>? = nil) {
        self = .init(replacingOccurrences(of: target, with: replacement, options: options, range: searchRange))
    }
}

var name = "This is my string"
name.replaceOccurrences(of: " ", with: "+")
print(name) // "This+is+my+string\n"

Nếu bạn không muốn sử dụng các NSStringphương thức Objective-C , bạn chỉ có thể sử dụng splitvà join:

var string = "This is my string"
string = join("+", split(string, isSeparator: { $0 == " " }))

split(string, isSeparator: { $0 == " " })trả về một chuỗi các chuỗi ( ["This", "is", "my", "string"]).

joinnối các phần tử này với a +, dẫn đến đầu ra mong muốn : "This+is+my+string".

Tôi đã thực hiện chức năng rất đơn giản này:

func convap (text : String) -> String {
    return text.stringByReplacingOccurrencesOfString("'", withString: "''")
}

Vì vậy, bạn có thể viết:

let sqlQuery = "INSERT INTO myTable (Field1, Field2) VALUES ('\(convap(value1))','\(convap(value2)')

bạn có thể kiểm tra điều này:

hãy để newString = test.opesByReplacesOccurrencesOfString ("", withString: "+", các tùy chọn: nil, phạm vi: nil)

Đây là một tiện ích mở rộng cho phương thức thay thế tại chỗ String, không phải là bản sao không cần thiết và thực hiện mọi thứ tại chỗ:

extension String {
    mutating func replaceOccurrences<Target: StringProtocol, Replacement: StringProtocol>(of target: Target, with replacement: Replacement, options: String.CompareOptions = [], locale: Locale? = nil) {
        var range: Range<Index>?
        repeat {
            range = self.range(of: target, options: options, range: range.map { self.index($0.lowerBound, offsetBy: replacement.count)..<self.endIndex }, locale: locale)
            if let range = range {
                self.replaceSubrange(range, with: replacement)
            }
        } while range != nil
    }
}

(Chữ ký phương thức cũng bắt chước chữ ký của String.replacingOccurrences()phương thức dựng sẵn )

Có thể được sử dụng theo cách sau:

var string = "this is a string"
string.replaceOccurrences(of: " ", with: "_")
print(string) // "this_is_a_string"