Nesne özelliğini değerlere göre sıralama

Eğer böyle bir JavaScript nesnesi varsa:

var list = {
  "you": 100, 
  "me": 75, 
  "foo": 116, 
  "bar": 15
};

Özellikleri değere göre sıralamanın bir yolu var mı? Böylece sonunda

list = {
  "bar": 15, 
  "me": 75, 
  "you": 100, 
  "foo": 116
};

Onları bir diziye taşıyın, diziyi sıralayın ve sonra bu diziyi amaçlarınız için kullanın. İşte bir çözüm:

var maxSpeed = {
    car: 300, 
    bike: 60, 
    motorbike: 200, 
    airplane: 1000,
    helicopter: 400, 
    rocket: 8 * 60 * 60
};
var sortable = [];
for (var vehicle in maxSpeed) {
    sortable.push([vehicle, maxSpeed[vehicle]]);
}

sortable.sort(function(a, b) {
    return a[1] - b[1];
});

//[["bike", 60], ["motorbike", 200], ["car", 300],
//["helicopter", 400], ["airplane", 1000], ["rocket", 28800]]

Diziye sahip olduğunuzda, nesneyi diziden istediğiniz sırayla yeniden oluşturabilir ve böylece tam olarak ne yapmak istediğinizi başarabilirsiniz. Bu, bildiğim tüm tarayıcılarda işe yarayacaktır, ancak bir uygulama tuhaflığına bağlı olacaktır ve herhangi bir zamanda kırılabilir. Bir JavaScript nesnesindeki öğelerin sırası hakkında asla varsayımlarda bulunmamalısınız.

var objSorted = {}
sortable.forEach(function(item){
    objSorted[item[0]]=item[1]
})

Tüm veri yapısını çoğaltmak veya ilişkilendirilebilir bir diziye ihtiyaç duyduğumuz bir dizi kullanmak istemiyoruz.

İşte bonna ile aynı şeyi yapmanın başka bir yolu:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(list).sort(function(a,b){return list[a]-list[b]})
console.log(keysSorted);     // bar,me,you,foo

Nesneleriniz herhangi bir miktarda özelliğe sahip olabilir ve nesneleri bir diziye koyarsanız istediğiniz nesne özelliğine, sayıya veya dizeye göre sıralamayı seçebilirsiniz. Şu diziyi düşünün:

var arrayOfObjects = [   
    {
        name: 'Diana',
        born: 1373925600000, // Mon, Jul 15 2013
        num: 4,
        sex: 'female'
    },
    {

        name: 'Beyonce',
        born: 1366832953000, // Wed, Apr 24 2013
        num: 2,
        sex: 'female'
    },
    {            
        name: 'Albert',
        born: 1370288700000, // Mon, Jun 3 2013
        num: 3,
        sex: 'male'
    },    
    {
        name: 'Doris',
        born: 1354412087000, // Sat, Dec 1 2012
        num: 1,
        sex: 'female'
    }
];

doğum tarihine göre sırala, en eskisi

// use slice() to copy the array and not just make a reference
var byDate = arrayOfObjects.slice(0);
byDate.sort(function(a,b) {
    return a.born - b.born;
});
console.log('by date:');
console.log(byDate);

isme göre sırala

var byName = arrayOfObjects.slice(0);
byName.sort(function(a,b) {
    var x = a.name.toLowerCase();
    var y = b.name.toLowerCase();
    return x < y ? -1 : x > y ? 1 : 0;
});

console.log('by name:');
console.log(byName);

http://jsfiddle.net/xsM5s/16/

Tamlık uğruna, bu işlev nesne özelliklerinin sıralı dizisini döndürür :

function sortObject(obj) {
    var arr = [];
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            arr.push({
                'key': prop,
                'value': obj[prop]
            });
        }
    }
    arr.sort(function(a, b) { return a.value - b.value; });
    //arr.sort(function(a, b) { a.value.toLowerCase().localeCompare(b.value.toLowerCase()); }); //use this to sort as strings
    return arr; // returns array
}

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var arr = sortObject(list);
console.log(arr); // [{key:"bar", value:15}, {key:"me", value:75}, {key:"you", value:100}, {key:"foo", value:116}]

Yukarıdaki kod ile Jsfiddle burada . Bu çözüm bu makaleye dayanmaktadır .

Dizeleri sıralamak için güncellenmiş keman burada. Büyük / küçük harfe duyarlı dize karşılaştırması için her iki ek .toLowerCase () dönüşümünü de kaldırabilirsiniz.

ECMAScript 2017 tanıtıldı Object.values / Object.entries. Adından da anlaşılacağı gibi, ilki bir nesnenin tüm değerlerini bir diziye toplar ve ikincisi tüm nesneyi bir dizi dizisine dönüştürür [key, value]; Python dict.values()ve ile eşdeğerdir dict.items().

Özellikler, herhangi bir karmayı sıralı bir nesneye sıralamayı oldukça kolaylaştırır. Şu an itibariyle, JavaScript platformlarının yalnızca küçük bir kısmı bunları destekliyor , ancak Firefox 47+ üzerinde deneyebilirsiniz.

let obj = {"you": 100, "me": 75, "foo": 116, "bar": 15};

let entries = Object.entries(obj);
// [["you",100],["me",75],["foo",116],["bar",15]]

let sorted = entries.sort((a, b) => a[1] - b[1]);
// [["bar",15],["me",75],["you",100],["foo",116]]

@MarcusR'un referans için cevabının "oklu" versiyonu

var myObj = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(myObj).sort((a,b) => myObj[a]-myObj[b])
alert(keysSorted);     // bar,me,you,foo

GÜNCELLEME: Nisan 2017 - Bu, myObjyukarıda tanımlanan sıralanmış bir nesneyi döndürür .

Object
 .keys(myObj)
 .sort((a, b) => myObj[a]-myObj[b])
 .reduce((_sortedObj, key) => ({
   ..._sortedObj, 
   [key]: myObj[key]
 }), {})

Burada deneyin!

GÜNCELLEME: Ekim 2018 - Object.entries sürümü

Object
 .entries(myObj)
 .sort()
 .reduce((_sortedObj, [k,v]) => ({
   ..._sortedObj, 
   [k]: v
 }), {})

Burada deneyin!

JavaScript nesneleri tanım gereği sıralanmamıştır (bkz. ECMAScript Dil Spesifikasyonu , bölüm 8.6). Dil belirtimi, bir nesnenin özelliklerini arka arkaya iki kez tekrarlarsanız, ikinci kez aynı sırayla çıkacaklarını garanti etmez.

Sipariş edilecek şeylere ihtiyacınız varsa, bir dizi ve Array.prototype.sort yöntemini kullanın.

Tamam , bildiğiniz gibi, javascript dizileri sıralamak için sort () işlevine sahiptir , ancak nesne için hiçbir şey yoktur ...

Bu durumda, bir şekilde anahtar dizisini almalı ve sıralamalıyız, bu yüzden apis'ler size çoğu zaman bir dizideki nesneleri verir, çünkü Array onlarla oynamak için nesne değişmezinden daha fazla yerel işlevlere sahiptir, hızlı solotion nesne anahtarları bir dizi döndüren Object.key kullanıyor , aşağıda sizin için işi yapan ES6 işlevini oluşturmak, javascript yerel sort () ve reduce () işlevlerini kullanır :

function sortObject(obj) {
  return Object.keys(obj)
    .sort().reduce((a, v) => {
    a[v] = obj[v];
    return a; }, {});
}

Ve şimdi şöyle kullanabilirsiniz:

let myObject = {a: 1, c: 3, e: 5, b: 2, d: 4};
let sortedMyObject = sortObject(myObject);

SortMyObject öğesini kontrol edin ve sonucu aşağıdaki gibi tuşlara göre sıralanmış olarak görebilirsiniz:

{a: 1, b: 2, c: 3, d: 4, e: 5}

Ayrıca bu şekilde ana nesneye dokunulmaz ve aslında yeni bir nesne elde ederiz.

Ayrıca, aşağıdaki gibi çalıştırarak işlev adımlarını daha net hale getirmek için aşağıdaki görüntüyü oluşturuyorum:

var list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

function sortAssocObject(list) {
    var sortable = [];
    for (var key in list) {
        sortable.push([key, list[key]]);
    }
    // [["you",100],["me",75],["foo",116],["bar",15]]

    sortable.sort(function(a, b) {
        return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0));
    });
    // [["bar",15],["me",75],["you",100],["foo",116]]

    var orderedList = {};
    for (var idx in sortable) {
        orderedList[sortable[idx][0]] = sortable[idx][1];
    }

    return orderedList;
}

sortAssocObject(list);

// {bar: 15, me: 75, you: 100, foo: 116}

ES6 ile güncelleme: Endişeniz yinelenecek sıralanmış bir nesneye sahipse (bu yüzden nesne özelliklerinizin sıralanmasını istediğinizi hayal ediyorum), Harita nesnesini kullanabilirsiniz .

(Anahtar, değer) çiftlerinizi sıralı olarak ekleyebilirsiniz ve daha sonra bir for..ofdöngü yapmanız , onları eklediğiniz sırayla döngüye almayı garanti eder

var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
  console.log(key + " = " + value);
}
// 0 = zero 
// 1 = one

Gelişmiş dizi veya nesne türleri için Underscore.js veya Lodash.js

 var data={
        "models": {

            "LTI": [
                "TX"
            ],
            "Carado": [
                "A",
                "T",
                "A(пасс)",
                "A(груз)",
                "T(пасс)",
                "T(груз)",
                "A",
                "T"
            ],
            "SPARK": [
                "SP110C 2",
                "sp150r 18"
            ],
            "Autobianchi": [
                "A112"
            ]
        }
    };

    var arr=[],
        obj={};
    for(var i in data.models){
      arr.push([i, _.sortBy(data.models[i],function (el){return el;})]);
    }
    arr=_.sortBy(arr,function (el){
      return el[0];
    });
    _.map(arr,function (el){return obj[el[0]]=el[1];});
     console.log(obj);

gösteri

Çok kısa ve basit!

var sortedList = {};
Object.keys(list).sort((a,b) => list[a]-list[b]).forEach((key) => {
    sortedList[key] = list[key]; });

Slebetman tarafından verilen çözümü takip ediyorum (tüm detaylar için okuyun), ancak nesneniz iç içe olmadığından ayarlandı.

// First create the array of keys/values so that we can sort it:
var sort_array = [];
for (var key in list) {
    sort_array.push({key:key,value:list[key]});
}

// Now sort it:
sort_array.sort(function(x,y){return x.value - y.value});

// Now process that object with it:
for (var i=0;i<sort_array.length;i++) {
    var item = list[sort_array[i].key];

    // now do stuff with each item
}

Birden çok döngüye sahip olmayan değerleri sırala (anahtarlara göre sıralamak için, geri arama dizinindeki dizini "0" olarak değiştirin)

const list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
  };

let sorted = Object.fromEntries(
                Object.entries(list).sort( (a,b) => a[1] - b[1] )    
             ) 
console.log('Sorted object: ', sorted) 

Bu, gerçek sıralı bir nesne olarak ele almanın basit bir yolu olabilir. Ne kadar yavaş olduğundan emin değilim. bir while döngüsü ile daha iyi olabilir.

Object.sortByKeys = function(myObj){
  var keys = Object.keys(myObj)
  keys.sort()
  var sortedObject = Object()
  for(i in keys){
    key = keys[i]
    sortedObject[key]=myObj[key]
   }

  return sortedObject

}

Ve sonra bu ters çevirme işlevini şu adresten buldum: http://nelsonwells.net/2011/10/swap-object-key-and-values-in-javascript/

Object.invert = function (obj) {

  var new_obj = {};

  for (var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      new_obj[obj[prop]] = prop;
    }
  }

  return new_obj;
};

Yani

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var invertedList = Object.invert(list)
var invertedOrderedList = Object.sortByKeys(invertedList)
var orderedList = Object.invert(invertedOrderedList)

a = { b: 1, p: 8, c: 2, g: 1 }
Object.keys(a)
  .sort((c,b) => {
    return a[b]-a[c]
  })
  .reduce((acc, cur) => {
    let o = {}
    o[cur] = a[cur]
    acc.push(o)
    return acc
   } , [])

çıktı = [{p: 8}, {c: 2}, {b: 1}, {g: 1}]

Her ihtimale karşı, birisi @Markus R ve @James Moran yorumunun kod referansını kullanarak nesneyi (anahtarlar ve değerlerle birlikte) arıyor, sadece şunu kullanın:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var newO = {};
Object.keys(list).sort(function(a,b){return list[a]-list[b]})
                 .map(key => newO[key] = list[key]);
console.log(newO);  // {bar: 15, me: 75, you: 100, foo: 116}

let toSort = {a:2323, b: 14, c: 799} 
let sorted = Object.entries(toSort ).sort((a,b)=> a[1]-b[1]) 

Çıktı:

[ [ "b", 14 ], [ "c", 799 ], [ "a", 2323 ] ]

birçok benzer ve kullanışlı fonksiyon: https://github.com/shimondoodkin/groupbyfunctions/

function sortobj(obj)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        if(a[1]>b[1]) return -1;if(a[1]<b[1]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

function sortobjkey(obj,key)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        k=key;      if(a[1][k]>b[1][k]) return -1;if(a[1][k]<b[1][k]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

Nesne değere göre sıralanmış (DESC)

function sortObject(list) {
  var sortable = [];
  for (var key in list) {
    sortable.push([key, list[key]]);
  }

  sortable.sort(function(a, b) {
    return (a[1] > b[1] ? -1 : (a[1] < b[1] ? 1 : 0));
  });

  var orderedList = {};
  for (var i = 0; i < sortable.length; i++) {
    orderedList[sortable[i][0]] = sortable[i][1];
  }

  return orderedList;
}

İşte bir örnek daha:

function sortObject(obj) {
  var arr = [];
  var prop;
  for (prop in obj) {
    if (obj.hasOwnProperty(prop)) {
      arr.push({
        'key': prop,
        'value': obj[prop]
      });
    }
  }
  arr.sort(function(a, b) {
    return a.value - b.value;
  });
  return arr; // returns array
}
var list = {
  car: 300,
  bike: 60,
  motorbike: 200,
  airplane: 1000,
  helicopter: 400,
  rocket: 8 * 60 * 60
};
var arr = sortObject(list);
console.log(arr);

    var list = {
    "you": 100,
    "me": 75,
    "foo": 116,
    "bar": 15
};
var tmpList = {};
while (Object.keys(list).length) {
    var key = Object.keys(list).reduce((a, b) => list[a] > list[b] ? a : b);
    tmpList[key] = list[key];
    delete list[key];
}
list = tmpList;
console.log(list); // { foo: 116, you: 100, me: 75, bar: 15 }

daktilo ile yazılmış yazı

Aşağıdaki işlev nesneyi değere veya değerin bir özelliğine göre sıralar. TypeScript kullanmıyorsanız, tür bilgisini JavaScript'e dönüştürmek için kaldırabilirsiniz.

/**
 * Represents an associative array of a same type.
 */
interface Dictionary<T> {
  [key: string]: T;
}

/**
 * Sorts an object (dictionary) by value or property of value and returns
 * the sorted result as a Map object to preserve the sort order.
 */
function sort<TValue>(
  obj: Dictionary<TValue>,
  valSelector: (val: TValue) => number | string,
) {
  const sortedEntries = Object.entries(obj)
    .sort((a, b) =>
      valSelector(a[1]) > valSelector(b[1]) ? 1 :
      valSelector(a[1]) < valSelector(b[1]) ? -1 : 0);
  return new Map(sortedEntries);
}

kullanım

var list = {
  "one": { height: 100, weight: 15 },
  "two": { height: 75, weight: 12 },
  "three": { height: 116, weight: 9 },
  "four": { height: 15, weight: 10 },
};

var sortedMap = sort(list, val => val.height);

Bir JavaScript nesnesindeki anahtarların sırası garanti edilmez, bu yüzden sonucu sıralıyorum ve Map sıralama düzenini koruyan nesne .

Bunu tekrar Object'e dönüştürmek istiyorsanız, bunu yapabilirsiniz:

var sortedObj = {} as any;
sortedMap.forEach((v,k) => { sortedObj[k] = v });

girdi nesne, çıktı nesne, lodash & js yerleşik lib kullanarak, azalan veya artan seçenek ile ve giriş nesnesini değiştirmez

örneğin giriş ve çıkış

{
  "a": 1,
  "b": 4,
  "c": 0,
  "d": 2
}
{
  "b": 4,
  "d": 2,
  "a": 1,
  "c": 0
}

Hayata geçirme

const _ = require('lodash');

const o = { a: 1, b: 4, c: 0, d: 2 };


function sortByValue(object, descending = true) {
  const { max, min } = Math;
  const selector = descending ? max : min;

  const objects = [];
  const cloned = _.clone(object);

  while (!_.isEmpty(cloned)) {
    const selectedValue = selector(...Object.values(cloned));
    const [key, value] = Object.entries(cloned).find(([, value]) => value === selectedValue);

    objects.push({ [key]: value });
    delete cloned[key];
  }

  return _.merge(...objects);
}

const o2 = sortByValue(o);
console.log(JSON.stringify(o2, null, 2));

const arrayOfObjects = [
{name: 'test'},
{name: 'test2'}
]

const order = ['test2', 'test']

const setOrder = (arrayOfObjects, order) =>
    arrayOfObjects.sort((a, b) => {
        if (order.findIndex((i) => i === a.name) < order.findIndex((i) => i === b.name)) {
            return -1;
        }

        if (order.findIndex((i) => i === a.name) > order.findIndex((i) => i === b.name)) {
            return 1;
        }

        return 0;
    });

sıralama ile benim çözüm:

let list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

let sorted = Object.entries(list).sort((a,b) => a[1] - b[1]);

for(let element of sorted) {
    console.log(element[0]+ ": " + element[1]);
}

<pre>
function sortObjectByVal(obj){  
var keysSorted = Object.keys(obj).sort(function(a,b){return obj[b]-obj[a]});
var newObj = {};
for(var x of keysSorted){
    newObj[x] = obj[x];
}
return newObj;

}
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
console.log(sortObjectByVal(list));
</pre>

Bunu çözmenin başka bir yolu: -

var res = [{"s1":5},{"s2":3},{"s3":8}].sort(function(obj1,obj2){ 
 var prop1;
 var prop2;
 for(prop in obj1) {
  prop1=prop;
 }
 for(prop in obj2) {
  prop2=prop;
 }
 //the above two for loops will iterate only once because we use it to find the key
 return obj1[prop1]-obj2[prop2];
});

// res sonuç dizisine sahip olacak

Teşekkürler ve devam etmek cevap @Nosredna

Şimdi nesnenin diziye dönüştürülmesi gerektiğini anladığımıza göre diziyi sıralayın. diziyi (veya dönüştürülen nesneyi diziye) dizeye göre sıralamak için kullanışlıdır:

Object {6: Object, 7: Object, 8: Object, 9: Object, 10: Object, 11: Object, 12: Object}
   6: Object
   id: "6"
   name: "PhD"
   obe_service_type_id: "2"
   __proto__: Object
   7: Object
   id: "7"
   name: "BVC (BPTC)"
   obe_service_type_id: "2"
   __proto__: Object


    //Sort options
    var sortable = [];
    for (var vehicle in options)
    sortable.push([vehicle, options[vehicle]]);
    sortable.sort(function(a, b) {
        return a[1].name < b[1].name ? -1 : 1;
    });


    //sortable => prints  
[Array[2], Array[2], Array[2], Array[2], Array[2], Array[2], Array[2]]
    0: Array[2]
    0: "11"
    1: Object
        id: "11"
        name: "AS/A2"
        obe_service_type_id: "2"
        __proto__: Object
        length: 2
        __proto__: Array[0]
    1: Array[2]
    0: "7"
    1: Object
        id: "7"
        name: "BVC (BPTC)"
        obe_service_type_id: "2"
        __proto__: Object
        length: 2

Bunu dene. Nesneniz bile sıralamaya çalıştığınız özelliğe sahip olmadığında da işlenir.

Nesneyle özellik göndererek arayın.

var sortObjectByProperty = function(property,object){

    console.time("Sorting");
    var  sortedList      = [];
         emptyProperty   = [];
         tempObject      = [];
         nullProperty    = [];
    $.each(object,function(index,entry){
        if(entry.hasOwnProperty(property)){
            var propertyValue = entry[property];
            if(propertyValue!="" && propertyValue!=null){
              sortedList.push({key:propertyValue.toLowerCase().trim(),value:entry});  
            }else{
                emptyProperty.push(entry);
           }
        }else{
            nullProperty.push(entry);
        }
    });

      sortedList.sort(function(a,b){
           return a.key < b.key ? -1 : 1;
         //return a.key < b.key?-1:1;   // Asc 
         //return a.key < b.key?1:-1;  // Desc
      });


    $.each(sortedList,function(key,entry){
        tempObject[tempObject.length] = entry.value;
     });

    if(emptyProperty.length>0){
        tempObject.concat(emptyProperty);
    }
    if(nullProperty.length>0){
        tempObject.concat(nullProperty);
    }
    console.timeEnd("Sorting");
    return tempObject;
}