मैं कॉफ़ीस्क्रिप्ट के साथ एक ऐरे को कैसे सॉर्ट करूं?

Question

इस तरह की एक सरणी के साथ:

users.sort (a,b) -> 
    return if a.lname.toUpperCase() >= b.lname.toUpperCase() then 1 else -1 

मैं इस तरह एक समारोह उपयोग करने की कोशिश:

sortBy = (field, reverse, primer) -> 
    key = (x) -> 
     return if primer? then primer x[field] else x[field] 
    return (a,b) -> 
     A = key a 
     B = key b 
     return (A < B ? -1 : (A > B ? 1 : 0)) * [1,-1][+!!reverse] 

users = [ 
    { id: 1, fname: 'Fred', lname: 'Flinstone', state: 'CA' }, 
    { id: 2, fname: 'George', lname: 'Winston', state: 'FL' }, 
    { id: 3, fname: 'Luke', lname: 'Skywalker', state: 'CA' } 
] 

और आप coffeescript साथ अंतिम नाम से क्रमबद्ध करना चाहते हैं, तो आप ऐसा कर सकते हैं

जिसे इस तरह से बुलाया गया था:

users.sort sortBy "lname", false, (a) -> 
    return a.toUpperCase() 

लेकिन यह सरणी को ठीक तरह से सॉर्ट नहीं किया गया।

क्या 1 से अधिक फ़ील्ड द्वारा सॉर्ट करने का कोई तरीका है, यानी पहले राज्य द्वारा क्रमबद्ध करें, और फिर अंतिम नाम से? मैं ऊपर "sortby" फ़ंक्शन पर सुधार करने की उम्मीद कर रहा था और कम से कम 2 फ़ील्ड द्वारा क्रमबद्ध करने की क्षमता जोड़ सकता था।

Answer 1

एक सरल तरीका नहीं है। बस अपने सामान्यीकृत छँटाई समारोह का फिर से उपयोग, और || का उपयोग कर उन्हें श्रेणीबद्ध:

sortBy = (key, a, b, r) -> 
    r = if r then 1 else -1 
    return -1*r if a[key] > b[key] 
    return +1*r if a[key] < b[key] 
    return 0 

users.sort (a,b) -> 
    sortBy('id', a, b, true) or 
    sortBy('lname', a, b) or 
    sortBy('fname', a, b) 

कार्य सस्ता कर रहे हैं। तब आप उस के लिए एक अमूर्त का निर्माण कर सकते हैं:

sortByMultiple = (a, b, keys) -> 
    return r if (r = sortBy key, a, b) for key in keys 
    return 0 

users.sort (a,b) -> sortByMultiple a, b, ['id', 'lname', 'fname'] 

लेकिन तब आप इनमें से प्रत्येक पर आदेश या अन्य पैरामीटर निर्धारित करने की क्षमता खो देते हैं।

Answer 2

वैकल्पिक रूप से, आप का उपयोग कर विचार करना चाह सकते Underscore के sortBy आप इसे अपने आप को लागू करने के लिए की जरूरत नहीं है, इसलिए है कि:

_(users).sortBy (u) -> [u.state, u.lname.toUpperCase()] 

Answer 3

यह ऐसा कुछ है जो मैंने सोचा था कि lodash का उपयोग करते समय डिफ़ॉल्ट रूप से लागू किया गया था, लेकिन ऐसा नहीं है।

तो हम यहां हैं!

sortByLowercase: (collection, key) -> 
    collection.sort (a, b) -> 
     [av, bv] = [a[key], b[key]] 
     [av, bv] = [av.toLowerCase(), bv.toLowerCase()] 
     if av >= bv then 1 else if av <= bv then -1 else 0 

sortByLowercase(users,'lname') 

एक अधिक सामान्य उदाहरण मैं here