වර්ග කිරීම (වැඩි) වස්තූන්ගේ සංකීර්ණ අරා
මෙම අරාව වැනි වඩාත් සංකීර්ණ දත්ත ව්‍යුහයන් ඔබට හමු විය හැකි බැවින්, මම විසඳුම පුළුල් කරමි.
ටීඑල්; ඩී.ආර්
@ Ege-Özcan ගේ ඉතා සුන්දර පිළිතුර මත පදනම්ව වඩාත් ප්ලග් කළ හැකි අනුවාදයන් වේ.
ගැටලුව
මට පහත දැක්වෙන දේ හමු වූ අතර එය වෙනස් කළ නොහැක. වස්තුව තාවකාලිකව සමතලා කිරීමට ද මට අවශ්ය නොවීය. ප්‍රධාන වශයෙන් කාර්ය සාධන හේතූන් මත සහ එය මා විසින්ම ක්‍රියාත්මක කිරීමට ඇති විනෝදය සඳහා අවධාරනය / ලොඩාෂ් භාවිතා කිරීමට මට අවශ්ය නොවීය.
var People = [
{Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
{Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
{Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];
ඉලක්කය
ඉලක්කය වන්නේ එය මූලික වශයෙන් People.Name.nameහා දෙවනුව අනුව වර්ග කිරීමයිPeople.Name.surname
බාධක
දැන්, මූලික විසඳුම තුළ ගතිකව වර්ග කිරීම සඳහා ගුණාංග ගණනය කිරීම සඳහා වරහන් අංකනය භාවිතා කරයි. මෙන්න, නමුත් අපට වරහන් අංකනය ගතිකව ගොඩනගා ගැනීමට සිදුවනු ඇත, මන්ද ඔබ බලාපොරොත්තු වන පරිදි යම් People['Name.name']වැඩක් සිදුවනු ඇතැයි ඔබ අපේක්ෂා කරනු ඇත - එය එසේ නොවේ.
සරලව කිරීම People['Name']['name'], අනෙක් අතට, ස්ථිතික වන අතර ඔබට n -th මට්ටමට යාමට පමණක් ඉඩ සලසයි .
විසඳුමක්
මෙහි ඇති ප්‍රධාන එකතු කිරීම වනුයේ වස්තු ගසෙන් බැස අවසාන පත්‍රයේ වටිනාකම තීරණය කිරීමයි, ඔබ සඳහන් කළ යුතු අතර ඕනෑම අතරමැදි පත්‍රයක්.
var People = [
{Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
{Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
{Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];
People.sort(dynamicMultiSort(['Name','name'], ['Name', '-surname']));
// Results in...
// [ { Name: { name: 'AAA', surname: 'ZZZ' }, Middlename: 'Abrams' },
// { Name: { name: 'Name', surname: 'Surname' }, Middlename: 'JJ' },
// { Name: { name: 'Name', surname: 'AAA' }, Middlename: 'Wars' } ]
// same logic as above, but strong deviation for dynamic properties
function dynamicSort(properties) {
var sortOrder = 1;
// determine sort order by checking sign of last element of array
if(properties[properties.length - 1][0] === "-") {
sortOrder = -1;
// Chop off sign
properties[properties.length - 1] = properties[properties.length - 1].substr(1);
}
return function (a,b) {
propertyOfA = recurseObjProp(a, properties)
propertyOfB = recurseObjProp(b, properties)
var result = (propertyOfA < propertyOfB) ? -1 : (propertyOfA > propertyOfB) ? 1 : 0;
return result * sortOrder;
};
}
/**
* Takes an object and recurses down the tree to a target leaf and returns it value
* @param {Object} root - Object to be traversed.
* @param {Array} leafs - Array of downwards traversal. To access the value: {parent:{ child: 'value'}} -> ['parent','child']
* @param {Number} index - Must not be set, since it is implicit.
* @return {String|Number} The property, which is to be compared by sort.
*/
function recurseObjProp(root, leafs, index) {
index ? index : index = 0
var upper = root
// walk down one level
lower = upper[leafs[index]]
// Check if last leaf has been hit by having gone one step too far.
// If so, return result from last step.
if (!lower) {
return upper
}
// Else: recurse!
index++
// HINT: Bug was here, for not explicitly returning function
// https://stackoverflow.com/a/17528613/3580261
return recurseObjProp(lower, leafs, index)
}
/**
* Multi-sort your array by a set of properties
* @param {...Array} Arrays to access values in the form of: {parent:{ child: 'value'}} -> ['parent','child']
* @return {Number} Number - number for sort algorithm
*/
function dynamicMultiSort() {
var args = Array.prototype.slice.call(arguments); // slight deviation to base
return function (a, b) {
var i = 0, result = 0, numberOfProperties = args.length;
// REVIEW: slightly verbose; maybe no way around because of `.sort`-'s nature
// Consider: `.forEach()`
while(result === 0 && i < numberOfProperties) {
result = dynamicSort(args[i])(a, b);
i++;
}
return result;
}
}
උදාහරණයක්
JSBin හි වැඩ කරන උදාහරණය