Swift Language
배열

소개

통사론

• Array <Element> // 요소 유형이 Element 인 배열의 유형입니다.
• [Element] // 요소 유형의 요소가있는 배열 형식의 구문 설탕
• [element0, element1, element2, ... elementN] // 배열 리터럴
• [Element] () // [Element] 타입의 빈 배열을 새로 만든다.
• 어레이 (COUNT : repeatedValue는 : // 배열 생성 count 요소를 각 초기화 repeatedValue
• Array (_ :) // 임의의 순서로 배열을 만듭니다.

비고

가치 의미론

배열을 복사하면 원래 배열 안에있는 모든 항목이 복사됩니다.

새 배열 을 변경해 도 원래 배열 은 변경되지 않습니다 .

var originalArray = ["Swift", "is", "great!"]
var newArray = originalArray
newArray[2] = "awesome!"
//originalArray = ["Swift", "is", "great!"]
//newArray = ["Swift", "is", "awesome!"]

복사 된 배열은 변경 될 때까지 원본과 동일한 공간을 메모리에서 공유합니다. 결과적으로 복사 된 배열이 처음 변경 될 때 메모리에 자체 공간이 주어지면 성능이 저하됩니다.

배열의 기초

Array 는 Swift 표준 라이브러리의 정렬 된 컬렉션 유형입니다. O (1) 무작위 액세스와 동적 재 할당을 제공합니다. Array는 제네릭 형식 이므로 포함 된 값 형식은 컴파일 타임에 알려집니다.

Array 는 값 유형 이므로 가변성은 var (변경 가능) 또는 let (변경 불가능)으로 주석 처리되는지 여부에 따라 정의됩니다.

[Int] 타입 (의미 : Int 포함하는 배열)은 Array<T> 문법적 설탕 입니다.

The Swift Programming Language의 배열에 대해 더 자세히 읽어보십시오.

빈 배열

다음 세 가지 선언은 동일합니다.

// A mutable array of Strings, initially empty.

var arrayOfStrings: [String] = []      // type annotation + array literal
var arrayOfStrings = [String]()        // invoking the [String] initializer
var arrayOfStrings = Array<String>()   // without syntactic sugar

배열 리터럴

배열 리터럴은 쉼표로 구분 된 요소를 둘러싸는 대괄호로 작성됩니다.

// Create an immutable array of type [Int] containing 2, 4, and 7
let arrayOfInts = [2, 4, 7]

컴파일러는 대개 리터럴의 요소를 기반으로 배열의 유형을 추측 할 수 있지만 명시 적 유형 주석은 기본값을 대체 할 수 있습니다.

let arrayOfUInt8s: [UInt8] = [2, 4, 7]   // type annotation on the variable
let arrayOfUInt8s = [2, 4, 7] as [UInt8] // type annotation on the initializer expression
let arrayOfUInt8s = [2 as UInt8, 4, 7]   // explicit for one element, inferred for the others

반복되는 값을 가진 배열

// An immutable array of type [String], containing ["Example", "Example", "Example"]
let arrayOfStrings = Array(repeating: "Example",count: 3)

다른 시퀀스에서 배열 만들기

let dictionary = ["foo" : 4, "bar" : 6]

// An immutable array of type [(String, Int)], containing [("bar", 6), ("foo", 4)]
let arrayOfKeyValuePairs = Array(dictionary)

다차원 배열

신속한에서는 다차원 배열 어레이를 중첩에 의해 생성된다 :의 2 차원 어레이 Int 이다 [[Int]] (또는 Array<Array<Int>> ).

let array2x3 = [
    [1, 2, 3],
    [4, 5, 6]
]
// array2x3[0][1] is 2, and array2x3[1][2] is 6.

반복되는 값의 다차원 배열을 만들려면 배열 초기화 자의 중첩 된 호출을 사용하십시오.

var array3x4x5 = Array(repeating: Array(repeating: Array(repeating: 0,count: 5),count: 4),count: 3)

배열 값 액세스

다음 예제에서는이 배열을 사용하여 값에 액세스하는 방법을 보여줍니다.

var exampleArray:[Int] = [1,2,3,4,5]
//exampleArray = [1, 2, 3, 4, 5]

알려진 색인의 값에 액세스하려면 다음 구문을 사용합니다.

let exampleOne = exampleArray[2]
//exampleOne = 3

참고 : 인덱스 2의 값 은 Array 의 세 번째 값 입니다. Array 은 0부터 시작하는 인덱스 를 사용합니다. 이는 Array 의 첫 번째 요소가 인덱스 0에 있음을 의미합니다.

let value0 = exampleArray[0]
let value1 = exampleArray[1]
let value2 = exampleArray[2]
let value3 = exampleArray[3]
let value4 = exampleArray[4]
//value0 = 1
//value1 = 2 
//value2 = 3
//value3 = 4
//value4 = 5

filter를 사용하여 Array 의 하위 집합에 액세스합니다.

var filteredArray = exampleArray.filter({ $0 < 4 })
//filteredArray = [1, 2, 3]

필터는 짝수 만 필터링하는 것과 같은 복잡한 조건을 가질 수 있습니다.

var evenArray = exampleArray.filter({ $0 % 2 == 0 })
//evenArray = [2, 4]

또한 주어진 값의 인덱스를 리턴 할 수 있으며, 값을 찾지 못하면 nil 을 리턴합니다.

exampleArray.indexOf(3) // Optional(2)

Array 의 첫 번째, 마지막, 최대 또는 최소 값에 대한 메서드가 있습니다. 이러한 메서드는 Array 가 비어있는 경우 nil 을 반환합니다.

exampleArray.first // Optional(1)
exampleArray.last // Optional(5)
exampleArray.maxElement() // Optional(5)
exampleArray.minElement() // Optional(1)

유용한 방법

배열이 비어 있는지 또는 크기를 반환하는지 결정합니다.

var exampleArray = [1,2,3,4,5]
exampleArray.isEmpty //false
exampleArray.count //5

배열 반전 참고 : 메서드가 호출 된 배열에서는 결과가 수행되지 않으므로 자체 변수에 넣어야합니다.

exampleArray = exampleArray.reverse()
//exampleArray = [9, 8, 7, 6, 5, 3, 2]

배열의 값 수정하기

배열에 값을 추가하는 여러 가지 방법이 있습니다.

var exampleArray = [1,2,3,4,5]
exampleArray.append(6)
//exampleArray = [1, 2, 3, 4, 5, 6]
var sixOnwards = [7,8,9,10]
exampleArray += sixOnwards
//exampleArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

배열에서 값을 제거하고 제거한다.

exampleArray.removeAtIndex(3)
//exampleArray = [1, 2, 3, 5, 6, 7, 8, 9, 10]
exampleArray.removeLast()
//exampleArray = [1, 2, 3, 5, 6, 7, 8, 9]
exampleArray.removeFirst()
//exampleArray = [2, 3, 5, 6, 7, 8, 9]

배열 정렬

var array = [3, 2, 1]

새 정렬 된 배열 만들기

Array 는 SequenceType 따르므로 내장 정렬 방법을 사용하여 정렬 된 요소의 새 배열을 생성 할 수 있습니다.

let sorted = array.sort()  // [1, 2, 3]

let sorted = array.sorted()  // [1, 2, 3]

기존 배열을 제자리에 정렬하기

Array 는 MutableCollectionType 따르 MutableCollectionType 요소를 제 위치에서 정렬 할 수 있습니다.

array.sortInPlace() // [1, 2, 3]

array.sort() // [1, 2, 3]

참고 : 위의 메서드를 사용하려면 요소가 Comparable 프로토콜을 준수해야합니다.

커스텀 주문으로 배열 정렬하기

또한 한 요소를 다른 요소보다 먼저 정렬해야 하는지를 정의하기 위해 클로저 를 사용하여 배열을 정렬 할 수 있습니다. 요소가 Comparable 이어야하는 배열에만 국한되지 않습니다. 예를 들어, Landmark 가 Comparable 것은 의미가 없지만 높이 또는 이름별로 랜드 마크 배열을 정렬 할 수는 있습니다.

struct Landmark {
    let name : String
    let metersTall : Int
}

var landmarks = [Landmark(name: "Empire State Building", metersTall: 443),
                 Landmark(name: "Eifell Tower", metersTall: 300),
                 Landmark(name: "The Shard", metersTall: 310)]

// sort landmarks by height (ascending)
landmarks.sortInPlace {$0.metersTall < $1.metersTall}

print(landmarks) // [Landmark(name: "Eifell Tower", metersTall: 300), Landmark(name: "The Shard", metersTall: 310), Landmark(name: "Empire State Building", metersTall: 443)]

// create new array of landmarks sorted by name
let alphabeticalLandmarks = landmarks.sort {$0.name < $1.name}

print(alphabeticalLandmarks) // [Landmark(name: "Eifell Tower", metersTall: 300), Landmark(name: "Empire State Building", metersTall: 443), Landmark(name: "The Shard", metersTall: 310)]

// sort landmarks by height (ascending)
landmarks.sort {$0.metersTall < $1.metersTall}

// create new array of landmarks sorted by name
let alphabeticalLandmarks = landmarks.sorted {$0.name < $1.name}

참고 : 문자열이 일치하지 않으면 문자열 비교로 인해 예기치 않은 결과가 발생할 수 있습니다 (문자열 배열 정렬 참조).

맵을 사용하여 배열의 요소 변환하기 (_ :)

Array 는 SequenceType 따르므로 map(_:) 을 사용하여 A 의 배열을 (A) throws -> B 의 클로저 를 사용하여 B 의 배열로 변형 할 수 있습니다.

예를 들어, 다음과 같이 Int 배열을 String 배열로 변환하는 데 사용할 수 있습니다.

let numbers = [1, 2, 3, 4, 5]
let words = numbers.map { String($0) }
print(words) // ["1", "2", "3", "4", "5"]

map(_:) 은 배열을 반복하며 주어진 클로저를 각 요소에 적용합니다. 클로저의 결과는 변환 된 요소로 새 배열을 채우는 데 사용됩니다.

String 에는 Int 를받는 initialiser가 Int 더 명확한 구문을 사용할 수도 있습니다.

let words = numbers.map(String.init)

map(_:) 변환은 배열의 유형을 변경할 필요가 없습니다. 예를 들어 Int 의 배열에 2를 곱하는 데 사용할 수도 있습니다.

let numbers = [1, 2, 3, 4, 5]
let numbersTimes2 = numbers.map {$0 * 2}
print(numbersTimes2) // [2, 4, 6, 8, 10]

flatMap을 사용하여 배열에서 지정된 유형의 값 추출 (_ :)

things 배열의 값을 포함 Any 유형입니다.

let things: [Any] = [1, "Hello", 2, true, false, "World", 3]

주어진 타입의 값을 추출하고 그 특정 타입의 새로운 Array를 생성 할 수 있습니다. 우리가 모든 Int(s) 를 추출하여 Int Array에 안전하게 저장하려고한다고 가정 해 봅시다.

let numbers = things.flatMap { $0 as? Int }

이제 numbers 는 [Int] 로 정의됩니다. flatMap 함수는 모든 nil 요소를 무시하므로 결과에는 다음 값만 포함됩니다.

[1, 2, 3]

배열 필터링

SequenceType 에서 filter(_:) 메서드를 사용하여 주어진 술어를 만족하는 시퀀스 요소를 포함하는 새 배열을 만들 수 있습니다.이 배열은 클로저 로 제공 될 수 있습니다.

예를 들어 [Int] 짝수 필터링 :

let numbers = [22, 41, 23, 30]

let evenNumbers = numbers.filter { $0 % 2 == 0 }

print(evenNumbers)  // [22, 30]

연령대가 30 세 미만인 [Person] 필터링 :

struct Person {
    var age : Int
}

let people = [Person(age: 22), Person(age: 41), Person(age: 23), Person(age: 30)]

let peopleYoungerThan30 = people.filter { $0.age < 30 }

print(peopleYoungerThan30) // [Person(age: 22), Person(age: 23)]

flatMap을 사용하여 배열 변환에서 nil 필터링 (_ :)

배열의 요소에 변환을 적용하여 배열을 만들려면 map(_:) 과 비슷한 방식으로 flatMap(_:) 을 사용할 수 있습니다.

extension SequenceType {
    public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
}

flatMap(_:) 의이 버전과의 차이점은 변환 클로저 가 선택적 값 T? 를 반환 할 것으로 예상한다는 것입니다 T? 각 요소에 대해 그러면 각각의 선택적 값을 안전하게 제거하고 nil 필터링하여 [T] 의 배열을 만듭니다.

예를 들어 다음과 같이 변환 할 수없는 모든 요소를 ​​필터링하여 [String] 을 Int 의 유령 String 초기화 프로그램을 사용하여 [Int] 로 변환 할 수 있습니다.

let strings = ["1", "foo", "3", "4", "bar", "6"]

let numbersThatCanBeConverted = strings.flatMap { Int($0) }

print(numbersThatCanBeConverted) // [1, 3, 4, 6]

flatMap(_:) 의 기능을 사용하여 옵션 배열을 단순히 비표준 배열로 변환하기 위해 nil 을 필터링 할 수도 있습니다.

let optionalNumbers : [Int?] = [nil, 1, nil, 2, nil, 3]

let numbers = optionalNumbers.flatMap { $0 }

print(numbers) // [1, 2, 3]

범위가있는 배열에 subscripting하기

범위를 사용하여 배열에서 일련의 연속 요소를 추출 할 수 있습니다.

let words = ["Hey", "Hello", "Bonjour", "Welcome", "Hi", "Hola"]
let range = 2...4
let slice = words[range] // ["Bonjour", "Welcome", "Hi"]

Range가있는 배열에 subscripting하면 ArraySlice 반환 ArraySlice . 그것은 배열의 하위 시퀀스입니다.

이 예에서는 Array of Strings가 있으므로 ArraySlice<String> 다시 가져옵니다.

ArraySlice가 CollectionType 준거하고있어 sort , filter 등으로 사용할 수 있습니다 만, 그 목적은 장기간의 저장은 아니고, 일시적인 계산을 위해서입니다. 작업을 끝내면 (자) 곧바로 Array에 변환 할 필요가 있습니다.

이를 위해 Array() 이니셜 라이저를 사용하십시오.

let result = Array(slice)

중간 단계가없는 간단한 예를 요약하면 다음과 같습니다.

let words = ["Hey", "Hello", "Bonjour", "Welcome", "Hi", "Hola"]
let selectedWords = Array(words[2...4]) // ["Bonjour", "Welcome", "Hi"]

배열 값 그룹화

우리가 이런 구조체를 가지고 있다면

struct Box {
    let name: String
    let thingsInside: Int
}

및 Box(es) 어레이 Box(es)

let boxes = [
    Box(name: "Box 0", thingsInside: 1),
    Box(name: "Box 1", thingsInside: 2),
    Box(name: "Box 2", thingsInside: 3),
    Box(name: "Box 3", thingsInside: 1),
    Box(name: "Box 4", thingsInside: 2),
    Box(name: "Box 5", thingsInside: 3),
    Box(name: "Box 6", thingsInside: 1)
]

우리는 thingsInside 속성을 사용하여 상자를 그룹화 할 수 있습니다. 여기서 Dictionary 는 key 의 개수이고 값은 상자의 배열입니다.

let grouped = boxes.reduce([Int:[Box]]()) { (res, box) -> [Int:[Box]] in
    var res = res
    res[box.thingsInside] = (res[box.thingsInside] ?? []) + [box]
    return res
}

이제 그룹화 된 [Int:[Box]] 이며 다음과 같은 내용을 가지고 있습니다

[
    2: [Box(name: "Box 1", thingsInside: 2), Box(name: "Box 4", thingsInside: 2)], 
    3: [Box(name: "Box 2", thingsInside: 3), Box(name: "Box 5", thingsInside: 3)],
    1: [Box(name: "Box 0", thingsInside: 1), Box(name: "Box 3", thingsInside: 1), Box(name: "Box 6", thingsInside: 1)]
]

flatMap (_ :)을 사용하여 배열 변환 결과 평평하게하기

시퀀스의 변환 된 요소에서 nil 을 필터링 하여 배열을 만들 수있을뿐만 아니라 변형 클로저 가 시퀀스 S 를 반환 할 것으로 기대하는 flatMap(_:) 버전도 있습니다.

extension SequenceType {
    public func flatMap<S : SequenceType>(transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
}

변환의 각 시퀀스가 ​​연결되어 각 시퀀스의 결합 된 요소 인 [S.Generator.Element] 포함 된 배열이 생성됩니다.

문자열 배열에서 문자 결합

예를 들어, 프라임 문자열의 배열을 가져 와서 그 문자를 단일 배열로 결합하는 데 사용할 수 있습니다.

let primes = ["2", "3", "5", "7", "11", "13", "17", "19"]
let allCharacters = primes.flatMap { $0.characters }
// => "["2", "3", "5", "7", "1", "1", "1", "3", "1", "7", "1", "9"]"

위의 예를 아래로 돌립니다.

1. primes 는 [String] (배열은 시퀀스이므로 flatMap(_:) 을 호출 할 수 있습니다).
2. 변환 클로저는 primes 의 요소 중 하나 인 String ( Array<String>.Generator.Element )을 사용합니다.
3. 그런 다음 클로저는 String.CharacterView 유형의 시퀀스를 반환합니다.
4. 결과는 각 변환 클로저 호출 ( [String.CharacterView.Generator.Element] 의 모든 시퀀스의 결합 된 요소를 포함하는 배열입니다.

다차원 배열 병합

flatMap(_:) 은 변환 클로저 호출에서 반환 된 시퀀스를 연결하므로 2D 배열을 1D 배열, 3D 배열을 2D 배열로 변환하는 등 다차원 배열을 병합하는 데 사용할 수 있습니다.

이것은 클로저에서 주어진 요소 $0 (중첩 배열)을 반환함으로써 간단히 수행 할 수 있습니다 :

// A 2D array of type [[Int]]
let array2D = [[1, 3], [4], [6, 8, 10], [11]]

// A 1D array of type [Int]
let flattenedArray = array2D.flatMap { $0 }

print(flattenedArray) // [1, 3, 4, 6, 8, 10, 11]

문자열 배열 정렬

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted()
print(sortedWords) // ["Ahola", "Bonjour", "Hello", "Salute"]

var mutableWords = ["Hello", "Bonjour", "Salute", "Ahola"]
mutableWords.sort()
print(mutableWords) // ["Ahola", "Bonjour", "Hello", "Salute"]

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted(isOrderedBefore: { $0 > $1 })
print(sortedWords) // ["Salute", "Hello", "Bonjour", "Ahola"]

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted() { $0 > $1 }
print(sortedWords) // ["Salute", "Hello", "Bonjour", "Ahola"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let unexpected = words.sorted()
print(unexpected) // ["Hello", "Salute", "ahola", "bonjour"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let sortedWords = words.sorted { $0.lowercased() < $1.lowercased() }
print(sortedWords) // ["ahola", "bonjour", "Hello", "Salute"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let sortedWords = words.sorted { $0.caseInsensitiveCompare($1) == .orderedAscending }
print(sortedWords) // ["ahola", "bonjour", "Hello", "Salute"]

let files = ["File-42.txt", "File-01.txt", "File-5.txt", "File-007.txt", "File-10.txt"]
let sortedFiles = files.sorted() { $0.compare($1, options: .numeric) == .orderedAscending }
print(sortedFiles) // ["File-01.txt", "File-5.txt", "File-007.txt", "File-10.txt", "File-42.txt"]

flatten ()을 사용하여 다차원 배열을 느슨하게 병합

다차원 시퀀스의 중첩을 지연 시키려면 flatten() 을 사용할 수 있습니다.

예를 들어, 2D 배열을 1D 배열로 평평하게 만드는 것 :

// A 2D array of type [[Int]]
let array2D = [[1, 3], [4], [6, 8, 10], [11]]

// A FlattenBidirectionalCollection<[[Int]]>
let lazilyFlattenedArray = array2D.flatten()

print(lazilyFlattenedArray.contains(4)) // true

위의 예에서 flatten() 은 FlattenBidirectionalCollection 을 반환합니다. FlattenBidirectionalCollection 은 배열의 병합을 지연 적용합니다. 따라서 contains(_:) 는 array2D 의 처음 두 개의 중첩 배열을 평평하게해야합니다. 원하는 요소를 찾으면 단락 될 것이기 때문입니다.

배열 요소를 reduce (_ : combine :)와 결합

reduce(_:combine:) 는 시퀀스의 요소를 단일 값으로 결합하기 위해 사용할 수 있습니다. 결과에 대한 초기 값뿐만 아니라 각 요소에 적용 할 클로저 - 새 누적 값을 반환합니다.

예를 들어 숫자 배열을 합하는 데 사용할 수 있습니다.

let numbers = [2, 5, 7, 8, 10, 4]

let sum = numbers.reduce(0) {accumulator, element in
    return accumulator + element
}

print(sum) // 36

우리는 합계에 대한 논리적 초기 값이므로 0 을 초기 값으로 전달합니다. 우리가 N 의 값을 전달하면 결과 sum 은 N + 36 됩니다. reduce 전달 된 클로저에는 두 개의 인수가 있습니다. accumulator 현재 누적 값이며 각 반복에서 클로저가 반환하는 값이 할당됩니다. element 는 반복의 현재 요소입니다.

이 예제에서와 같이, (Int, Int) -> Int 클로저를 reduce .이 클로저는 단순히 두 개의 입력을 더하는 출력입니다. 실제로 연산자는 Swift에서 함수이므로 + 연산자에서 직접 전달할 수 있습니다.

let sum = numbers.reduce(0, combine: +)

배열을 모르는 채 배열에서 요소 제거하기

일반적으로 배열에서 요소를 제거하려면 remove(at:) 함수를 사용하여 쉽게 제거 할 수 있도록 색인을 알아야합니다.

하지만 인덱스를 모르지만 제거 할 요소의 값을 알고 있다면 어떨까요?

여기에 배열에 대한 간단한 확장이 있습니다.이 확장은 배열에서 요소를 색인없이 쉽게 제거 할 수있게합니다 :

스위프트 3

extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = index(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

예

    var array = ["abc", "lmn", "pqr", "stu", "xyz"]
    array.remove("lmn")
    print("\(array)")    //["abc", "pqr", "stu", "xyz"]
    
    array.remove("nonexistent")
    print("\(array)")    //["abc", "pqr", "stu", "xyz"]
    //if provided element value is not present, then it will do nothing!

또한 실수로 다음과 같이했을 경우 : array.remove(25) 즉, 다른 데이터 유형으로 값을 제공하면 컴파일러에서 오류가 발생합니다.
cannot convert value to expected argument type

배열의 최소 또는 최대 요소 찾기

let numbers = [2, 6, 1, 25, 13, 7, 9]

let minimumNumber = numbers.minElement() // Optional(1)
let maximumNumber = numbers.maxElement() // Optional(25)

let minimumNumber = numbers.min() // Optional(1)
let maximumNumber = numbers.max() // Optional(25)

이러한 메소드의 반환 값은 배열이 비어있을 수 있다는 사실을 반영하기 위해 Optional 입니다. 그렇다면 nil 이 반환됩니다.

주 : 위 메소드는 요소가 Comparable 프로토콜을 준수하도록 요구합니다.

맞춤 주문으로 최소 또는 최대 요소 찾기

또한 위의 메서드를 사용자 정의 클로저 와 함께 사용하여 하나의 요소를 다른 요소보다 먼저 정렬해야 하는지를 정의 할 수 있으므로 요소가 반드시 Comparable 필요가없는 배열에서 최소 또는 최대 요소를 찾을 수 있습니다.

예를 들어, 벡터 배열로 :

struct Vector2 {
    let dx : Double
    let dy : Double
    
    var magnitude : Double {return sqrt(dx*dx+dy*dy)}
}

let vectors = [Vector2(dx: 3, dy: 2), Vector2(dx: 1, dy: 1), Vector2(dx: 2, dy: 2)]

// Vector2(dx: 1.0, dy: 1.0)
let lowestMagnitudeVec2 = vectors.minElement { $0.magnitude < $1.magnitude } 

// Vector2(dx: 3.0, dy: 2.0)
let highestMagnitudeVec2 = vectors.maxElement { $0.magnitude < $1.magnitude } 

let lowestMagnitudeVec2 = vectors.min { $0.magnitude < $1.magnitude }
let highestMagnitudeVec2 = vectors.max { $0.magnitude < $1.magnitude }

지표에 안전하게 액세스하기

배열 색인에 다음 확장자를 추가하면 색인이 범위 내에 있는지 알지 못해도 액세스 할 수 있습니다.

extension Array {
    subscript (safe index: Int) -> Element? {
        return indices ~= index ? self[index] : nil
    }
}

예:

if let thirdValue = array[safe: 2] {
    print(thirdValue)
}

zip과 2 개의 배열 비교

zip 함수는 SequenceType 유형의 2 개의 매개 변수를 받아들이고 각 요소에 첫 번째 시퀀스의 값과 두 번째 시퀀스의 값이 포함 된 Zip2Sequence 반환합니다.

예

let nums = [1, 2, 3]
let animals = ["Dog", "Cat", "Tiger"]
let numsAndAnimals = zip(nums, animals)

nomsAndimals는 이제 다음 값을 포함합니다.

이것은 각 배열의 n 번째 요소 사이에 일종의 비교를 수행하려는 경우에 유용합니다.

예

주어진 Int(s) 의 2 개의 배열

let list0 = [0, 2, 4]
let list1 = [0, 4, 8]

list1 각 값이 list0 의 관련 값의 두 배가되는지 확인하려고합니다.

let list1HasDoubleOfList0 = !zip(list0, list1).filter { $0 != (2 * $1)}.isEmpty