假设我这里有一个字符串:

var fullName: String = "First Last"

我想在空白处拆分字符串,并将值分配给它们各自的变量

var fullNameArr = // something like: fullName.explode(" ") 

var firstName: String = fullNameArr[0]
var lastName: String? = fullnameArr[1]

此外,有时用户可能没有姓氏。


当前回答

只有拆分才是正确的答案,这里有两个以上空格的差异。

雨燕5

var temp = "Hello world     ni hao"
let arr  = temp.components(separatedBy: .whitespacesAndNewlines)
// ["Hello", "world", "", "", "", "", "ni", "hao"]
let arr2 = temp.components(separatedBy: " ")
// ["Hello", "world", "", "", "", "", "ni", "hao"]
let arr3 = temp.split(whereSeparator: {$0 == " "})
// ["Hello", "world", "ni", "hao"]

其他回答

斯威夫特4

let string = "loremipsum.dolorsant.amet:"

let result = string.components(separatedBy: ".")

print(result[0])
print(result[1])
print(result[2])
print("total: \(result.count)")

输出

loremipsum
dolorsant
amet:
total: 3

空白问题

一般来说,人们会一次又一次地重复这个问题和糟糕的解决方案。这是一个空间吗?“”以及“\n”、“\t”或一些您从未见过的unicode空白字符,在很大程度上是不可见的。虽然你可以逃脱

弱解决方案

import Foundation
let pieces = "Mary had little lamb".componentsSeparatedByString(" ")

如果你需要在现实中动摇你的控制,请观看WWDC视频中的字符串或日期。简而言之,让苹果解决这类平凡的任务几乎总是更好的。

稳健的解决方案:使用NSCharacterSet

IMHO,正确做到这一点的方法是使用NSCharacterSet,因为正如前面所述,您的空白可能不是您所期望的,并且Apple提供了一个空白字符集。要探索提供的各种字符集,请查看Apple的NSCharacterSet开发人员文档,然后,如果不符合您的需要,才可以扩充或构建新的字符集。

NSCharacterSet空白

返回包含Unicode常规中的字符的字符集Z类和字符表(U+0009)。

let longerString: String = "This is a test of the character set splitting system"
let components = longerString.components(separatedBy: .whitespaces)
print(components)

您可以使用此公共函数并添加任何要分隔的字符串

func separateByString(String wholeString: String, byChar char:String) -> [String] {

    let resultArray = wholeString.components(separatedBy: char)
    return resultArray
}

var fullName: String = "First Last"
let array = separateByString(String: fullName, byChar: " ")
var firstName: String = array[0]
var lastName: String = array[1]
print(firstName)
print(lastName)

这里是我刚刚构建的一个算法,它将通过数组中的任何字符分割字符串,如果有任何希望保留具有分割字符的子字符串,可以将swall参数设置为true。

Xcode 7.3-Swift 2.2:

extension String {

    func splitBy(characters: [Character], swallow: Bool = false) -> [String] {

        var substring = ""
        var array = [String]()
        var index = 0

        for character in self.characters {

            if let lastCharacter = substring.characters.last {

                // swallow same characters
                if lastCharacter == character {

                    substring.append(character)

                } else {

                    var shouldSplit = false

                    // check if we need to split already
                    for splitCharacter in characters {
                        // slit if the last character is from split characters or the current one
                        if character == splitCharacter || lastCharacter == splitCharacter {

                            shouldSplit = true
                            break
                        }
                    }

                    if shouldSplit {

                        array.append(substring)
                        substring = String(character)

                    } else /* swallow characters that do not equal any of the split characters */ {

                        substring.append(character)
                    }
                }
            } else /* should be the first iteration */ {

                substring.append(character)
            }

            index += 1

            // add last substring to the array
            if index == self.characters.count {

                array.append(substring)
            }
        }

        return array.filter {

            if swallow {

                return true

            } else {

                for splitCharacter in characters {

                    if $0.characters.contains(splitCharacter) {

                        return false
                    }
                }
                return true
            }
        }
    }
}

例子:

"test text".splitBy([" "]) // ["test", "text"]
"test++text--".splitBy(["+", "-"], swallow: true) // ["test", "++" "text", "--"]

大多数这些答案都假设输入包含一个空格,而不是空白,并且只有一个空格。如果你能安全地做出这样的假设,那么(来自bennett的)公认的答案是相当优雅的,也是我在可能的时候会采用的方法。

当我们无法做出这一假设时,一个更稳健的解决方案需要涵盖以下大多数答案没有考虑的情况:

制表符/换行符/空格(空白),包括重复出现的字符前导/尾随空格Apple/Linux(\n)和Windows(\r\n)换行符

为了涵盖这些情况,此解决方案使用正则表达式将所有空格(包括重复出现的字符和Windows换行符)转换为单个空格,然后修剪,然后拆分为单个空格:

斯威夫特3:

let searchInput = "  First \r\n \n \t\t\tMiddle    Last "
let searchTerms = searchInput 
    .replacingOccurrences(
        of: "\\s+",
        with: " ",
        options: .regularExpression
    )
    .trimmingCharacters(in: .whitespaces)
    .components(separatedBy: " ")

// searchTerms == ["First", "Middle", "Last"]