Swift 3：数组封装逻辑转为函数实现时遇到问题求助

Hey there! I totally get the frustration when code works perfectly in Playground but hits a wall when you wrap it into a function—been there, done that. Let's break down the most common reasons this happens and fix it step by step.

First, let's assume your working Playground logic looks something like this (I'm guessing based on your description, adjust if needed):

var originalArray = ["Apple", "Banana", "Orange"]
let selectedElement = "Banana"

// Your encapsulation logic—say, moving the selected element to the front
var newArray = [selectedElement]
newArray.append(contentsOf: originalArray.filter { $0 != selectedElement })

When you turn this into a function, you might be missing key details like proper return types, handling value types correctly, or forgetting to return the final array. Here's how to fix it:

1. Correct Function Structure with Return Value #

Swift functions need explicit return types unless they're void. Since you're generating a new array, make sure to define the return type and return the result:

// Use generics so this works with any equatable element type (strings, numbers, custom types)
func encapsulateSelectedElement<T: Equatable>(from array: [T], selected: T) -> [T] {
    var processedArray = [selected]
    // Add all elements except the selected one (adjust logic to match your needs)
    let remainingElements = array.filter { $0 != selected }
    processedArray.append(contentsOf: remainingElements)
    // Don't forget to return the final array!
    return processedArray
}

2. Test the Function in Playground #

Now call it like this to verify:

let fruits = ["Apple", "Banana", "Orange"]
if let selectedFruit = fruits.first(where: { $0 == "Banana" }) {
    let result = encapsulateSelectedElement(from: fruits, selected: selectedFruit)
    print(result) // Output: ["Banana", "Apple", "Orange"]
}

3. Handle Edge Cases #

Don't forget to account for scenarios where the selected element doesn't exist in the array—this prevents unexpected behavior:

func encapsulateSelectedElement<T: Equatable>(from array: [T], selected: T) -> [T] {
    guard array.contains(selected) else {
        // Return original array or handle error as needed
        return array
    }
    
    var processedArray = [selected]
    let remainingElements = array.filter { $0 != selected }
    processedArray.append(contentsOf: remainingElements)
    return processedArray
}

If Your Encapsulation is More Complex #

If you're wrapping the selected element into a custom structure (not just rearranging the array), here's an example:

// Define a struct to hold your encapsulated data
struct ElementPackage<T> {
    let selectedElement: T
    let remainingElements: [T]
}

func createElementPackage<T: Equatable>(from array: [T], selected: T) -> ElementPackage<T>? {
    guard array.contains(selected) else {
        return nil // Return nil if element isn't found
    }
    
    let remaining = array.filter { $0 != selected }
    return ElementPackage(selectedElement: selected, remainingElements: remaining)
}

// Usage
let numbers = [1, 2, 3, 4]
if let package = createElementPackage(from: numbers, selected: 3) {
    print("Selected: \(package.selectedElement)") // 3
    print("Remaining: \(package.remainingElements)") // [1,2,4]
}

Key Checks to Double-Check: #

• Make sure your function returns the processed array/structure (easy to forget!)
• If using custom types, ensure they conform to Equatable (required for filter and contains)
• Remember Swift arrays are value types—changes inside the function won't affect the original array outside, so you need to use the returned value

内容的提问来源于stack exchange，提问作者user8276622