Swift에서 어레이의 처음 5개 개체를 반환하는 방법

Swift에서 어레이의 처음 5개 개체를 반환하는 방법

Swift에서는 어레이의 상위 메서드를 사용하여 첫 번째 객체 5개를 반환하는 현명한 방법이 있습니까?obj-c 방법은 인덱스를 저장하고 5가 될 때까지 인덱스를 증가시켜 새로운 어레이를 반환하는 것이었습니다.이 작업을 할 수 있는 방법이 있나요?filter,map또는reduce?

지금까지 Swift 어레이의 첫 번째 N개의 요소를 얻는 가장 깔끔한 방법은prefix(_ maxLength: Int):

let array = [1, 2, 3, 4, 5, 6, 7]
let slice5 = array.prefix(5) // ArraySlice
let array5 = Array(slice5)   // [1, 2, 3, 4, 5]

원라이너는 다음과 같습니다.

let first5 = Array(array.prefix(5))

이것은 안전하다는 장점이 있다.전달한 카운트가prefix어레이 수보다 크면 어레이 전체가 반환됩니다.

주의: 댓글에 지적된 바와 같이Array.prefix실제로 반환되는 것은ArraySlice,가 아니라Array.

결과를 에 할당해야 하는 경우Array예상하는 방법으로 입력 또는 전달하다Arrayparam, 당신은 결과를 강제로 param에 넣을 필요가 있습니다.Array입력:let first5 = Array(array.prefix(5))

정말 쉽게 할 수 있어요.filter,map,reduce, 또는prefix아래 첨자를 통해 어레이 범위를 반환하기만 하면 됩니다.

var wholeArray = [1, 2, 3, 4, 5, 6]
var n = 5

var firstFiveSlice = wholeArray[0..<n] // 1,2,3,4,5

let firstFiveArray = Array(firstFiveSlice)

Swift 5에서는 필요에 따라 Playground 코드 6개 중 하나를 선택하여 문제를 해결할 수 있습니다.

---

#1. 사용방법subscript(_:)첨자

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array[..<5]
//let arraySlice = array[0..<5] // also works
//let arraySlice = array[0...4] // also works
//let arraySlice = array[...4] // also works
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

---

#2. 사용방법prefix(_:)방법

복잡도: 컬렉션이 다음을 준수하는 경우 O(1)RandomAccessCollection그 이외의 경우는 O(k)입니다.여기서 k는 수집의 선두에서 선택하는 요소의 수입니다.

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(5)
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

Apple 스테이트:prefix(_:):

최대 길이가 컬렉션의 요소 수를 초과하면 결과에는 컬렉션의 모든 요소가 포함됩니다.

---

#3. 사용방법prefix(upTo:)방법

복잡도: O(1)

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(upTo: 5)
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

Apple 스테이트:prefix(upTo:):

사용방법prefix(upTo:)method는 부분 하프오픈 범위를 컬렉션의 첨자로 사용하는 것과 같습니다.아래 첨자 표기법이 선호됩니다.prefix(upTo:).

---

#4. 사용방법prefix(through:)방법

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(through: 4)
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

---

#5. 사용방법removeSubrange(_:)방법

복잡도: O(n). 여기서 n은 컬렉션의 길이입니다.

var array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
array.removeSubrange(5...)
print(array) // prints: ["A", "B", "C", "D", "E"]

---

#6. 사용방법dropLast(_:)방법

복잡도: 컬렉션이 다음을 준수하는 경우 O(1)RandomAccessCollection; 그 이외의 경우는 O(k)입니다.여기서 k는 폐기하는 요소의 수입니다.

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let distance = array.distance(from: 5, to: array.endIndex)
let arraySlice = array.dropLast(distance)
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

let a: [Int] = [0, 0, 1, 1, 2, 2, 3, 3, 4]
let b: [Int] = Array(a.prefix(5))
// result is [0, 0, 1, 1, 2]

SWIFT 4

다른 솔루션:

어레이가 너무 짧아도 크래쉬하지 않는 간단한 인라인 솔루션

[0,1,2,3,4,5].enumerated().compactMap{ $0.offset < 3 ? $0.element : nil }

하지만 이것과 잘 어울린다.

[0,1,2,3,4,5].enumerated().compactMap{ $0.offset < 1000 ? $0.element : nil }

보통 이렇게 하면 크래쉬가 발생합니다.

[0,1,2,3,4,5].prefix(upTo: 1000) // THIS CRASHES

[0,1,2,3,4,5].prefix(1000) // THIS DOESNT

스위프트 4

Swift 배열의 첫 번째 N개 요소를 가져오려면prefix(_ maxLength: Int):

Array(largeArray.prefix(5))

어레이의 처음 5개 요소를 가져오려면 해당 어레이를 슬라이스하기만 하면 됩니다.스위프트에서는 다음과 같이 합니다.array[0..<5].

배열의 첫 번째 N개 요소를 선택하는 기능이 향상되고 일반화하기 쉽도록 확장 방법을 만들 수 있습니다.예:

extension Array {
    func takeElements(var elementCount: Int) -> Array {
        if (elementCount > count) {
            elementCount = count
        }
        return Array(self[0..<elementCount])
    }
}

객체 배열에 대해 Sequence에서 확장을 만들 수 있습니다.

extension Sequence {
    func limit(_ max: Int) -> [Element] {
        return self.enumerated()
            .filter { $0.offset < max }
            .map { $0.element }
    }
}

사용방법:

struct Apple {}

let apples: [Apple] = [Apple(), Apple(), Apple()]
let limitTwoApples = apples.limit(2)

// limitTwoApples: [Apple(), Apple()]

최신 Markus의 답변을 약간 했습니다.var메서드 선언 내에서는 지원되지 않습니다.

extension Array {
    func takeElements(elementCount: Int) -> Array {
        if (elementCount > count) {
            return Array(self[0..<count])
        }
        return Array(self[0..<elementCount])
    }
}

Swift 4(어레이 유형 저장)

extension Array {
    func take(_ elementsCount: Int) -> [Element] {
        let min = Swift.min(elementsCount, count)
        return Array(self[0..<min])
    }
}

심플하고 심플한

extension Array {
    func first(elementCount: Int) -> Array {
          let min = Swift.min(elementCount, count)
          return Array(self[0..<min])
    }
}

이 내선번호를 사용하세요.원래 끔찍했던 이름들을 고치고 있어

public extension Array {
    func first(_ count: Int) -> ArraySlice<Element> {
        return self.prefix(count)
    }
    
    func last(_ count: Int) -> ArraySlice<Element> {
        return self.suffix(count)
    }
}

사용방법:

someArr.first(5) 
someArr.last(5) 

Prefix 함수는 이 문제를 해결하는 가장 효율적인 방법이지만 다음과 같은 for-in 루프를 사용할 수도 있습니다.

let array = [1,2,3,4,5,6,7,8,9]
let maxNum = 5
var iterationNumber = 0
var firstNumbers = [Int()]
if array.count > maxNum{
  for i in array{
    iterationNumber += 1
    if iterationNumber <= maxNum{
      firstNumbers.append(i)
    }
  }
  firstNumbers.remove(at: 0)
  print(firstNumbers)
} else {
  print("There were not \(maxNum) items in the array.")
}

이 솔루션은 많은 코드를 사용하지만 어레이에 프로그램을 실행하기에 충분한 항목이 있는지 확인한 후 계속하여 문제를 해결합니다.이 솔루션은 다음과 같은 많은 기본 기능을 사용합니다.array.count배열 내 마지막 항목의 위치가 아니라 배열 내 항목의 양을 반환합니다.또,array.append어레이 끝에 항목을 추가합니다. 마지막으로 '아까', '아까', '아까', '아까',array.remove지정된 위치에 있는 어레이의 항목을 제거합니다.

테스트를 해봤는데 적어도 swift 5는 동작합니다.

언급URL : https://stackoverflow.com/questions/28527797/how-to-return-first-5-objects-of-array-in-swift