ขีดล่าง: sortBy () ตามแอตทริบิวต์หลายรายการ

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

var patients = [
             [{name: 'John', roomNumber: 1, bedNumber: 1}],
             [{name: 'Lisa', roomNumber: 1, bedNumber: 2}],
             [{name: 'Chris', roomNumber: 2, bedNumber: 1}],
             [{name: 'Omar', roomNumber: 3, bedNumber: 1}]
               ];

การเรียงลำดับตามroomNumberแอตทริบิวต์ฉันจะใช้รหัสต่อไปนี้:

var sortedArray = _.sortBy(patients, function(patient) {
    return patient[0].roomNumber;
});

วิธีนี้ใช้งานได้ดี แต่ฉันจะดำเนินการอย่างไรเพื่อให้ 'John' และ 'Lisa' เรียงลำดับอย่างถูกต้อง?

sortBy บอกว่าเป็นอัลกอริทึมการจัดเรียงที่เสถียรดังนั้นคุณควรจะสามารถจัดเรียงตามคุณสมบัติที่สองของคุณก่อนจากนั้นจัดเรียงอีกครั้งตามคุณสมบัติแรกของคุณดังนี้:

var sortedArray = _(patients).chain().sortBy(function(patient) {
    return patient[0].name;
}).sortBy(function(patient) {
    return patient[0].roomNumber;
}).value();

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

นี่คือเคล็ดลับแฮ็คที่ฉันใช้ในบางครั้งในกรณีเหล่านี้: รวมคุณสมบัติในลักษณะที่ผลลัพธ์จะจัดเรียงได้:

var sortedArray = _.sortBy(patients, function(patient) {
  return [patient[0].roomNumber, patient[0].name].join("_");
});

อย่างไรก็ตามอย่างที่ฉันบอกว่ามันค่อนข้างแฮ็ค ในการดำเนินการนี้อย่างถูกต้องคุณอาจต้องการใช้เมธอดJavaScript หลักsort :

patients.sort(function(x, y) {
  var roomX = x[0].roomNumber;
  var roomY = y[0].roomNumber;
  if (roomX !== roomY) {
    return compare(roomX, roomY);
  }
  return compare(x[0].name, y[0].name);
});

// General comparison function for convenience
function compare(x, y) {
  if (x === y) {
    return 0;
  }
  return x > y ? 1 : -1;
}

แน่นอนสิ่งนี้จะจัดเรียงอาร์เรย์ของคุณให้เข้าที่ หากคุณต้องการคัดลอกแบบเรียงลำดับ (ต้องการ_.sortByให้คุณ) โคลนอาร์เรย์ก่อน:

function sortOutOfPlace(sequence, sorter) {
  var copy = _.clone(sequence);
  copy.sort(sorter);
  return copy;
}

ด้วยความเบื่อหน่ายฉันเพิ่งเขียนวิธีแก้ปัญหาทั่วไป (เพื่อจัดเรียงตามจำนวนคีย์ใด ๆ ก็ตาม) สำหรับสิ่งนี้เช่นกัน: ดูสิ

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

var sortedPatients = _.chain(patients)
  .sortBy('Name')
  .sortBy('RoomNumber')
  .value();

btw การเริ่มต้นของคุณสำหรับผู้ป่วยเป็นเรื่องแปลกใช่ไหม ทำไมคุณไม่เริ่มต้นตัวแปรนี้เนื่องจากนี่คืออาร์เรย์ของวัตถุที่แท้จริง - คุณสามารถทำได้โดยใช้ _.flatten ()ไม่ใช่อาร์เรย์อาร์เรย์ของออบเจ็กต์เดียวอาจเป็นปัญหาการพิมพ์ผิด):

var patients = [
        {name: 'Omar', roomNumber: 3, bedNumber: 1},
        {name: 'John', roomNumber: 1, bedNumber: 1},
        {name: 'Chris', roomNumber: 2, bedNumber: 1},
        {name: 'Lisa', roomNumber: 1, bedNumber: 2},
        {name: 'Kiko', roomNumber: 1, bedNumber: 2}
        ];

ฉันจัดเรียงรายการต่างออกไปและเพิ่ม Kiko เข้าไปในเตียงของ Lisa เพื่อความสนุกสนานและดูว่าจะมีการเปลี่ยนแปลงอะไรบ้าง ...

var sorted = _(patients).sortBy( 
                    function(patient){
                       return [patient.roomNumber, patient.bedNumber, patient.name];
                    });

ตรวจสอบการจัดเรียงแล้วคุณจะเห็นสิ่งนี้

[
{bedNumber: 1, name: "John", roomNumber: 1}, 
{bedNumber: 2, name: "Kiko", roomNumber: 1}, 
{bedNumber: 2, name: "Lisa", roomNumber: 1}, 
{bedNumber: 1, name: "Chris", roomNumber: 2}, 
{bedNumber: 1, name: "Omar", roomNumber: 3}
]

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

var sorted = _(patients).chain()
                        .flatten()
                        .sortBy( function(patient){
                              return [patient.roomNumber, 
                                     patient.bedNumber, 
                                     patient.name];
                        })
                        .value();

และการทดสอบจะน่าสนใจ ...

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

นี่คือโซลูชันที่รวดเร็วมีประสิทธิภาพช่วยให้สามารถจัดเรียงย้อนกลับได้ง่ายและสามารถใช้ร่วมกับunderscoreหรือlodashหรือโดยตรงกับArray.sort

ส่วนที่สำคัญที่สุดคือcompositeComparatorเมธอดซึ่งใช้อาร์เรย์ของฟังก์ชันตัวเปรียบเทียบและส่งคืนฟังก์ชันตัวเปรียบเทียบคอมโพสิตใหม่

/**
 * Chains a comparator function to another comparator
 * and returns the result of the first comparator, unless
 * the first comparator returns 0, in which case the
 * result of the second comparator is used.
 */
function makeChainedComparator(first, next) {
  return function(a, b) {
    var result = first(a, b);
    if (result !== 0) return result;
    return next(a, b);
  }
}

/**
 * Given an array of comparators, returns a new comparator with
 * descending priority such that
 * the next comparator will only be used if the precending on returned
 * 0 (ie, found the two objects to be equal)
 *
 * Allows multiple sorts to be used simply. For example,
 * sort by column a, then sort by column b, then sort by column c
 */
function compositeComparator(comparators) {
  return comparators.reduceRight(function(memo, comparator) {
    return makeChainedComparator(comparator, memo);
  });
}

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

function naturalSort(field) {
  return function(a, b) {
    var c1 = a[field];
    var c2 = b[field];
    if (c1 > c2) return 1;
    if (c1 < c2) return -1;
    return 0;
  }
}

(รหัสทั้งหมดจนถึงตอนนี้สามารถใช้ซ้ำได้และสามารถเก็บไว้ในโมดูลยูทิลิตี้เป็นต้น)

ถัดไปคุณต้องสร้างตัวเปรียบเทียบคอมโพสิต สำหรับตัวอย่างของเราจะมีลักษณะดังนี้:

var cmp = compositeComparator([naturalSort('roomNumber'), naturalSort('name')]);

โดยจะเรียงตามหมายเลขห้องแล้วตามด้วยชื่อ การเพิ่มเกณฑ์การจัดเรียงเพิ่มเติมเป็นเรื่องเล็กน้อยและไม่มีผลต่อประสิทธิภาพของการจัดเรียง

var patients = [
 {name: 'John', roomNumber: 3, bedNumber: 1},
 {name: 'Omar', roomNumber: 2, bedNumber: 1},
 {name: 'Lisa', roomNumber: 2, bedNumber: 2},
 {name: 'Chris', roomNumber: 1, bedNumber: 1},
];

// Sort using the composite
patients.sort(cmp);

console.log(patients);

ส่งคืนสิ่งต่อไปนี้

[ { name: 'Chris', roomNumber: 1, bedNumber: 1 },
  { name: 'Lisa', roomNumber: 2, bedNumber: 2 },
  { name: 'Omar', roomNumber: 2, bedNumber: 1 },
  { name: 'John', roomNumber: 3, bedNumber: 1 } ]

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

ตัวอย่างง่ายๆจากhttp://janetriley.net/2014/12/sort-on-multiple-keys-with-underscores-sortby.html (เอื้อเฟื้อโดย @MikeDevenney)

รหัส

var FullySortedArray = _.sortBy(( _.sortBy(array, 'second')), 'first');

ด้วยข้อมูลของคุณ

var FullySortedArray = _.sortBy(( _.sortBy(patients, 'roomNumber')), 'name');

บางที underscore.js หรือแค่ Javascript engine อาจแตกต่างจากตอนที่เขียนคำตอบเหล่านี้ แต่ฉันสามารถแก้ปัญหานี้ได้โดยส่งคืนอาร์เรย์ของคีย์การเรียงลำดับ

var input = [];

for (var i = 0; i < 20; ++i) {
  input.push({
    a: Math.round(100 * Math.random()),
    b: Math.round(3 * Math.random())
  })
}

var output = _.sortBy(input, function(o) {
  return [o.b, o.a];
});

// output is now sorted by b ascending, a ascending

ในการดำเนินการโปรดดูซอนี้: https://jsfiddle.net/mikeular/xenu3u91/

เพียงส่งคืนอาร์เรย์ของคุณสมบัติที่คุณต้องการจัดเรียงด้วย:

ไวยากรณ์ ES6

var sortedArray = _.sortBy(patients, patient => [patient[0].name, patient[1].roomNumber])

ไวยากรณ์ ES5

var sortedArray = _.sortBy(patients, function(patient) { 
    return [patient[0].name, patient[1].roomNumber]
})

สิ่งนี้ไม่มีผลข้างเคียงใด ๆ จากการแปลงตัวเลขเป็นสตริง

คุณสามารถเชื่อมต่อคุณสมบัติที่คุณต้องการจัดเรียงในตัววนซ้ำ:

return [patient[0].roomNumber,patient[0].name].join('|');

หรือสิ่งที่เทียบเท่า

หมายเหตุ: เนื่องจากคุณกำลังแปลงแอตทริบิวต์ที่เป็นตัวเลข roomNumber เป็นสตริงคุณจะต้องทำอะไรบางอย่างถ้าคุณมีหมายเลขห้อง> 10 มิฉะนั้น 11 จะมาก่อน 2 คุณสามารถใส่เลขศูนย์นำหน้าเพื่อแก้ปัญหาได้เช่น 01 แทนที่จะเป็น 1

ฉันคิดว่าคุณควรใช้_.orderByแทนsortBy:

_.orderBy(patients, ['name', 'roomNumber'], ['asc', 'desc'])

หากคุณกำลังใช้ Angular คุณสามารถใช้ตัวกรองตัวเลขในไฟล์ html แทนการเพิ่มตัวจัดการ JS หรือ CSS ตัวอย่างเช่น:

  No fractions: <span>{{val | number:0}}</span><br>

ในตัวอย่างนั้นถ้า val = 1234567 จะแสดงเป็น

  No fractions: 1,234,567

ตัวอย่างและคำแนะนำเพิ่มเติมที่: https://docs.angularjs.org/api/ng/filter/number