Question

我在字符串数组中总共有9个元素。

strArr = [ "1 days ago","10 hours ago","2 hours ago","3 days ago","3 hours ago","4 hours ago",
"5 hours ago","6 hours ago","7 hours ago"]

我需要像这样对数组进行排序

sortedArr = ["2 hours ago","3 hours ago","4 hours ago","5 hours ago",
"6 hours ago","7 hours ago","10 hours ago", "1 days ago","3 days ago"]

Answer 1

您可以执行3个步骤：

创建一个代表句子的模型值

使模型值具有可比性

将每个句子转换为模型值

对模型值进行排序

再次将每个模型值转换成一个句子

步骤1：创建一个表示句子sentence的模型值

枚举是表示一般句子的好方法


enum TimePoint {

    case hours(Int)
    case days(Int)

    init?(sentence: String) {
        let tokens = sentence.split(separator: " ")
        guard
            tokens.count == 3,
            let firstToken = tokens.first,
            let value = Int(firstToken)
            else { return nil }

        let unitString = String(tokens[1])

        switch unitString {
        case "hours": self = .hours(value)
        case "days": self = .days(value)
        default: return nil
        }

    }

    var description: String {
        switch self {
        case .days(let value): return "\(value) days ago"
        case .hours(let value): return "\(value) hours ago"
        }
    }
}

步骤2：使模型值可比

extension TimePoint: Comparable {

    private var hours: Int {
        switch self {
        case .hours(let value): return value
        case .days(let value): return 24 * value
        }
    }

    static func < (lhs: TimePoint, rhs: TimePoint) -> Bool {
        return lhs.hours < rhs.hours
    }
}

步骤3、4和5（转换为模型，排序并再次转换为文本）

给出此输入数组

let sentences = ["1 days ago","10 hours ago","2 hours ago","3 days ago","3 hours ago","4 hours ago", "5 hours ago","6 hours ago","7 hours ago"]

您现在可以写

let sortedSentences = sentences
    .compactMap(TimePoint.init)
    .sorted()
    .map { $0.description }

就这样

["2 hours ago", "3 hours ago", "4 hours ago", "5 hours ago", "6 hours ago", "7 hours ago", "10 hours ago", "1 days ago", "3 days ago"]

Answer 2

如果您的字符串集合是一致的，则可以传递自定义排序谓词。如果前一个元素具有小时后缀，而下一个元素不仅返回true，否则返回localizedStandardCompare结果

let strings = [ "1 days ago","10 hours ago","2 hours ago","3 days ago","3 hours ago","4 hours ago",
"5 hours ago","6 hours ago","7 hours ago"]

let sorted = strings.sorted{ $0.hasSuffix(" hours ago") && !$1.hasSuffix(" hours ago") ? true : $0.localizedStandardCompare($1) == .orderedAscending  }
print(sorted) // ["2 hours ago", "3 hours ago", "4 hours ago", "5 hours ago", "6 hours ago", "7 hours ago", "10 hours ago", "1 days ago", "3 days ago"]

快速排序时间范围的列表

2 个答案:

步骤1：创建一个表示句子sentence的模型值

步骤2：使模型值可比
`extension TimePoint: Comparable { private var hours: Int { switch self { case .hours(let value): return value case .days(let value): return 24 * value } } static func < (lhs: TimePoint, rhs: TimePoint) -> Bool { return lhs.hours < rhs.hours } }`

步骤3、4和5（转换为模型，排序并再次转换为文本）

快速排序时间范围的列表

2 个答案:

步骤1：创建一个表示句子sentence的模型值

步骤2：使模型值可比 extension TimePoint: Comparable { private var hours: Int { switch self { case .hours(let value): return value case .days(let value): return 24 * value } } static func < (lhs: TimePoint, rhs: TimePoint) -> Bool { return lhs.hours < rhs.hours } }

步骤3、4和5（转换为模型，排序并再次转换为文本）

步骤2：使模型值可比
`extension TimePoint: Comparable { private var hours: Int { switch self { case .hours(let value): return value case .days(let value): return 24 * value } } static func < (lhs: TimePoint, rhs: TimePoint) -> Bool { return lhs.hours < rhs.hours } }`