javascript - স্ট্রিং সম্পত্তি মান দ্বারা বস্তুর সাজান অ্যারে




arrays sorting (20)

বাছাই (আরো) বস্তুর কমপ্লেক্স অ্যারে

যেহেতু আপনি সম্ভবত এই অ্যারের মত আরো জটিল তথ্য গঠন সম্মুখীন, আমি সমাধান প্রসারিত করব।

টি এল; ডিআর

@ege-Özcan খুব সুন্দর answer উপর ভিত্তি করে আরো প্লাগযোগ্য সংস্করণ রয়েছে।

সমস্যা

আমি নীচের সম্মুখীন এবং এটি পরিবর্তন করতে পারে না। আমি অস্থায়ীভাবে বস্তু flatten করতে চান না। না আমি প্রধানত কর্মক্ষমতা কারণে এবং এটি নিজেকে বাস্তবায়ন মজা মজা underscore / lodash ব্যবহার করতে চান।

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.surname

অবমুক্ত

এখন, বেস সমাধান গতিশীলভাবে সাজানোর বৈশিষ্ট্যগুলি গণনা করার জন্য বন্ধনী সংকেত ব্যবহার করে। এখানে, যদিও, আমরা বন্ধনী সংকেত গতিশীলভাবে নির্মাণ করতে হবে, যেহেতু আপনি আশা করবেন যে কিছু People['Name.name'] কাজ করবে - যা করে না।

শুধু People['Name']['name'] , অন্যদিকে, স্থিতিশীল এবং শুধুমাত্র আপনি n- স্তরের স্তর নিচে যেতে পারবেন।

সমাধান

এখানে মূল সংযোজন বস্তুটির গাছটি হ্রাস করতে হবে এবং শেষ পাতাটির মান নির্ধারণ করতে হবে, যা আপনাকে নির্দিষ্ট করতে হবে, পাশাপাশি কোন মধ্যবর্তী পাতা।

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 কাজ উদাহরণ

আমি জাভাস্ক্রিপ্ট বস্তুর একটি অ্যারে আছে:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

কিভাবে আমি জাভাস্ক্রিপ্টে last_nom মান দ্বারা তাদের বাছাই করতে পারেন?

আমি sort(a,b) সম্পর্কে জানি sort(a,b) , কিন্তু যে শুধুমাত্র স্ট্রিং এবং সংখ্যা কাজ বলে মনে হয়। আমার বস্তুগুলিতে একটি toString() পদ্ধতি যোগ করতে হবে?


ES6 / ES2015 বা পরে আপনি এই ভাবে করতে পারেন:

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

আপনার যদি শেষ নামগুলি অনুলিপি করা হয় তবে আপনি সেগুলি প্রথম নাম অনুসারে সাজিয়ে নিতে পারেন-

obj.sort(function(a,b){
  if(a.last_nom< b.last_nom) return -1;
  if(a.last_nom >b.last_nom) return 1;
  if(a.first_nom< b.first_nom) return -1;
  if(a.first_nom >b.first_nom) return 1;
  return 0;
});

আপনি একটি গতিশীল সাজানোর ফাংশনও তৈরি করতে পারেন যা আপনার মান দ্বারা পাস করে এমন বস্তুগুলি সাজায়:

function dynamicSort(property) {
    var sortOrder = 1;
    if(property[0] === "-") {
        sortOrder = -1;
        property = property.substr(1);
    }
    return function (a,b) {
        var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
        return result * sortOrder;
    }
}

সুতরাং আপনি এই মত বস্তুর একটি অ্যারে থাকতে পারে:

var People = [
    {Name: "Name", Surname: "Surname"},
    {Name:"AAA", Surname:"ZZZ"},
    {Name: "Name", Surname: "AAA"}
];

... এবং যখন আপনি করবেন তখন এটি কাজ করবে:

People.sort(dynamicSort("Name"));
People.sort(dynamicSort("Surname"));
People.sort(dynamicSort("-Surname"));

আসলে এই ইতিমধ্যে প্রশ্ন উত্তর। অংশটি নীচে লেখা হয়েছে কারণ অনেক লোক আমার সাথে যোগাযোগ করেছে, অভিযোগ করেছে যে এটি একাধিক পরামিতিগুলির সাথে কাজ করে না

একাধিক পরামিতি

আপনি একাধিক বাছাই পরামিতি সঙ্গে সাজানোর ফাংশন জেনারেট করতে নিচের ফাংশন ব্যবহার করতে পারেন।

function dynamicSortMultiple() {
    /*
     * save the arguments object as it will be overwritten
     * note that arguments object is an array-like object
     * consisting of the names of the properties to sort by
     */
    var props = arguments;
    return function (obj1, obj2) {
        var i = 0, result = 0, numberOfProperties = props.length;
        /* try getting a different result from 0 (equal)
         * as long as we have extra properties to compare
         */
        while(result === 0 && i < numberOfProperties) {
            result = dynamicSort(props[i])(obj1, obj2);
            i++;
        }
        return result;
    }
}

যা আপনাকে এমন কিছু করতে সক্ষম করবে:

People.sort(dynamicSortMultiple("Name", "-Surname"));

এটি প্রোটোটাইপ যোগ করা

(নীচের বাস্তবায়ন মাইক আর এর answer থেকে অনুপ্রাণিত)

আমি একটি নেটিভ অবজেক্ট প্রোটোটাইপ পরিবর্তন করার পরামর্শ দিই না তবে কেবল একটি উদাহরণ দিতে যাতে আপনি এটি আপনার নিজের বস্তুগুলিতে বাস্তবায়ন করতে পারেন (এটির যে পরিবেশগুলি এটি সমর্থন করে, তার জন্য আপনি পরবর্তী বিভাগে দেখানো Object.defineProperty ব্যবহার করতে পারেন, যা কমপক্ষে শেষ অংশে বর্ণিত হিসাবে সংখ্যাগরিষ্ঠ হওয়ার নেতিবাচক পার্শ্ব প্রতিক্রিয়া নেই)

প্রোটোটাইপ বাস্তবায়ন নিম্নলিখিত মত কিছু হবে ( এখানে একটি কাজ উদাহরণ ):

//Don't just copy-paste this code. You will break the "for-in" loops
!function() {
    function _dynamicSortMultiple(attr) {
       /* dynamicSortMultiple function body comes here */
    }
    function _dynamicSort(property) {
        /* dynamicSort function body comes here */
    }
    Array.prototype.sortBy = function() {
        return this.sort(_dynamicSortMultiple.apply(null, arguments));
    }
}();

প্রোটোটাইপ এ যোগ করার "ঠিক আছে" উপায়

যদি আপনি IE v9.0 এবং তারপরে লক্ষ্য রাখেন তবে, যেমন আমি আগে উল্লেখ করেছি, Object.defineProperty ব্যবহার করুন ( কাজের উদাহরণ ):

//Won't work below IE9, but totally safe otherwise
!function() {
    function _dynamicSortMultiple(attr) {
       /* dynamicSortMultiple function body comes here */
    }
    function _dynamicSort(property) {
        /* dynamicSort function body comes here */
    }
    Object.defineProperty(Array.prototype, "sortBy", {
        enumerable: false,
        writable: true,
        value: function() {
            return this.sort(_dynamicSortMultiple.apply(null, arguments));
        }
    });
}();

বাঁধ অপারেটর আসে না হওয়া পর্যন্ত এটি একটি গ্রহণযোগ্য আপোস হতে পারে।

সমস্ত প্রোটোটাইপ মজা এই সক্ষম করে:

People.sortBy("Name", "-Surname");

আপনি এই পড়া উচিত

আপনি যদি সরাসরি প্রোটোটাইপ অ্যাক্সেস পদ্ধতি ব্যবহার করেন (Object.defineProperty জরিমানা) এবং অন্য কোডটি চেক না করেও অননুমোদিত, বিড়ালদের মৃত্যু! ঠিক আছে, সৎ হতে, কোনও কুকুরের কোনও ক্ষতিই আসে না তবে সম্ভবত জিনিসগুলি ভেঙ্গে যাবে এবং আপনার দলের অন্য ডেভেলপার আপনাকে ঘৃণা করবে:

শেষ যে "SortBy" দেখুন? হ্যাঁ। ভালো না. আপনি যা করতে পারেন তা Object.defineProperty ব্যবহার করুন, এবং অন্যথায় একা Array.prototype ছেড়ে দিন।


আমি এই বিশেষ পদ্ধতির প্রস্তাবটি দেখিনি, তাই এখানে একটি টিয়ার্স তুলনা পদ্ধতি যা আমি ব্যবহার করতে চাই string এবং number উভয় জন্য কাজ করে:

const objs = [ 
  { first_nom: 'Lazslo', last_nom: 'Jamf'     },
  { first_nom: 'Pig',    last_nom: 'Bodine'   },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

const sortBy = fn => (a, b) => -(fn(a) < fn(b)) || +(fn(a) > fn(b))
const getLastName = o => o.last_nom
const sortByLastName = sortBy(getLastName)

objs.sort(sortByLastName)
console.log(objs.map(getLastName))

এখানে একটি ব্যাখ্যা আছে sortBy():

sortBy()একটি গ্রহণ fnযে একটি বস্তু থেকে আমরা কী মান নির্বাচন করে তুলনা হিসাবে ব্যবহার করার জন্য, এবং একটি ফাংশন যা সরাসরি প্রেরণ করা সম্ভব ফেরৎ Array.prototype.sort()। এই উদাহরণে, আমরা o.last_nomতুলনা করার জন্য মান হিসাবে ব্যবহার করছি , তাই যখনই আমরা Array.prototype.sort()যেমন দুটি বস্তু পাবেন

{ first_nom: 'Lazslo', last_nom: 'Jamf' }

এবং

{ first_nom: 'Pig', last_nom: 'Bodine' }

আমরা ব্যাবহার করি

(a, b) => -(fn(a) < fn(b)) || +(fn(a) > fn(b))

তাদের তুলনা করা।

যে মনে রাখা fn = o => o.last_nom, আমরা তুলনা ফাংশন সমতুল্য প্রসারিত করতে পারেন

(a, b) => -(a.last_nom < b.last_nom) || +(a.last_nom > b.last_nom)

লজিক্যাল OR ||অপারেটরটির একটি ছোট-সার্কুটিং কার্যকারিতা রয়েছে যা এখানে খুবই উপকারী। এটি কিভাবে কাজ করে, উপরে ফাংশন শরীরের মানে

if (a.last_nom < b.last_nom) return -1
return +(a.last_nom > b.last_nom)

সুতরাং যদি a < bআমরা ফিরে যাই -1, অন্যথায় যদি a > bআমরা ফিরে যাই +1, কিন্তু যদি a == b, তারপর a < bএবং a > bমিথ্যা, তাই এটি ফেরত +0

যোগ করা বোনাস হিসাবে, এখানে ECMAScript 5.1 এর সমতুল্য তীর ফাংশন ছাড়া সমতুল্য, যা দুর্ভাগ্যবশত তীক্ষ্ণ নয়:

var objs = [ 
  { first_nom: 'Lazslo', last_nom: 'Jamf'     },
  { first_nom: 'Pig',    last_nom: 'Bodine'   },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

var sortBy = function (fn) {
  return function (a, b) {
    return -(fn(a) < fn(b)) || +(fn(a) > fn(b))
  }
}

var getLastName = function (o) { return o.last_nom }
var sortByLastName = sortBy(getLastName)

objs.sort(sortByLastName)
console.log(objs.map(getLastName))


আমি জানি এই প্রশ্নটি পুরানো, কিন্তু আমি আমার অনুরূপ কোন বাস্তবায়ন দেখতে পাইনি।
এই সংস্করণ Schwartzian রূপান্তর 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'));

উইয়ের ধারণা নিয়ে এজের গতিশীল সমাধানকে একত্রিত করে, আপনি একটি চমৎকার দৃঢ় সমাধান পান:

Array.prototype.sortBy = function() {
    function _sortByAttr(attr) {
        var sortOrder = 1;
        if (attr[0] == "-") {
            sortOrder = -1;
            attr = attr.substr(1);
        }
        return function(a, b) {
            var result = (a[attr] < b[attr]) ? -1 : (a[attr] > b[attr]) ? 1 : 0;
            return result * sortOrder;
        }
    }
    function _getSortFunc() {
        if (arguments.length == 0) {
            throw "Zero length arguments not allowed for Array.sortBy()";
        }
        var args = arguments;
        return function(a, b) {
            for (var result = 0, i = 0; result == 0 && i < args.length; i++) {
                result = _sortByAttr(args[i])(a, b);
            }
            return result;
        }
    }
    return this.sort(_getSortFunc.apply(null, arguments));
}

ব্যবহার:

// Utility for printing objects
Array.prototype.print = function(title) {
    console.log("************************************************************************");
    console.log("**** "+title);
    console.log("************************************************************************");
    for (var i = 0; i < this.length; i++) {
        console.log("Name: "+this[i].FirstName, this[i].LastName, "Age: "+this[i].Age);
    }
}

// Setup sample data
var arrObj = [
    {FirstName: "Zach", LastName: "Emergency", Age: 35},
    {FirstName: "Nancy", LastName: "Nurse", Age: 27},
    {FirstName: "Ethel", LastName: "Emergency", Age: 42},
    {FirstName: "Nina", LastName: "Nurse", Age: 48},
    {FirstName: "Anthony", LastName: "Emergency", Age: 44},
    {FirstName: "Nina", LastName: "Nurse", Age: 32},
    {FirstName: "Ed", LastName: "Emergency", Age: 28},
    {FirstName: "Peter", LastName: "Physician", Age: 58},
    {FirstName: "Al", LastName: "Emergency", Age: 51},
    {FirstName: "Ruth", LastName: "Registration", Age: 62},
    {FirstName: "Ed", LastName: "Emergency", Age: 38},
    {FirstName: "Tammy", LastName: "Triage", Age: 29},
    {FirstName: "Alan", LastName: "Emergency", Age: 60},
    {FirstName: "Nina", LastName: "Nurse", Age: 54}
];

//Unit Tests
arrObj.sortBy("LastName").print("LastName Ascending");
arrObj.sortBy("-LastName").print("LastName Descending");
arrObj.sortBy("LastName", "FirstName", "-Age").print("LastName Ascending, FirstName Ascending, Age Descending");
arrObj.sortBy("-FirstName", "Age").print("FirstName Descending, Age Ascending");
arrObj.sortBy("-Age").print("Age Descending");

উদাহরণ ব্যবহার:

objs.sort(sortBy('last_nom'));

লিপি:

/**
 * @description 
 * Returns a function which will sort an
 * array of objects by the given key.
 * 
 * @param  {String}  key
 * @param  {Boolean} reverse
 * @return {Function}     
 */
function sortBy(key, reverse) {

  // Move smaller items towards the front
  // or back of the array depending on if
  // we want to sort the array in reverse
  // order or not.
  var moveSmaller = reverse ? 1 : -1;

  // Move larger items towards the front
  // or back of the array depending on if
  // we want to sort the array in reverse
  // order or not.
  var moveLarger = reverse ? -1 : 1;

  /**
   * @param  {*} a
   * @param  {*} b
   * @return {Number}
   */
  return function(a, b) {
    if (a[key] < b[key]) {
      return moveSmaller;
    }
    if (a[key] > b[key]) {
      return moveLarger;
    }
    return 0;
  };

}

একটি সহজ উপায়:

objs.sort(function(a,b) {
  return b.last_nom.toLowerCase() < a.last_nom.toLowerCase();
});

স্ট্রিংগুলির তুলনায় '.toLowerCase()' প্রতিরোধ করতে '.toLowerCase()' প্রয়োজনীয় তা দেখুন।


এখানে অনেক ভাল উত্তর আছে, তবে আমি আরো কিছু জটিল ক্রমবর্ধমান অর্জন করতে খুব সহজেই বর্ধিত করতে চাই। আপনাকে যা করতে হবে তা হল OR অপারেটরটি চেইন তুলনা ফাংশনে ব্যবহার করার মতো:

objs.sort((a,b)=> fn1(a,b) || fn2(a,b) || fn3(a,b) )

যেখানে fn1 , fn2 , ... হল এমন ধরণের ফাংশন যা ফিরিয়ে দেয় [-1,0,1]। এটি "fn1 দ্বারা সাজানো", "fn2 দ্বারা সাজানো" ফলাফল যা এসকিউএল দ্বারা অর্ডারের বেশিরভাগ সমান।

এই সমাধান আচরণের উপর ভিত্তি করে || অপারেটর যা প্রথম মূল্যায়ন অভিব্যক্তির মূল্যায়ন করে যা সত্য রূপান্তর করা যেতে পারে

সবচেয়ে সহজ ফর্মটি এইরকম একটি ইনলাইনযুক্ত ফাংশন আছে:

// ORDER BY last_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) )

last_nom সাথে দুটি ধাপ রয়েছে, first_nom সাজানোর first_nom last_nom দেখতে হবে:

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) || 
                  a.first_nom.localeCompare(b.first_nom)  )

একটি জেনেরিক তুলনা ফাংশন এই মত কিছু হতে পারে:

// ORDER BY <n>
let cmp = (a,b,n)=>a[n].localeCompare(b[n])

এই ফাংশন সংখ্যাসূচক ক্ষেত্র, কেস সংবেদনশীলতা, arbitary datatypes ইত্যাদি সমর্থন করার জন্য বর্ধিত করা যেতে পারে।

আপনি তাদের অগ্রাধিকার অগ্রাধিকার দ্বারা চেনা সঙ্গে এটি ব্যবহার করতে পারেন:

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> cmp(a,b, "last_nom") || cmp(a,b, "first_nom") )
// ORDER_BY last_nom, first_nom DESC
objs.sort((a,b)=> cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )
// ORDER_BY last_nom DESC, first_nom DESC
objs.sort((a,b)=> -cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )

এখানে বিন্দু যে কার্যকরী পদ্ধতির সাথে বিশুদ্ধ জাভাস্ক্রিপ্ট বহিরাগত লাইব্রেরি বা জটিল কোড ছাড়া আপনি একটি দীর্ঘ পথ নিতে পারে। এটি খুব কার্যকর, কোন স্ট্রিং পার্সিং করা হবে না


মানুষ কেন এত জটিল করে তুলবে না:

objs.sort(function(a, b){
  return a.last_nom > b.last_nom;
});

কঠোর ইঞ্জিনের জন্য:

objs.sort(function(a, b){
  return a.last_nom == b.last_nom ? 0 : +(a.last_nom > b.last_nom) || -1;
});

বিপরীত বর্ণানুক্রমিক ক্রম দ্বারা সাজানো অপারেটর swap।


২018 সালের মধ্যে অনেক ছোট এবং মার্জিত সমাধান রয়েছে। শুধু ব্যবহার করুন। developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

উদাহরণ:

var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic', value: 13 },
  { name: 'Zeros', value: 37 }
];

// sort by value
items.sort(function (a, b) {
  return a.value - b.value;
});

লোড্যাশ.জেএস ( আন্ডারস্কোর.জেএস এর সুপারসেট)

প্রতিটি সহজ লজিকের জন্য ফ্রেমওয়ার্ক যুক্ত করা ভাল নয়, তবে একটি ভাল পরীক্ষিত ইউটিলিটি কাঠামোর উপর নির্ভর করে, বিকাশের গতি বাড়ান এবং লিখিত পরিমাণগুলি হ্রাস করা কোন লজ্জা নয়।

লোডশ খুব পরিষ্কার কোড তৈরি করে এবং আরো কার্যকরী প্রোগ্রামিং শৈলী প্রচার করে, যার ফলে কম বাগ হয়। এক নজরে এটি কোড হয়ে থাকলে উদ্দেশ্য কি স্পষ্ট হয়ে যায়।

OP এর সমস্যাটি সহজেই সমাধান করা যেতে পারে:

const sortedObjs = _.sortBy(objs, 'last_nom');

অধিক তথ্য? যেমন আমরা নীচের বস্তু নিম্নলিখিত আছে:

const users = [
  { 'user': {'name':'fred', 'age': 48}},
  { 'user': {'name':'barney', 'age': 36 }},
  { 'user': {'name':'wilma'}},
  { 'user': {'name':'betty', 'age': 32}}
];

আমরা এখন _.property শর্ট্যান্ড user.age ব্যবহার করতে পারেন সম্পত্তি যে পথ মেলে করা উচিত নির্দিষ্ট করতে। আমরা নেস্টেড বয়স সম্পত্তি দ্বারা ব্যবহারকারী অবজেক্ট সাজানোর হবে। হ্যাঁ, এটি নেস্টেড সম্পত্তি মেলা জন্য অনুমতি দেয়!

const sortedObjs = _.sortBy(users, ['user.age']);

এটা বিপরীত চান? সমস্যা নেই. _.reverse ব্যবহার করুন।

const sortedObjs = _.reverse(_.sortBy(users, ['user.age']));

পরিবর্তে Chaining ব্যবহার করে উভয় একত্রিত করতে চান?

const sortedObjs = _.chain(users).sortBy('user.age').reverse().value();

একটি সম্পত্তি দ্বারা বস্তুর অ্যারের সাজানোর একটি সহজ ফাংশন

function sortArray(array, property, direction) {
    direction = direction || 1;
    array.sort(function compare(a, b) {
        let comparison = 0;
        if (a[property] > b[property]) {
            comparison = 1 * direction;
        } else if (a[property] < b[property]) {
            comparison = -1 * direction;
        }
        return comparison;
    });
    return array; // Chainable
}

ব্যবহার:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

sortArray(objs, "last_nom"); // Asc
sortArray(objs, "last_nom", -1); // Desc

বিভ্রান্তি প্রতিরোধ করার জন্য আপনাকে নিম্ন ক্ষেত্রে এটি রূপান্তর করতে হবে।

objs.sort(function (a,b) {

var nameA=a.last_nom.toLowerCase(), nameB=b.last_nom.toLowerCase()

if (nameA < nameB)
  return -1;
if (nameA > nameB)
  return 1;
return 0;  //no sorting

})

মূল উদাহরণ দেওয়া হয়েছে:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

একাধিক ক্ষেত্র দ্বারা সাজান:

objs.sort(function(left, right) {
    var last_nom_order = left.last_nom.localeCompare(right.last_nom);
    var first_nom_order = left.first_nom.localeCompare(right.first_nom);
    return last_nom_order || first_nom_order;
});

নোট

  • a.localeCompare(b)হয় সর্বজনীন সমর্থিত এবং আয় -1,0,1 যদি a<b, a==b, a>bযথাক্রমে।
  • ||শেষ লাইন last_nomঅগ্রাধিকার দেয় first_nom
  • সংখ্যাসূচক ক্ষেত্রের উপর বিয়োগ কাজ করে: var age_order = left.age - right.age;
  • আদেশ বিপরীত নেগেটিভ, return -last_nom_order || -first_nom_order || -age_order;

Ege Özcan কোড জন্য অতিরিক্ত উত্তম প্যারামিটার

function dynamicSort(property, desc) {
    if (desc) {
        return function (a, b) {
            return (a[property] > b[property]) ? -1 : (a[property] < b[property]) ? 1 : 0;
        }   
    }
    return function (a, b) {
        return (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
    }
}

আপনার উদাহরণটি ধরে রাখার জন্য, আপনাকে দুইটি ক্ষেত্র (শেষ নাম, প্রথম নাম), বরং একের দ্বারা সাজানোর প্রয়োজন। আপনি Alasql লাইব্রেরীটি এক লাইনে এই ধরণের সাজানোর জন্য ব্যবহার করতে পারেন :

var res = alasql('SELECT * FROM ? ORDER BY last_nom, first_nom',[objs]);

JsFiddle এ এই উদাহরণ চেষ্টা করুন ।


এটি একটি সাধারণ সমস্যা, কেন মানুষ এই ধরনের জটিল সমাধান জানেন না।
একটি সহজ সাজানোর ফাংশন ( দ্রুত সাজানোর আলগোরিদিম উপর ভিত্তি করে ):

function sortObjectsArray(objectsArray, sortKey)
        {
            // Quick Sort:
            var retVal;

            if (1 < objectsArray.length)
            {
                var pivotIndex = Math.floor((objectsArray.length - 1) / 2);  // middle index
                var pivotItem = objectsArray[pivotIndex];                    // value in the middle index
                var less = [], more = [];

                objectsArray.splice(pivotIndex, 1);                          // remove the item in the pivot position
                objectsArray.forEach(function(value, index, array)
                {
                    value[sortKey] <= pivotItem[sortKey] ?                   // compare the 'sortKey' proiperty
                        less.push(value) :
                        more.push(value) ;
                });

                retVal = sortObjectsArray(less, sortKey).concat([pivotItem], sortObjectsArray(more, sortKey));
            }
            else
            {
                retVal = objectsArray;
            }

            return retVal;
        }

উদাহরণ ব্যবহার করুন:

var myArr = 
        [
            { val: 'x', idx: 3 },
            { val: 'y', idx: 2 },
            { val: 'z', idx: 5 },
        ];
myArr = sortObjectsArray(myArr, 'idx');

function compare(propName) {
    return function(a,b) {
        if (a[propName] < b[propName])
            return -1;
        if (a[propName] > b[propName])
            return 1;
        return 0;
    };
}

objs.sort(compare("last_nom"));







sorting