Swift에서 문자열을 배열로 나누시겠습니까?

여기에 문자열이 있다고 가정 해보십시오.

var fullName: String = "First Last"

문자열 기반을 공백으로 나누고 값을 해당 변수에 할당하고 싶습니다.

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

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

또한 때때로 사용자는 성이 없을 수도 있습니다.

스위프트 방식은 split다음과 같이 전역 함수 를 사용하는 것입니다.

var fullName = "First Last"
var fullNameArr = split(fullName) {$0 == " "}
var firstName: String = fullNameArr[0]
var lastName: String? = fullNameArr.count > 1 ? fullNameArr[1] : nil

와 스위프트 2

Swift 2에서는 split의 사용이 내부 CharacterView 유형의 도입으로 인해 조금 더 복잡해졌습니다. 즉, String은 더 이상 SequenceType 또는 CollectionType 프로토콜을 채택하지 않으며 대신 .characters속성을 사용하여 String 인스턴스의 CharacterView 유형 표현에 액세스 해야 합니다. (참고 : CharacterView는 SequenceType 및 CollectionType 프로토콜을 채택합니다).

let fullName = "First Last"
let fullNameArr = fullName.characters.split{$0 == " "}.map(String.init)
// or simply:
// let fullNameArr = fullName.characters.split{" "}.map(String.init)

fullNameArr[0] // First
fullNameArr[1] // Last 

componentsSeparatedByString당신의 방법을 호출fullName

import Foundation

var fullName: String = "First Last"
let fullNameArr = fullName.componentsSeparatedByString(" ")

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

Swift 3 이상 업데이트

import Foundation

let fullName    = "First Last"
let fullNameArr = fullName.components(separatedBy: " ")

let name    = fullNameArr[0]
let surname = fullNameArr[1]

가장 쉬운 방법은 componentsSeparatedBy를 사용하는 것입니다.

스위프트 2의 경우 :

import Foundation
let fullName : String = "First Last";
let fullNameArr : [String] = fullName.componentsSeparatedByString(" ")

// And then to access the individual words:

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

스위프트 3의 경우 :

import Foundation

let fullName : String = "First Last"
let fullNameArr : [String] = fullName.components(separatedBy: " ")

// And then to access the individual words:

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

스위프트 개발 4.0 (2017 년 5 월 24 일)

새로운 기능 splitSwift 4 ( 베타 ).

import Foundation
let sayHello = "Hello Swift 4 2017";
let result = sayHello.split(separator: " ")
print(result)

산출:

["Hello", "Swift", "4", "2017"]

액세스 값 :

print(result[0]) // Hello
print(result[1]) // Swift
print(result[2]) // 4
print(result[3]) // 2017

Xcode 8.1 / 스위프트 3.0.1

배열이있는 여러 구분 기호가 있습니다.

import Foundation
let mathString: String = "12-37*2/5"
let numbers = mathString.components(separatedBy: ["-", "*", "/"])
print(numbers)

산출:

["12", "37", "2", "5"]

스위프트 4 이상

개인 이름을 올바르게 형식화해야하는 경우 PersonNameComponentsFormatter 를 사용할 수 있습니다 .

PersonNameComponentsFormatter 클래스는 PersonNameComponents 객체로 표시되는 사람 이름 구성 요소의 지역화 된 표현을 제공합니다. 이 클래스를 사용하여 사용자 이름 정보를 사용자에게 표시 할 때 현지화 된 이름을 작성하십시오.

// iOS (9.0 and later), macOS (10.11 and later), tvOS (9.0 and later), watchOS (2.0 and later)
let nameFormatter = PersonNameComponentsFormatter()

let name =  "Mr. Steven Paul Jobs Jr."
// personNameComponents requires iOS (10.0 and later)
if let nameComps  = nameFormatter.personNameComponents(from: name) {
    nameComps.namePrefix   // Mr.
    nameComps.givenName    // Steven
    nameComps.middleName   // Paul
    nameComps.familyName   // Jobs
    nameComps.nameSuffix   // Jr.

    // It can also be configured to format your names
    // Default (same as medium), short, long or abbreviated

    nameFormatter.style = .default
    nameFormatter.string(from: nameComps)   // "Steven Jobs"

    nameFormatter.style = .short
    nameFormatter.string(from: nameComps)   // "Steven"

    nameFormatter.style = .long
    nameFormatter.string(from: nameComps)   // "Mr. Steven Paul Jobs jr."

    nameFormatter.style = .abbreviated
    nameFormatter.string(from: nameComps)   // SJ

    // It can also be use to return an attributed string using annotatedString method
    nameFormatter.style = .long
    nameFormatter.annotatedString(from: nameComps)   // "Mr. Steven Paul Jobs jr."
}

편집 / 업데이트 :

스위프트 5 이상

문자가 아닌 문자로 문자열을 나누기 위해 new Character 속성을 사용할 수 있습니다 isLetter.

let fullName = "First Last"

let components = fullName.split{ !$0.isLetter }
print(components)  // "["First", "Last"]\n"

WMios의 답변에 대한 대안으로을 사용할 수도 있습니다 componentsSeparatedByCharactersInSet.이 경우 더 많은 구분 기호 (공백 공간, 쉼표 등)가있는 경우 편리합니다.

특정 입력으로 :

let separators = NSCharacterSet(charactersInString: " ")
var fullName: String = "First Last";
var words = fullName.componentsSeparatedByCharactersInSet(separators)

// words contains ["First", "Last"]

여러 구분 기호 사용 :

let separators = NSCharacterSet(charactersInString: " ,")
var fullName: String = "Last, First Middle";
var words = fullName.componentsSeparatedByCharactersInSet(separators)

// words contains ["Last", "First", "Middle"]

스위프트 4

let words = "these words will be elements in an array".components(separatedBy: " ")

공백 문제

일반적으로 사람들은이 문제와 나쁜 해결책을 계속해서 재창조합니다. 여긴 공간인가요? ""그리고 "\ n", "\ t"또는 전혀 본 적이없는 유니 코드 공백 문자는 보이지 않습니다. 당신이 도망 갈 수있는 동안

약한 솔루션

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

현실을 파악해야하는 경우 문자열이나 날짜로 WWDC 비디오를보십시오. 요컨대, 애플이 이런 종류의 일상적인 작업을 해결하도록하는 것이 거의 항상 좋습니다.

강력한 솔루션 : NSCharacterSet 사용

IMHO는이를 올바르게 수행하는 방법 NSCharacterSet은 앞에서 언급 한대로 공백이 예상 한 것과 다르고 Apple이 공백 문자 세트를 제공했기 때문에 사용 하는 것입니다. 제공되는 다양한 문자 집합을 살펴 보려면 Apple의 NSCharacterSet 개발자 설명서를 확인한 다음 필요에 맞지 않으면 새 문자 집합을 보강하거나 구성하십시오.

NSCharacterSet 공백

유니 코드 일반 카테고리 Z 및 CHARACTER TABULATION (U + 0009)의 문자를 포함하는 문자 세트를 리턴합니다.

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

에서 스위프트 4.2 엑스 코드 (10)

//This is your str
let str = "This is my String" //Here replace with your string

옵션 1

let items = str.components(separatedBy: " ")//Here replase space with your value and the result is Array.
//Direct single line of code
//let items = "This is my String".components(separatedBy: " ")
let str1 = items[0]
let str2 = items[1]
let str3 = items[2]
let str4 = items[3]
//OutPut
print(items.count)
print(str1)
print(str2)
print(str3)
print(str4)
print(items.first!)
print(items.last!)

옵션 2

let items = str.split(separator: " ")
let str1 = String(items.first!)
let str2 = String(items.last!)
//Output
print(items.count)
print(items)
print(str1)
print(str2)

옵션 3

let arr = str.split {$0 == " "}
print(arr)

옵션 4

let line = "BLANCHE:   I don't want realism. I want magic!"
print(line.split(separator: " "))
// Prints "["BLANCHE:", "I", "don\'t", "want", "realism.", "I", "want", "magic!"]"

Apple 문서 별 ....

let line = "BLANCHE:   I don't want realism. I want magic!"
print(line.split(separator: " "))
// Prints "["BLANCHE:", "I", "don\'t", "want", "realism.", "I", "want", "magic!"]"

print(line.split(separator: " ", maxSplits: 1))//This can split your string into 2 parts
// Prints "["BLANCHE:", "  I don\'t want realism. I want magic!"]"

print(line.split(separator: " ", maxSplits: 2))//This can split your string into 3 parts

print(line.split(separator: " ", omittingEmptySubsequences: false))//array contains empty strings where spaces were repeated.
// Prints "["BLANCHE:", "", "", "I", "don\'t", "want", "realism.", "I", "want", "magic!"]"

print(line.split(separator: " ", omittingEmptySubsequences: true))//array not contains empty strings where spaces were repeated.
print(line.split(separator: " ", maxSplits: 4, omittingEmptySubsequences: false))
print(line.split(separator: " ", maxSplits: 3, omittingEmptySubsequences: true))

Swift 4를 사용하면 문자를 훨씬 쉽게 분할 할 수 있습니다. 문자열에 새로운 분할 기능을 사용하십시오.

예: let s = "hi, hello" let a = s.split(separator: ",") print(a)

이제 'hi'와 'hello'를 가진 배열을 얻었습니다.

Swift 5 및 가장 간단한 방법 업데이트

let paragraph = "Bob hit a ball, the hit BALL flew far after it was hit. Hello! Hie, How r u?"

let words = paragraph.components(separatedBy: [",", " ", "!",".","?"])

이것은 인쇄

[ "Bob", "hit", "a", "ball", "", "the", "hit", "BALL", "fly", "far", "after", "it", "was ","hit "," ","Hello "," ","Hie "," ","How ","r ","u "," "]

그러나 빈 문자열을 걸러 내려면

let words = paragraph.components(separatedBy: [",", " ", "!",".","?"]).filter({!$0.isEmpty})

산출,

[ "Bob", "hit", "a", "ball", "the", "hit", "BALL", "fly", "far", "after", "it", "was", " hit ","Hello ","Hie ","How ","r ","u "]

하지만 재단 은 수입품입니다

스위프트 3

let line = "AAA    BBB\t CCC"
let fields = line.components(separatedBy: .whitespaces).filter {!$0.isEmpty}

• 세 개의 문자열을 반환 AAA, BBB및CCC
• 빈 필드를 걸러냅니다
• 여러 공백 및 표 문자 처리
• 새로운 라인을 처리하는 경우, 교체 .whitespaces로.whitespacesAndNewlines

스위프트 4, Xcode 10 및 iOS 12 업데이트 100 % 작동

let fullName = "First Last"    
let fullNameArr = fullName.components(separatedBy: " ")
let firstName = fullNameArr[0] //First
let lastName = fullNameArr[1] //Last

자세한 내용은 여기 에서 Apple 설명서를 참조하십시오 .

Xcode 8.0 / 스위프트 3

let fullName = "First Last"
var fullNameArr = fullName.components(separatedBy: " ")

var firstname = fullNameArr[0] // First
var lastname = fullNameArr[1] // Last

먼 길:

var fullName: String = "First Last"
fullName += " " // this will help to see the last word

var newElement = "" //Empty String
var fullNameArr = [String]() //Empty Array

for Character in fullName.characters {
    if Character == " " {
        fullNameArr.append(newElement)
        newElement = ""
    } else {
        newElement += "\(Character)"
    }
}


var firsName = fullNameArr[0] // First
var lastName = fullNameArr[1] // Last

분할하려는 문자열에 여러 제어 문자가 존재할 수있는 시나리오가있었습니다. 이것들의 배열을 유지하는 대신, 나는 애플이 그 부분을 처리하게했다.

다음은 iOS 10의 Swift 3.0.1에서 작동합니다.

let myArray = myString.components(separatedBy: .controlCharacters)

흥미로운 사건을 발견했는데

방법 1

var data:[String] = split( featureData ) { $0 == "\u{003B}" }

이 명령을 사용 하여 서버에서로드 된 데이터에서 일부 기호를 분리 할 때 에서 시뮬레이터에서 테스트하는 동안 분할하고 테스트 장치와 동기화 할 수는 있지만 게시 응용 프로그램 및 Ad Hoc에서는 분할되지 않습니다

이 오류를 추적하는 데 많은 시간이 걸립니다. 일부 Swift 버전 또는 일부 iOS 버전에서 저주되었을 수 있습니다.

stringByRemovingPercentEncoding을 시도하고 여전히 작동 하지 않기 때문에 HTML 코드에 관한 것이 아닙니다.

2015 년 10 월 10 일 추가

Swift 2.0에서이 방법은

var data:[String] = featureData.split {$0 == "\u{003B}"}

방법 2

var data:[String] = featureData.componentsSeparatedByString("\u{003B}")

이 명령을 사용하면 서버에서로드하는 것과 동일한 데이터를 올바르게 분할 할 수 있습니다

결론적으로 나는 방법 2를 사용하는 것이 좋습니다.

string.componentsSeparatedByString("")

하지 -이 답변의 대부분은 입력에 공백이 포함한다고 가정 해 봅시다 흰색 공간, 그리고 그에서 하나의 공간. 안전하게 가정 할 수 있다면 (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"]

또는 폐쇄없이 Swift 2 에서이 작업을 수행 할 수 있습니다.

let fullName = "First Last"
let fullNameArr = fullName.characters.split(" ")
let firstName = String(fullNameArr[0])

Swift 4에서 문자열을 배열로 분할하는 단계

1. 문자열을 할당
2. @ 분할을 기반으로합니다.

참고 : variableName.components (separatedBy : "분할 키워드")

let fullName: String = "First Last @ triggerd event of the session by session storage @ it can be divided by the event of the trigger."
let fullNameArr = fullName.components(separatedBy: "@")
print("split", fullNameArr)

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

"Hello World"라는 이름의 변수가 있고이를 분리하여 두 개의 다른 변수로 저장하려는 경우 다음과 같이 사용할 수 있습니다.

var fullText = "Hello World"
let firstWord = fullText.text?.components(separatedBy: " ").first
let lastWord = fullText.text?.components(separatedBy: " ").last

오직 split정답입니다. 여기에 두 칸 이상의 차이가 있습니다.

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"]

let str = "one two"
let strSplit = str.characters.split(" ").map(String.init) // returns ["one", "two"]

Xcode 7.2 (7C68)

스위프트 2.2 오류 처리 및 대문자 문자열 추가 :

func setFullName(fullName: String) {
    var fullNameComponents = fullName.componentsSeparatedByString(" ")

    self.fname = fullNameComponents.count > 0 ? fullNameComponents[0]: ""
    self.sname = fullNameComponents.count > 1 ? fullNameComponents[1]: ""

    self.fname = self.fname!.capitalizedString
    self.sname = self.sname!.capitalizedString
}

문자열 처리는 Swift에서 여전히 어려운 과제이며 다른 답변에서 볼 수 있듯이 계속 변경됩니다. 바라건대 상황이 해결되고 더 단순 해집니다. 이것은 여러 구분 문자가있는 현재 3.0 버전의 Swift에서 수행하는 방법입니다.

스위프트 3 :

let chars = CharacterSet(charactersIn: ".,; -")
let split = phrase.components(separatedBy: chars)

// Or if the enums do what you want, these are preferred. 
let chars2 = CharacterSet.alphaNumerics // .whitespaces, .punctuation, .capitalizedLetters etc
let split2 = phrase.components(separatedBy: chars2)

빈 배열이 결과 배열에 포함되는 PHP와 같은 느슨한 분할 을 찾고 있었는데explode 이것은 나를 위해 일했습니다.

"First ".split(separator: " ", maxSplits: 1, omittingEmptySubsequences: false)

산출:

["First", ""]

이것은 분할 된 부분 의 배열 을 직접 제공합니다

var fullNameArr = fullName.components(separatedBy:" ")

다음과 같이 사용할 수 있습니다,

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

이것은 베타 5에서 다시 변경되었습니다. Weee! 이제 CollectionType의 메소드입니다.

낡은:

var fullName = "First Last"
var fullNameArr = split(fullName) {$0 == " "}

새로운:

var fullName = "First Last"
var fullNameArr = fullName.split {$0 == " "}

사과 출시 정보

신속한 2, XCode 7.1의 경우 :

let complete_string:String = "Hello world"
let string_arr =  complete_string.characters.split {$0 == " "}.map(String.init)
let hello:String = string_arr[0]
let world:String = string_arr[1]

다음은 방금 빌드 한 알고리즘 입니다. 배열에서 a String로 분할 Character하고 하위 문자를 분할 문자로 유지하려는 경우 swallow매개 변수를로 설정할 수 true있습니다.

Xcode 7.3-스위프트 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", "--"]