创建一个通用的扩展排序函数

huangapple
go评论131阅读模式
英文:

Creating a Generic Sort function in Extension

问题

我想知道我在这里做错了什么。我希望不使用强制转换，但无论我尝试什么，似乎都无法成功。

  1. extension Array where Element: Equatable {
  3.     func highestPriority<T: Equatable>(priority: [T]) -> T? {
  4.         let sorted = sorted { lhs, rhs in
  5.             guard let lhs = priority.firstIndex(of: lhs as! T),
  6.                   let rhs = priority.firstIndex(of: rhs as! T) else {
  7.                 return false
  8.             }
  9.             return lhs < rhs
  10.         }
  11.         return sorted.first as? T
  12.     }
  13. }
  15. public enum Jobs: String, Codable {
  16.     case wash = "Wash"
  17.     case dry = "Dry"
  18.     case wax = "Wax"
  19. }
  21. let priorities: [Jobs] = [.wash, .dry, .wax]
  23. let jobs: [Jobs] = [.wax, .wash, .dry]
  25. let priority = jobs.highestPriority(priority: priorities)

我正在从这个起点进行改进，但我不明白为什么将集合更改为在数组中使用 self 有何不同？

  1. func highestPriority<T: Equatable>(_ collection: [T]?, priority: [T]) -> T? {
  2.     let sorted = collection?.sorted { lhs, rhs in
  3.         guard let lhs = priority.firstIndex(of: lhs),
  4.               let rhs = priority.firstIndex(of: rhs) else {
  5.             return false
  6.         }
  7.         return lhs < rhs
  8.     }
  9.     return sorted?.first
  10. }
  12. public enum Jobs: String, Codable {
  13.     case wash = "Wash"
  14.     case dry = "Dry"
  15.     case wax = "Wax"
  16. }
  18. let priorities: [Jobs] = [.wash, .dry, .wax]
  20. let jobs: [Jobs] = [.wax, .wash, .dry]
  22. let priority = highestPriority(jobs, priority: priorities)

我尝试过更改泛型约束，但我只是在摸索中尝试 创建一个通用的扩展排序函数

英文:

I would like to know what I am doing wrong here. I would like not to use force casting but no matter what I try I do not seem able to.

  1. extension Array where Element : Equatable {
  3.     func highestPriority&lt;T: Equatable&gt;( priority: [T]) -&gt; T? {
  4.         let sorted = sorted { lhs, rhs in
  5.             guard let lhs = priority.firstIndex(of: lhs as! T),
  6.                   let rhs = priority.firstIndex(of: rhs as! T) else {
  7.                 return false
  8.             }
  9.             return lhs &lt; rhs
  10.         }
  11.         return sorted.first as? T
  12.     }
  13. }
  15. public enum Jobs: String, Codable {
  16.     case wash = &quot;Wash&quot;
  17.     case dry = &quot;Dry&quot;
  18.     case wax = &quot;Wax&quot;
  19. }
  21. let priorities: [Jobs] = [.wash, .dry, .wax]
  23. let jobs: [Jobs] = [.wax, .wash, .dry]
  25. let priority = jobs.highestPriority(priority: priorities)

Im refining from this which works, but I'm not understanding why changing collection to use self in Array is any different?

  1. func highestPriority&lt;T:Equatable&gt;(_ collection: [T]?, priority: [T]) -&gt; T? {
  2.     let sorted = collection?.sorted { lhs, rhs in
  3.         guard let lhs = priority.firstIndex(of: lhs),
  4.               let rhs = priority.firstIndex(of: rhs) else {
  5.             return false
  6.         }
  7.         return lhs &lt; rhs
  8.     }
  9.     return sorted?.first
  10. }
  12. public enum Jobs: String, Codable {
  13.     case wash = &quot;Wash&quot;
  14.     case dry = &quot;Dry&quot;
  15.     case wax = &quot;Wax&quot;
  16. }
  18. let priorities: [Jobs] = [.wash, .dry, .wax]
  20. let jobs: [Jobs] = [.wax, .wash, .dry]
  22. let priority = highestPriority(jobs, priority: priorities)

I have tried changing the generic constraint but I'm just stabbing in the dark 创建一个通用的扩展排序函数

答案1

得分: 2

  1. 由于与 `highestPriority` 关联的所有类型都与数组中存储的类型相同，所以将 `highestPriority` 从通用更改为基于 `Element`。
  3. ```swift
  4. extension Array where Element : Equatable {
  5.     func highestPriority(priority: [Element]) -> Element? {
  6.         let sort = sorted { lhs, rhs in
  7.             guard let lhs = priority.firstIndex(of: lhs),
  8.                   let rhs = priority.firstIndex(of: rhs) else {
  9.                 return false
  10.             }
  11.             return lhs < rhs
  12.         }
  14.         return sort.first
  15.     }
  16. }

这是一个更简单的实现：

  1. extension Array where Element : Equatable {
  2.     func highestPriority(priority: [Element]) -> Element? {
  3.         return priority.first { contains($0) }
  4.     }
  5. }

如果数组将具有许多元素（并且元素是可哈希的），那么以下实现可能更有效：

  1. extension Array where Element : Hashable {
  2.     func highestPriority(priority: [Element]) -> Element? {
  3.         let set = Set(self)
  4.         return priority.first { set.contains($0) }
  5.     }
  6. }
  2. <details>
  3. <summary>英文:</summary>
  5. Since all of the types associated with `highestPriority` are the same as the type stored in the array, change `highestPriority` from being generic to being based on `Element`.
  7. ```swift
  8. extension Array where Element : Equatable {
  9.     func highestPriority(priority: [Element]) -&gt; Element? {
  10.         let sort = sorted { lhs, rhs in
  11.             guard let lhs = priority.firstIndex(of: lhs),
  12.                   let rhs = priority.firstIndex(of: rhs) else {
  13.                 return false
  14.             }
  15.             return lhs &lt; rhs
  16.         }
  18.         return sort.first
  19.     }
  20. }

Here's a much simpler implementation:

  1. extension Array where Element : Equatable {
  2.     func highestPriority( priority: [Element]) -&gt; Element? {
  3.         return priority.first { contains($0) }
  4.     }
  5. }

If the array will have a lot of elements (and the elements are Hashable), it would likely be more efficient as:

  1. extension Array where Element : Hashable {
  2.     func highestPriority(priority: [Element]) -&gt; Element? {
  3.         let set = Set(self)
  4.         return priority.first { set.contains($0) }
  5.     }
  6. }

huangapple
  • 本文由 发表于 2023年8月4日 01:16:41
  • 转载请务必保留本文链接：https://go.coder-hub.com/76830296.html
  • extension-methods
  • generics
  • swift
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定