struct Student {
    let name: String
    let score: Int

}

var students = [
    Student(name: "John", score: 79),
    Student(name: "Bob", score: 44),
    Student(name: "Alice", score: 0),
    Student(name: "Julie", score: 56),
    Student(name: "Patrick", score: 61)
]

// Example 1
let firstStudent = students.first(where: { $0.score < 50 })
print(firstStudent?.name) // Output: Optional("Bob")


let lastStudent = students.last(where: { $0.score == 56 })
print(lastStudent?.name) // Output: Julie

let scores = students.map { $0.score }
print(scores)

// OR

struct {
    let str: String?
    let int: Int
}

var data: [Model] = [Model(str: "abc", int: 2), Model(str: "asd", int: 1)]
var scores: [Int] = []

data.forEach { value in
    let strLoop = value.str
    let intLoop = value.int
    //normal use
    score.append(strLoop)
}

// use map
score = data.map {$0.int} // [2, 1]

// use compactMap if data optional
score = data.compactMap {$0.str} // [abc, asd]

var data: [Model] = [Model(str: "abc", int: 2), Model(str: "asd", int: 1)]
var data2: [Int ] = [1]

var scores: [Model] = []

data.forEach { value in
    score.append(contentOf: data.filter({ return $0.int == value)
}

// OR

var result: [String] = []

borrowToolId.forEach { id in
    result.append(contentsOf: toolList.map {
        if $0.id == id {
            return $0.name
        }
        return ""
    })
}

print(result.filter({$0 != ""})) // ["A", "c"]

// sort student by score
let sortedArray = students.sorted(by: { $0.score > $1.score })

// map result into list of names
print(
    sortedArray.map { $0.name }, // ["John", "Patrick", "Julie", "Bob", "Alice"]
    sortedArray.map { $0.score } // [79, 61, 56, 44, 0]
)

// Top score
let topScoreStudent = students.max(by: { $0.score < $1.score })
print(topScoreStudent?.name)


// Lowest Score
let lowestStudent = students.min(by: { $0.score < $1.score })
print(lowestStudent?.name)

// Array get form tenary
var dataA = result.arrayValue.compactMap { models(data: $0) }
response["data"].forEach { (_, json) in
    for (key, item) in result.enumerated() {
        if item.1["id"].stringValue == json["id"].stringValue {
            dataA[key].status = json["data"]["status"].boolValue
        }
    }
    
}
self.dataB = dataA
================================================================================


// Should change to this
response["data"].arrayValue.forEach { (json) in
    for index in 0..<(self?.dataB.count ?? 0) {
        if self?.dataB[index].symbol == json["id"].stringValue {
            self?.dataB[index].status = json["data"]["status"].boolValue
        }
    }
}

// CustomUserDefaults.swift (full)
import Foundation

class CustomUserDefaults {
    // define all keys needed
    enum DefaultsKey: String, CaseIterable {
        case name
        case email
        case isUserLogin
        case userLevel
    }
    static let shared = CustomUserDefaults()
    private let defaults = UserDefaults.standard

    init() {}
    // to set value using pre-defined key
    func set(_ value: Any?, key: DefaultsKey) {
        defaults.setValue(value, forKey: key.rawValue)
    }
    // get value using pre-defined key
    func get(key: DefaultsKey) -> Any? {
        return defaults.value(forKey: key.rawValue)
    }
    // check value if exist or nil
    func hasValue(key: DefaultsKey) -> Bool {
        return defaults.value(forKey: key.rawValue) != nil
    }
    // remove all stored values
    func removeAll() {
        for key in DefaultsKey.allCases {
            defaults.removeObject(forKey: key.rawValue)
        }
    }
}

/* How to use
 
 let name = "jhon"
 CustomUserDefaults.shared.set("data", key: .name)

 */