วิธีการจัดเรียงอาร์เรย์ของวัตถุตามหลายเขตข้อมูล?

จากคำถามเดิมนี้ฉันจะใช้การเรียงลำดับในหลายสาขาได้อย่างไร

การใช้โครงสร้างที่ปรับเปลี่ยนนี้เล็กน้อยฉันจะจัดเรียงเมือง (ขึ้นไป) และราคา (มากไปหาน้อย) ได้อย่างไร

var homes = [
    {"h_id":"3",
     "city":"Dallas",
     "state":"TX",
     "zip":"75201",
     "price":"162500"},
    {"h_id":"4",
     "city":"Bevery Hills",
     "state":"CA",
     "zip":"90210",
     "price":"319250"},
    {"h_id":"6",
     "city":"Dallas",
     "state":"TX",
     "zip":"75000",
     "price":"556699"},
    {"h_id":"5",
     "city":"New York",
     "state":"NY",
     "zip":"00010",
     "price":"962500"}
    ];

ฉันชอบความจริงมากกว่าคำตอบที่ให้ซึ่งเป็นแนวทางทั่วไป ที่ฉันวางแผนที่จะใช้รหัสนี้ฉันจะต้องเรียงลำดับวันที่เช่นเดียวกับสิ่งอื่น ๆ ความสามารถในการ "สำคัญ" วัตถุดูเหมือนจะมีประโยชน์ถ้าไม่ยุ่งยากเล็กน้อย

ฉันพยายามสร้างคำตอบนี้เป็นตัวอย่างทั่วไปที่ดี แต่ฉันไม่มีโชคมาก

วิธีการเรียงลำดับแบบหลายมิติตามคำตอบนี้ :

อัปเดต : นี่คือรุ่น "ปรับให้เหมาะสม" มันจะทำการประมวลผลล่วงหน้ามากขึ้นและสร้างฟังก์ชั่นการเปรียบเทียบสำหรับแต่ละตัวเลือกการเรียงลำดับล่วงหน้า อาจต้องใช้หน่วยความจำเพิ่มเติม (เนื่องจากเก็บฟังก์ชันสำหรับแต่ละตัวเลือกการเรียงลำดับ แต่ควร preform บิตดีกว่าเนื่องจากไม่จำเป็นต้องกำหนดการตั้งค่าที่ถูกต้องระหว่างการเปรียบเทียบฉันยังไม่ได้ทำโปรไฟล์ใด ๆ

var sort_by;

(function() {
    // utility functions
    var default_cmp = function(a, b) {
            if (a == b) return 0;
            return a < b ? -1 : 1;
        },
        getCmpFunc = function(primer, reverse) {
            var dfc = default_cmp, // closer in scope
                cmp = default_cmp;
            if (primer) {
                cmp = function(a, b) {
                    return dfc(primer(a), primer(b));
                };
            }
            if (reverse) {
                return function(a, b) {
                    return -1 * cmp(a, b);
                };
            }
            return cmp;
        };

    // actual implementation
    sort_by = function() {
        var fields = [],
            n_fields = arguments.length,
            field, name, reverse, cmp;

        // preprocess sorting options
        for (var i = 0; i < n_fields; i++) {
            field = arguments[i];
            if (typeof field === 'string') {
                name = field;
                cmp = default_cmp;
            }
            else {
                name = field.name;
                cmp = getCmpFunc(field.primer, field.reverse);
            }
            fields.push({
                name: name,
                cmp: cmp
            });
        }

        // final comparison function
        return function(A, B) {
            var a, b, name, result;
            for (var i = 0; i < n_fields; i++) {
                result = 0;
                field = fields[i];
                name = field.name;

                result = field.cmp(A[name], B[name]);
                if (result !== 0) break;
            }
            return result;
        }
    }
}());

ตัวอย่างการใช้งาน:

homes.sort(sort_by('city', {name:'price', primer: parseInt, reverse: true}));

การสาธิต

ฟังก์ชั่นเดิม:

var sort_by = function() {
   var fields = [].slice.call(arguments),
       n_fields = fields.length;

   return function(A,B) {
       var a, b, field, key, primer, reverse, result, i;

       for(i = 0; i < n_fields; i++) {
           result = 0;
           field = fields[i];

           key = typeof field === 'string' ? field : field.name;

           a = A[key];
           b = B[key];

           if (typeof field.primer  !== 'undefined'){
               a = field.primer(a);
               b = field.primer(b);
           }

           reverse = (field.reverse) ? -1 : 1;

           if (a<b) result = reverse * -1;
           if (a>b) result = reverse * 1;
           if(result !== 0) break;
       }
       return result;
   }
};

การสาธิต

สำหรับวิธีแก้ปัญหาที่ไม่ธรรมดาและไม่ใช่ปัญหาทั่วไปของคุณ:

homes.sort(
   function(a, b) {          
      if (a.city === b.city) {
         // Price is only important when cities are the same
         return b.price - a.price;
      }
      return a.city > b.city ? 1 : -1;
   });

คุณสามารถใช้วิธีการเรียงลำดับที่ถูกโยงโซ่โดยใช้ค่าเดลต้าของค่าจนกว่าจะถึงค่าไม่เท่ากับศูนย์

var data = [{ h_id: "3", city: "Dallas", state: "TX", zip: "75201", price: "162500" }, { h_id: "4", city: "Bevery Hills", state: "CA", zip: "90210", price: "319250" }, { h_id: "6", city: "Dallas", state: "TX", zip: "75000", price: "556699" }, { h_id: "5", city: "New York", state: "NY", zip: "00010", price: "962500" }];

data.sort(function (a, b) {
    return a.city.localeCompare(b.city) || b.price - a.price;
});

console.log(data);

.as-console-wrapper { max-height: 100% !important; top: 0; }

หรือใช้ es6 เพียง:

data.sort((a, b) => a.city.localeCompare(b.city) || b.price - a.price);

นี่คือวิธีการทำงานที่เรียบง่าย ระบุลำดับการจัดเรียงโดยใช้อาร์เรย์ เตรียมลบเพื่อระบุลำดับจากมากไปน้อย

var homes = [
    {"h_id":"3", "city":"Dallas", "state":"TX","zip":"75201","price":"162500"},
    {"h_id":"4","city":"Bevery Hills", "state":"CA", "zip":"90210", "price":"319250"},
    {"h_id":"6", "city":"Dallas", "state":"TX", "zip":"75000", "price":"556699"},
    {"h_id":"5", "city":"New York", "state":"NY", "zip":"00010", "price":"962500"}
    ];

homes.sort(fieldSorter(['city', '-price']));
// homes.sort(fieldSorter(['zip', '-state', 'price'])); // alternative

function fieldSorter(fields) {
    return function (a, b) {
        return fields
            .map(function (o) {
                var dir = 1;
                if (o[0] === '-') {
                   dir = -1;
                   o=o.substring(1);
                }
                if (a[o] > b[o]) return dir;
                if (a[o] < b[o]) return -(dir);
                return 0;
            })
            .reduce(function firstNonZeroValue (p,n) {
                return p ? p : n;
            }, 0);
    };
}

แก้ไข:ใน ES6 มันยิ่งสั้นลง!

"use strict";
const fieldSorter = (fields) => (a, b) => fields.map(o => {
    let dir = 1;
    if (o[0] === '-') { dir = -1; o=o.substring(1); }
    return a[o] > b[o] ? dir : a[o] < b[o] ? -(dir) : 0;
}).reduce((p, n) => p ? p : n, 0);

const homes = [{"h_id":"3", "city":"Dallas", "state":"TX","zip":"75201","price":162500},     {"h_id":"4","city":"Bevery Hills", "state":"CA", "zip":"90210", "price":319250},{"h_id":"6", "city":"Dallas", "state":"TX", "zip":"75000", "price":556699},{"h_id":"5", "city":"New York", "state":"NY", "zip":"00010", "price":962500}];
const sortedHomes = homes.sort(fieldSorter(['state', '-price']));

document.write('<pre>' + JSON.stringify(sortedHomes, null, '\t') + '</pre>')

ฉันทำ sorter หลายคุณสมบัติที่ค่อนข้างทั่วไปวันนี้ คุณสามารถดู thenBy.js ได้ที่นี่: https://github.com/Teun/thenBy.js

อนุญาตให้คุณใช้ Array.sort มาตรฐาน แต่ใช้สไตล์ firstBy () .ByBy () .Boy () .By () มันเป็นวิธีที่น้อยรหัสและความซับซ้อนกว่าโซลูชั่นที่โพสต์ข้างต้น

ฟังก์ชั่นต่อไปนี้จะช่วยให้คุณสามารถเรียงลำดับอาร์เรย์ของออบเจกต์ในคุณสมบัติหนึ่งหรือหลายอย่างทั้งจากน้อยไปมาก (เริ่มต้น) หรือจากมากไปน้อยในแต่ละคุณสมบัติและช่วยให้คุณเลือกว่าจะทำการเปรียบเทียบ โดยค่าเริ่มต้นฟังก์ชั่นนี้จะทำการเรียงตามตัวพิมพ์เล็กและใหญ่

อาร์กิวเมนต์แรกต้องเป็นอาร์เรย์ที่มีวัตถุ อาร์กิวเมนต์ที่ตามมาจะต้องเป็นรายการของสตริงที่คั่นด้วยเครื่องหมายจุลภาคซึ่งอ้างอิงคุณสมบัติของวัตถุที่แตกต่างเพื่อเรียงลำดับ อาร์กิวเมนต์สุดท้าย (ซึ่งเป็นทางเลือก) คือบูลีนเพื่อเลือกว่าจะดำเนินการตามตัวพิมพ์เล็กหรือใหญ่ - หรือไม่trueตามขนาดตัวพิมพ์เล็กหรือใหญ่

ฟังก์ชันจะเรียงลำดับคุณสมบัติ / คีย์แต่ละรายการตามลำดับจากน้อยไปหามากตามค่าเริ่มต้น หากคุณต้องการให้คีย์เฉพาะเรียงลำดับจากมากไปน้อยให้ส่งผ่านอาร์เรย์ในรูปแบบนี้แทน:['property_name', true]ถ้าคุณต้องการที่สำคัญโดยเฉพาะอย่างยิ่งในการเรียงลำดับในลำดับถัดลงแล้วแทนที่จะผ่านในอาร์เรย์ในรูปแบบนี้:

นี่คือตัวอย่างการใช้งานฟังก์ชั่นตามด้วยคำอธิบาย (ที่ไหน) homesเป็นอาร์เรย์ที่มีวัตถุ):

objSort(homes, 'city') -> จัดเรียงตามเมือง (น้อยไปมาก, เล็ก - ใหญ่)

objSort(homes, ['city', true]) -> จัดเรียงตามเมือง (จากมากไปน้อย, เล็ก - ใหญ่)

objSort(homes, 'city', true)-> จัดเรียงตามเมืองแล้วราคา (น้อยไปหามากกรณีที่มีความละเอียดอ่อน )

objSort(homes, 'city', 'price') -> จัดเรียงตามเมืองตามราคาแล้ว (ทั้งจากน้อยไปมากและเล็ก)

objSort(homes, 'city', ['price', true]) -> จัดเรียงตามเมือง (จากน้อยไปมาก) จากนั้นราคา (มากไปหาน้อย), เล็ก - ใหญ่

และถ้าไม่มีความกังวลใจเพิ่มเติมนี่คือฟังก์ชั่น:

function objSort() {
    var args = arguments,
        array = args[0],
        case_sensitive, keys_length, key, desc, a, b, i;

    if (typeof arguments[arguments.length - 1] === 'boolean') {
        case_sensitive = arguments[arguments.length - 1];
        keys_length = arguments.length - 1;
    } else {
        case_sensitive = false;
        keys_length = arguments.length;
    }

    return array.sort(function (obj1, obj2) {
        for (i = 1; i < keys_length; i++) {
            key = args[i];
            if (typeof key !== 'string') {
                desc = key[1];
                key = key[0];
                a = obj1[args[i][0]];
                b = obj2[args[i][0]];
            } else {
                desc = false;
                a = obj1[args[i]];
                b = obj2[args[i]];
            }

            if (case_sensitive === false && typeof a === 'string') {
                a = a.toLowerCase();
                b = b.toLowerCase();
            }

            if (! desc) {
                if (a < b) return -1;
                if (a > b) return 1;
            } else {
                if (a > b) return -1;
                if (a < b) return 1;
            }
        }
        return 0;
    });
} //end of objSort() function

และนี่คือข้อมูลตัวอย่าง:

var homes = [{
    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": 162500
}, {
    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": 1000000
}, {
    "h_id": "5",
    "city": "new york",
    "state": "NY",
    "zip": "00010",
    "price": 1000000
}, {
    "h_id": "6",
    "city": "Dallas",
    "state": "TX",
    "zip": "85000",
    "price": 300000
}, {
    "h_id": "7",
    "city": "New York",
    "state": "NY",
    "zip": "00020",
    "price": 345000
}];

นี่คือการโกงที่สมบูรณ์ แต่ฉันคิดว่ามันเพิ่มคุณค่าให้กับคำถามนี้เพราะโดยทั่วไปแล้วมันเป็นฟังก์ชั่นไลบรารีกระป๋องที่คุณสามารถใช้นอกกรอบได้

หากรหัสของคุณมีการเข้าถึงlodashหรือห้องสมุดที่เข้ากันได้กับ lodash เช่นunderscoreนั้นคุณสามารถใช้_.sortByวิธีการ ข้อมูลด้านล่างจะถูกคัดลอกโดยตรงจากเอกสาร lodash

ผลลัพธ์ที่ถูกคอมเม้นท์ในตัวอย่างนั้นดูเหมือนว่าพวกมันจะคืนค่าอาร์เรย์ของอาร์เรย์ แต่นั่นเป็นเพียงการแสดงลำดับและไม่ใช่ผลลัพธ์ที่แท้จริงซึ่งเป็นอาร์เรย์ของวัตถุ

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 36 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 34 }
];

_.sortBy(users, [function(o) { return o.user; }]);
 // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]

_.sortBy(users, ['user', 'age']);
// => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]

นี่เป็นอีกเรื่องที่ใกล้เคียงกับความคิดของคุณสำหรับไวยากรณ์

function sortObjects(objArray, properties /*, primers*/) {
    var primers = arguments[2] || {}; // primers are optional

    properties = properties.map(function(prop) {
        if( !(prop instanceof Array) ) {
            prop = [prop, 'asc']
        }
        if( prop[1].toLowerCase() == 'desc' ) {
            prop[1] = -1;
        } else {
            prop[1] = 1;
        }
        return prop;
    });

    function valueCmp(x, y) {
        return x > y ? 1 : x < y ? -1 : 0; 
    }

    function arrayCmp(a, b) {
        var arr1 = [], arr2 = [];
        properties.forEach(function(prop) {
            var aValue = a[prop[0]],
                bValue = b[prop[0]];
            if( typeof primers[prop[0]] != 'undefined' ) {
                aValue = primers[prop[0]](aValue);
                bValue = primers[prop[0]](bValue);
            }
            arr1.push( prop[1] * valueCmp(aValue, bValue) );
            arr2.push( prop[1] * valueCmp(bValue, aValue) );
        });
        return arr1 < arr2 ? -1 : 1;
    }

    objArray.sort(function(a, b) {
        return arrayCmp(a, b);
    });
}

// just for fun use this to reverse the city name when sorting
function demoPrimer(str) {
    return str.split('').reverse().join('');
}

// Example
sortObjects(homes, ['city', ['price', 'desc']], {city: demoPrimer});

การสาธิต: http://jsfiddle.net/Nq4dk/2/

แก้ไข: เพื่อความสนุกนี่คือรูปแบบที่ใช้สตริงเหมือน sql ดังนั้นคุณสามารถทำได้sortObjects(homes, "city, price desc")

function sortObjects(objArray, properties /*, primers*/) {
    var primers = arguments[2] || {};

    properties = properties.split(/\s*,\s*/).map(function(prop) {
        prop = prop.match(/^([^\s]+)(\s*desc)?/i);
        if( prop[2] && prop[2].toLowerCase() === 'desc' ) {
            return [prop[1] , -1];
        } else {
            return [prop[1] , 1];
        }
    });

    function valueCmp(x, y) {
        return x > y ? 1 : x < y ? -1 : 0; 
    }

    function arrayCmp(a, b) {
        var arr1 = [], arr2 = [];
        properties.forEach(function(prop) {
            var aValue = a[prop[0]],
                bValue = b[prop[0]];
            if( typeof primers[prop[0]] != 'undefined' ) {
                aValue = primers[prop[0]](aValue);
                bValue = primers[prop[0]](bValue);
            }
            arr1.push( prop[1] * valueCmp(aValue, bValue) );
            arr2.push( prop[1] * valueCmp(bValue, aValue) );
        });
        return arr1 < arr2 ? -1 : 1;
    }

    objArray.sort(function(a, b) {
        return arrayCmp(a, b);
    });
}

เรียบง่ายหนึ่ง:

var someArray = [...];

function generateSortFn(props) {
    return function (a, b) {
        for (var i = 0; i < props.length; i++) {
            var prop = props[i];
            var name = prop.name;
            var reverse = prop.reverse;
            if (a[name] < b[name])
                return reverse ? 1 : -1;
            if (a[name] > b[name])
                return reverse ? -1 : 1;
        }
        return 0;
    };
};

someArray.sort(generateSortFn([{name: 'prop1', reverse: true}, {name: 'prop2'}]));

นี่คือการจัดเรียงหลายมิติทั่วไปช่วยให้สามารถย้อนกลับและ / หรือทำแผนที่ในแต่ละระดับ

เขียนใน typescript สำหรับ Javascript ให้ตรวจสอบJSFiddleนี้

รหัส

type itemMap = (n: any) => any;

interface SortConfig<T> {
  key: keyof T;
  reverse?: boolean;
  map?: itemMap;
}

export function byObjectValues<T extends object>(keys: ((keyof T) | SortConfig<T>)[]): (a: T, b: T) => 0 | 1 | -1 {
  return function(a: T, b: T) {
    const firstKey: keyof T | SortConfig<T> = keys[0];
    const isSimple = typeof firstKey === 'string';
    const key: keyof T = isSimple ? (firstKey as keyof T) : (firstKey as SortConfig<T>).key;
    const reverse: boolean = isSimple ? false : !!(firstKey as SortConfig<T>).reverse;
    const map: itemMap | null = isSimple ? null : (firstKey as SortConfig<T>).map || null;

    const valA = map ? map(a[key]) : a[key];
    const valB = map ? map(b[key]) : b[key];
    if (valA === valB) {
      if (keys.length === 1) {
        return 0;
      }
      return byObjectValues<T>(keys.slice(1))(a, b);
    }
    if (reverse) {
      return valA > valB ? -1 : 1;
    }
    return valA > valB ? 1 : -1;
  };
}

ตัวอย่างการใช้งาน

เรียงลำดับอาร์เรย์บุคคลตามนามสกุลแล้วชื่อ:

interface Person {
  firstName: string;
  lastName: string;
}

people.sort(byObjectValues<Person>(['lastName','firstName']));

เรียงรหัสภาษาตามชื่อไม่ใช่รหัสภาษา (ดูmap) จากนั้นเรียงตามรุ่นจากมากไปน้อย (ดูreverse)

interface Language {
  code: string;
  version: number;
}

// languageCodeToName(code) is defined elsewhere in code

languageCodes.sort(byObjectValues<Language>([
  {
    key: 'code',
    map(code:string) => languageCodeToName(code),
  },
  {
    key: 'version',
    reverse: true,
  }
]));

ฉันชอบวิธีการของ SnowBurnt แต่ต้องการบิดเพื่อทดสอบความเท่าเทียมกันในเมืองไม่แตกต่างกัน

homes.sort(
   function(a,b){
      if (a.city==b.city){
         return (b.price-a.price);
      } else {
         return (a.city-b.city);
      }
   });

วิธีแบบไดนามิกในการทำเช่นนั้นด้วยปุ่ม MULTIPLE:

• กรองค่าที่ไม่ซ้ำจากแต่ละคอลัมน์ / เรียงลำดับ
• ใส่ในการสั่งซื้อหรือย้อนกลับ
• เพิ่มความกว้างของน้ำหนัก zeropad สำหรับแต่ละวัตถุโดยยึดตามค่าคีย์ indexOf (ค่า)
• จัดเรียงโดยใช้น้ำหนัก caclutated

Object.defineProperty(Array.prototype, 'orderBy', {
value: function(sorts) { 
    sorts.map(sort => {            
        sort.uniques = Array.from(
            new Set(this.map(obj => obj[sort.key]))
        );

        sort.uniques = sort.uniques.sort((a, b) => {
            if (typeof a == 'string') {
                return sort.inverse ? b.localeCompare(a) : a.localeCompare(b);
            }
            else if (typeof a == 'number') {
                return sort.inverse ? (a < b) : (a > b ? 1 : 0);
            }
            else if (typeof a == 'boolean') {
                let x = sort.inverse ? (a === b) ? 0 : a? -1 : 1 : (a === b) ? 0 : a? 1 : -1;
                return x;
            }
            return 0;
        });
    });

    const weightOfObject = (obj) => {
        let weight = "";
        sorts.map(sort => {
            let zeropad = `${sort.uniques.length}`.length;
            weight += sort.uniques.indexOf(obj[sort.key]).toString().padStart(zeropad, '0');
        });
        //obj.weight = weight; // if you need to see weights
        return weight;
    }

    this.sort((a, b) => {
        return weightOfObject(a).localeCompare( weightOfObject(b) );
    });

    return this;
}
});

ใช้:

// works with string, number and boolean
let sortered = your_array.orderBy([
    {key: "type", inverse: false}, 
    {key: "title", inverse: false},
    {key: "spot", inverse: false},
    {key: "internal", inverse: true}
]);

นี่คือโซลูชันทั่วไปของ @ Snowburnt:

var sortarray = [{field:'city', direction:'asc'}, {field:'price', direction:'desc'}];
array.sort(function(a,b){
    for(var i=0; i<sortarray.length; i++){
        retval = a[sortarray[i].field] < b[sortarray[i].field] ? -1 : a[sortarray[i].field] > b[sortarray[i].field] ? 1 : 0;
        if (sortarray[i].direction == "desc") {
            retval = retval * -1;
        }
        if (retval !== 0) {
            return retval;
        }
    }
}


})

สิ่งนี้ขึ้นอยู่กับขั้นตอนการเรียงลำดับที่ฉันใช้ ฉันไม่ได้ทดสอบรหัสเฉพาะนี้ดังนั้นจึงอาจมีข้อผิดพลาด แต่คุณได้รับแนวคิด แนวคิดคือการเรียงลำดับตามฟิลด์แรกที่ระบุความแตกต่างจากนั้นหยุดและไปที่ระเบียนถัดไป ดังนั้นหากคุณเรียงลำดับโดยสามเขตข้อมูลและเขตข้อมูลแรกในการเปรียบเทียบนั้นเพียงพอที่จะกำหนดลำดับการเรียงของสองระเบียนที่เรียงลำดับจากนั้นส่งคืนผลลัพธ์การเรียงลำดับนั้นและไปที่ระเบียนถัดไป

ฉันทดสอบแล้ว (จริง ๆ แล้วมีตรรกะการเรียงลำดับที่ซับซ้อนกว่าเล็กน้อย) ในบันทึก 5000 รายการและทำในพริบตา หากคุณกำลังโหลดเรคคอร์ดมากกว่า 1,000 รายการไปยังไคลเอนต์คุณควรใช้การเรียงลำดับและการกรองด้านเซิร์ฟเวอร์

รหัสนี้ไม่ได้จัดการตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ แต่ฉันปล่อยไว้ที่ตัวอ่านเพื่อจัดการกับการดัดแปลงเล็กน้อย

นี่คือวิธีการแก้ปัญหาของฉันตามSchwartzian transform idiomหวังว่าคุณจะพบว่ามีประโยชน์

function sortByAttribute(array, ...attrs) {
  // generate an array of predicate-objects contains
  // property getter, and descending indicator
  let predicates = attrs.map(pred => {
    let descending = pred.charAt(0) === '-' ? -1 : 1;
    pred = pred.replace(/^-/, '');
    return {
      getter: o => o[pred],
      descend: descending
    };
  });
  // schwartzian transform idiom implementation. aka: "decorate-sort-undecorate"
  return array.map(item => {
    return {
      src: item,
      compareValues: predicates.map(predicate => predicate.getter(item))
    };
  })
  .sort((o1, o2) => {
    let i = -1, result = 0;
    while (++i < predicates.length) {
      if (o1.compareValues[i] < o2.compareValues[i]) result = -1;
      if (o1.compareValues[i] > o2.compareValues[i]) result = 1;
      if (result *= predicates[i].descend) break;
    }
    return result;
  })
  .map(item => item.src);
}

นี่คือตัวอย่างวิธีการใช้งาน:

let games = [
  { name: 'Pako',              rating: 4.21 },
  { name: 'Hill Climb Racing', rating: 3.88 },
  { name: 'Angry Birds Space', rating: 3.88 },
  { name: 'Badland',           rating: 4.33 }
];

// sort by one attribute
console.log(sortByAttribute(games, 'name'));
// sort by mupltiple attributes
console.log(sortByAttribute(games, '-rating', 'name'));

อีกวิธีหนึ่ง

var homes = [
    {"h_id":"3",
     "city":"Dallas",
     "state":"TX",
     "zip":"75201",
     "price":"162500"},
    {"h_id":"4",
     "city":"Bevery Hills",
     "state":"CA",
     "zip":"90210",
     "price":"319250"},
    {"h_id":"6",
     "city":"Dallas",
     "state":"TX",
     "zip":"75000",
     "price":"556699"},
    {"h_id":"5",
     "city":"New York",
     "state":"NY",
     "zip":"00010",
     "price":"962500"}
    ];
function sortBy(ar) {
  return ar.sort((a, b) => a.city === b.city ?
      b.price.toString().localeCompare(a.price) :
      a.city.toString().localeCompare(b.city));
}
console.log(sortBy(homes));

function sortMultiFields(prop){
    return function(a,b){
        for(i=0;i<prop.length;i++)
        {
            var reg = /^\d+$/;
            var x=1;
            var field1=prop[i];
            if(prop[i].indexOf("-")==0)
            {
                field1=prop[i].substr(1,prop[i].length);
                x=-x;
            }

            if(reg.test(a[field1]))
            {
                a[field1]=parseFloat(a[field1]);
                b[field1]=parseFloat(b[field1]);
            }
            if( a[field1] > b[field1])
                return x;
            else if(a[field1] < b[field1])
                return -x;
        }
    }
}

วิธีใช้ (ใส่ - (ลบ) เครื่องหมายก่อนช่องถ้าคุณต้องการเรียงลำดับจากมากไปหาน้อยในฟิลด์)

homes.sort(sortMultiFields(["city","-price"]));

การใช้ฟังก์ชั่นด้านบนคุณสามารถเรียงลำดับ json array ที่มีหลายฟิลด์ได้ ไม่จำเป็นต้องเปลี่ยนฟังก์ชั่นร่างกายเลย

การปรับคำตอบของ @chriskelly

คำตอบส่วนใหญ่มองข้ามว่าราคาจะเรียงลำดับไม่ถูกต้องหากค่าอยู่ในหลักหมื่นและต่ำกว่าหรือมากกว่าหนึ่งล้าน resaon เป็น JS เรียงลำดับตัวอักษร มันได้รับคำตอบที่ดีสวยทำไม JavaScript ไม่สามารถเรียง "5, 10, 1"และที่นี่วิธีการเรียงลำดับของจำนวนเต็มอย่างถูกต้องวิธีการเรียงลำดับอาร์เรย์ของจำนวนเต็มได้อย่างถูกต้อง

ในที่สุดเราต้องทำการประเมินผลถ้าเขตข้อมูลหรือโหนดที่เราเรียงลำดับโดยเป็นตัวเลข ฉันไม่ได้บอกว่าการใช้parseInt()ในกรณีนี้เป็นคำตอบที่ถูกต้องผลลัพธ์ที่เรียงกันมีความสำคัญมากกว่า

var homes = [{
  "h_id": "2",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "62500"
}, {
  "h_id": "1",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "62510"
}, {
  "h_id": "3",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "162500"
}, {
  "h_id": "4",
  "city": "Bevery Hills",
  "state": "CA",
  "zip": "90210",
  "price": "319250"
}, {
  "h_id": "6",
  "city": "Dallas",
  "state": "TX",
  "zip": "75000",
  "price": "556699"
}, {
  "h_id": "5",
  "city": "New York",
  "state": "NY",
  "zip": "00010",
  "price": "962500"
}];

homes.sort(fieldSorter(['price']));
// homes.sort(fieldSorter(['zip', '-state', 'price'])); // alternative

function fieldSorter(fields) {
  return function(a, b) {
    return fields
      .map(function(o) {
        var dir = 1;
        if (o[0] === '-') {
          dir = -1;
          o = o.substring(1);
        }
        if (!parseInt(a[o]) && !parseInt(b[o])) {
          if (a[o] > b[o]) return dir;
          if (a[o] < b[o]) return -(dir);
          return 0;
        } else {
          return dir > 0 ? a[o] - b[o] : b[o] - a[o];
        }
      })
      .reduce(function firstNonZeroValue(p, n) {
        return p ? p : n;
      }, 0);
  };
}
document.getElementById("output").innerHTML = '<pre>' + JSON.stringify(homes, null, '\t') + '</pre>';

<div id="output">

</div>

ซอที่จะทดสอบด้วย

ว้าวมีบางวิธีแก้ปัญหาที่ซับซ้อนอยู่ที่นี่ ซับซ้อนดังนั้นฉันตัดสินใจที่จะเกิดขึ้นกับสิ่งที่ง่ายขึ้น แต่ก็มีประสิทธิภาพมาก นี่มันคือ;

function sortByPriority(data, priorities) {
  if (priorities.length == 0) {
    return data;
  }

  const nextPriority = priorities[0];
  const remainingPriorities = priorities.slice(1);

  const matched = data.filter(item => item.hasOwnProperty(nextPriority));
  const remainingData = data.filter(item => !item.hasOwnProperty(nextPriority));

  return sortByPriority(matched, remainingPriorities)
    .sort((a, b) => (a[nextPriority] > b[nextPriority]) ? 1 : -1)
    .concat(sortByPriority(remainingData, remainingPriorities));
}

และนี่คือตัวอย่างของวิธีการใช้งานของคุณ

const data = [
  { id: 1,                         mediumPriority: 'bbb', lowestPriority: 'ggg' },
  { id: 2, highestPriority: 'bbb', mediumPriority: 'ccc', lowestPriority: 'ggg' },
  { id: 3,                         mediumPriority: 'aaa', lowestPriority: 'ggg' },
];

const priorities = [
  'highestPriority',
  'mediumPriority',
  'lowestPriority'
];


const sorted = sortByPriority(data, priorities);

สิ่งนี้จะจัดเรียงตามลำดับความสำคัญของแอตทริบิวต์จากนั้นตามค่าของแอตทริบิวต์

ต่อไปนี้เป็นวิธีที่ขยายได้ในการจัดเรียงตามเขตข้อมูลหลาย ๆ แห่ง

homes.sort(function(left, right) {
    var city_order = left.city.localeCompare(right.city);
    var price_order = parseInt(left.price) - parseInt(right.price);
    return city_order || -price_order;
});

หมายเหตุ

• a.localeCompare(b)จะได้รับการสนับสนุนในระดับสากลและผลตอบแทน -1,0,1 ถ้าa<b, a==b, a>bตามลำดับ
• การลบจะทำงานในฟิลด์ตัวเลข
• ||ในบรรทัดสุดท้ายให้มากกว่าความสำคัญcityprice
• ปฏิเสธที่จะกลับคำสั่งซื้อในสาขาใด ๆ เช่นใน -price_order
• เปรียบเทียบวัน , var date_order = new Date(left.date) - new Date(right.date);ทำงานเหมือน numerics เพราะคณิตศาสตร์วันจะกลายเป็นมิลลิวินาทีตั้งแต่ปี 1970
• เพิ่มเขตข้อมูลลงใน or-chain return city_order || -price_order || date_order;

ฉันคิดว่านี่อาจเป็นวิธีที่ง่ายที่สุดที่จะทำ

https://coderwall.com/p/ebqhca/javascript-sort-by-two-fields

มันง่ายมากและฉันลองกับคู่ค่าคีย์ที่แตกต่างกัน 3 ชุดและใช้งานได้ดี

นี่คือตัวอย่างง่ายๆดูลิงค์สำหรับรายละเอียดเพิ่มเติม

testSort(data) {
    return data.sort(
        a['nameOne'] > b['nameOne'] ? 1
        : b['nameOne'] > a['nameOne'] ? -1 : 0 ||
        a['date'] > b['date'] ||
        a['number'] - b['number']
    );
}

นี่คือของฉันสำหรับการอ้างอิงของคุณด้วยตัวอย่าง:

function msort(arr, ...compFns) {
  let fn = compFns[0];
  arr = [].concat(arr);
  let arr1 = [];
  while (arr.length > 0) {
    let arr2 = arr.splice(0, 1);
    for (let i = arr.length; i > 0;) {
      if (fn(arr2[0], arr[--i]) === 0) {
        arr2 = arr2.concat(arr.splice(i, 1));
      }
    }
    arr1.push(arr2);
  }

  arr1.sort(function (a, b) {
    return fn(a[0], b[0]);
  });

  compFns = compFns.slice(1);
  let res = [];
  arr1.map(a1 => {
    if (compFns.length > 0) a1 = msort(a1, ...compFns);
    a1.map(a2 => res.push(a2));
  });
  return res;
}

let tstArr = [{ id: 1, sex: 'o' }, { id: 2, sex: 'm' }, { id: 3, sex: 'm' }, { id: 4, sex: 'f' }, { id: 5, sex: 'm' }, { id: 6, sex: 'o' }, { id: 7, sex: 'f' }];

function tstFn1(a, b) {
  if (a.sex > b.sex) return 1;
  else if (a.sex < b.sex) return -1;
  return 0;
}

function tstFn2(a, b) {
  if (a.id > b.id) return -1;
  else if (a.id < b.id) return 1;
  return 0;
}

console.log(JSON.stringify(msort(tstArr, tstFn1, tstFn2)));
//output:
//[{"id":7,"sex":"f"},{"id":4,"sex":"f"},{"id":5,"sex":"m"},{"id":3,"sex":"m"},{"id":2,"sex":"m"},{"id":6,"sex":"o"},{"id":1,"sex":"o"}]

ฉันกำลังมองหาสิ่งที่คล้ายกันและจบลงด้วยสิ่งนี้:

ก่อนอื่นเรามีฟังก์ชั่นการเรียงลำดับอย่างน้อยหนึ่งฟังก์ชันส่งคืนค่า 0, 1 หรือ -1 เสมอ:

const sortByTitle = (a, b): number => 
  a.title === b.title ? 0 : a.title > b.title ? 1 : -1;

คุณสามารถสร้างฟังก์ชั่นเพิ่มเติมสำหรับแต่ละคุณสมบัติที่คุณต้องการเรียงลำดับ

จากนั้นฉันก็มีฟังก์ชั่นที่รวมฟังก์ชั่นการเรียงลำดับเหล่านี้ไว้ในที่เดียว:

const createSorter = (...sorters) => (a, b) =>
  sorters.reduce(
    (d, fn) => (d === 0 ? fn(a, b) : d),
    0
  );

สิ่งนี้สามารถใช้เพื่อรวมฟังก์ชั่นการเรียงลำดับข้างต้นในวิธีที่อ่านได้:

const sorter = createSorter(sortByTitle, sortByYear)

items.sort(sorter)

เมื่อฟังก์ชันการเรียงลำดับส่งคืน 0 ฟังก์ชันการเรียงลำดับถัดไปจะถูกเรียกใช้สำหรับการเรียงลำดับเพิ่มเติม

ตัวเลือกอื่น ลองใช้ฟังก์ชั่นยูทิลิตี้ต่อไปนี้:

/** Performs comparing of two items by specified properties
 * @param  {Array} props for sorting ['name'], ['value', 'city'], ['-date']
 * to set descending order on object property just add '-' at the begining of property
 */
export const compareBy = (...props) => (a, b) => {
  for (let i = 0; i < props.length; i++) {
    const ascValue = props[i].startsWith('-') ? -1 : 1;
    const prop = props[i].startsWith('-') ? props[i].substr(1) : props[i];
    if (a[prop] !== b[prop]) {
      return a[prop] > b[prop] ? ascValue : -ascValue;
    }
  }
  return 0;
};

ตัวอย่างการใช้งาน (ในกรณีของคุณ):

homes.sort(compareBy('city', '-price'));

ควรสังเกตว่าฟังก์ชั่นนี้สามารถทำให้เป็นมาตรฐานได้มากขึ้นเพื่อที่จะสามารถใช้คุณสมบัติที่ซ้อนกันเช่น 'address.city' หรือ 'style.size.width' เป็นต้น

นี่เป็นอัลกอริทึมแบบเรียกซ้ำเพื่อเรียงลำดับตามเขตข้อมูลต่างๆในขณะที่มีโอกาสจัดรูปแบบค่าก่อนการเปรียบเทียบ

var data = [
{
    "id": 1,
    "ship": null,
    "product": "Orange",
    "quantity": 7,
    "price": 92.08,
    "discount": 0
},
{
    "id": 2,
    "ship": "2017-06-14T23:00:00.000Z".toDate(),
    "product": "Apple",
    "quantity": 22,
    "price": 184.16,
    "discount": 0
},
...
]
var sorts = ["product", "quantity", "ship"]

// comp_val formats values and protects against comparing nulls/undefines
// type() just returns the variable constructor
// String.lower just converts the string to lowercase.
// String.toDate custom fn to convert strings to Date
function comp_val(value){
    if (value==null || value==undefined) return null
    var cls = type(value)
    switch (cls){
        case String:
            return value.lower()
    }
    return value
}

function compare(a, b, i){
    i = i || 0
    var prop = sorts[i]
    var va = comp_val(a[prop])
    var vb = comp_val(b[prop])

    // handle what to do when both or any values are null
    if (va == null || vb == null) return true

    if ((i < sorts.length-1) && (va == vb)) {
        return compare(a, b, i+1)
    } 
    return va > vb
}

var d = data.sort(compare);
console.log(d);

หาก a และ b เท่ากันมันจะลองใช้ฟิลด์ถัดไปจนกว่าจะไม่สามารถใช้ได้

homes.sort(function(a,b) { return a.city - b.city } );
homes.sort(function(a,b){
    if (a.city==b.city){
        return parseFloat(b.price) - parseFloat(a.price);
    } else {
        return 0;
    }
});

นี่คือ 'AffiliateDueDate' และ 'ชื่อ' เป็นคอลัมน์ซึ่งทั้งคู่จะเรียงลำดับจากน้อยไปหามาก

array.sort(function(a, b) {

               if (a.AffiliateDueDate > b.AffiliateDueDate ) return 1;
               else if (a.AffiliateDueDate < b.AffiliateDueDate ) return -1;
               else if (a.Title > b.Title ) return 1;
               else if (a.Title < b.Title ) return -1;
               else return 0;
             })

การเรียงลำดับในสองฟิลด์วันที่และตัวอย่างฟิลด์ตัวเลข:

var generic_date =  new Date(2070, 1, 1);
checkDate = function(date) {
  return Date.parse(date) ? new Date(date): generic_date;
}

function sortData() {  
  data.sort(function(a,b){
    var deltaEnd = checkDate(b.end) - checkDate(a.end);
    if(deltaEnd) return deltaEnd;

    var deltaRank = a.rank - b.rank;
    if (deltaRank) return deltaRank;

    var deltaStart = checkDate(b.start) - checkDate(a.start);
    if(deltaStart) return deltaStart;

    return 0;
  });
}

http://jsfiddle.net/hcWgf/57/

function sort(data, orderBy) {
        orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
        return data.sort((a, b) => {
            for (let i = 0, size = orderBy.length; i < size; i++) {
                const key = Object.keys(orderBy[i])[0],
                    o = orderBy[i][key],
                    valueA = a[key],
                    valueB = b[key];
                if (!(valueA || valueB)) {
                    console.error("the objects from the data passed does not have the key '" + key + "' passed on sort!");
                    return [];
                }
                if (+valueA === +valueA) {
                    return o.toLowerCase() === 'desc' ? valueB - valueA : valueA - valueB;
                } else {
                    if (valueA.localeCompare(valueB) > 0) {
                        return o.toLowerCase() === 'desc' ? -1 : 1;
                    } else if (valueA.localeCompare(valueB) < 0) {
                        return o.toLowerCase() === 'desc' ? 1 : -1;
                    }
                }
            }
        });
    }