Trie un tableau d'avoir des éléments spécifiques d'abord dans le tableau

Question

j'ai un tableau en tant que tel:

[{flag: true, other: 1}, 
{flag: true, other: 2}, 
{flag: false, other: 3}, 
{flag: true, other: 4}, 
{flag: true, other: 5}, 
{flag: true, other: 6}, 
{flag: false, other: 7}] 

Je veux avoir ceci:

[{flag: false, other: 3}, 
{flag: false, other: 7}, 
{flag: true, other: 1}, 
{flag: true, other: 2}, 
{flag: true, other: 4}, 
{flag: true, other: 5}, 
{flag: true, other: 6}] 

Fondamentalement, je veux que si array[2].flag === false (ou toute autre valeur que je choisis) l'élément correspondant est placé en premier dans le tableau, mais après les éléments correspondants précédents. Les éléments qui ne correspondent pas restent dans le même ordre qu'ils étaient à l'origine.

L'ordre d'apparition est important.

Comment faire de mieux en JavaScript?

Answer 1

Cela ne fait le tri. Vous pouvez juste boucle à travers le réseau deux fois et construire un nouveau tableau:

var result = []; 
for (var i = 0; i < arr.length; i++) { 
    if (arr[i].flag === false) { 
    result.push(arr[i]); 
    } 
} 
for (var i = 0; i < arr.length; i++) { 
    if (!arr[i].flag === false) { 
    result.push(arr[i]); 
    } 
} 

Vous pouvez aussi le faire avec deux tableaux de résultats et une boucle, et concaténer les résultats:

var result1 = [], result2 = []; 
for (var i = 0; i < arr.length; i++) { 
    if (arr[i].flag === false) { 
    result1.push(arr[i]); 
    } else { 
    result2.push(arr[i]); 
    } 
} 
var result = result1.concat(result2); 

Answer 2

Ecrire une fonction de tri personnalisé et utilise le drapeau pour augmenter la priorité:

array.sort(function(a,b) { 
    if (!a['flag'] && b['flag']) 
    return 1; 
    if (a['flag'] && !b['flag']) 
    return -1; 
    return a['other'] - b['other'] 
}); 

Answer 3

La méthode de tri peut prendre une sortFunction en option comme paramètre que vous pouvez utiliser pour définir l'ordre des éléments après le tri

http://www.w3schools.com/jsref/jsref_sort.asp

Answer 4

arr = arr.sort(function(a, b) { // sort the array using a custom function, 
           // which is called a number of times to 
           // determine the new order. a and b are two 
           // elements to compare. JavaScript uses the 
           // return value to determine the new order: 
           // 1 - a should come later than b 
           // -1 - a should come earlier than b 
           // 0 - they should stay in their current order 
    return a.flag === true && b.flag === false 
      ? 1 // if a is true and b is false a should come later on 
      : a.flag === false && b.flag === true 
       ? -1 // if a is false and b is true a should come earlier 
       : a.other > b.other 
        ? 1 // if a.other > b.other, a must come later on 
        : a.other < b.other 
        ? -1 // if a.other < b.other, a must come earlier 
        : 0; // otherwise they are equal, so they have no order difference 
}); 

Answer 5

Puisque vous voulez sélectionnez certains éléments du tableau, mais gardez-les dans leur ordre d'origine, vous voulez la méthode filter(). Cette fonction est un extension to the standard, vous devrez peut-être utiliser la cale fournie à cette page selon les navigateurs que vous prenez en charge.

(Quand je lis votre question, je pensais que vous vouliez trier en fonction du drapeau, puis en fonction de la valeur, car vous pouvez utiliser la méthode intégrée sort().)

var input = [{flag: true, other: 1}, 
      {flag: true, other: 2}, 
      {flag: false, other: 3}, 
      {flag: true, other: 4}, 
      {flag: true, other: 5}, 
      {flag: true, other: 6}, 
      {flag: false, other: 7}] 
var false_items = input.filter(
     function(val, idx, arr) { 
      return (val["flag"] == false); 
     }); 
var true_items = input.filter(
     function(val, idx, arr) { 
      return (val["flag"] == true); 
     }); 

var sorted = false_items.concat(true_items); 

Answer 6

I pense que c'est un peu simple. Parce que javascript traite vrai 1 et faux que 0, vous pouvez les utiliser pour créer un comparateur comme celui-ci,

var comp = function(a,b){ 
    return a.flag*1 - b.flag*1; 
} 

et vous pouvez utiliser ce comparateur pour trier le tableau

var arr = [{flag: true, other: 1}, 
     {flag: true, other: 2}, 
     {flag: false, other: 3}, 
     {flag: true, other: 4}, 
     {flag: true, other: 5}, 
     {flag: true, other: 6}, 
     {flag: false, other: 7}]; 
arr.sort(comp); 

Answer 7

ES6 rend cette relativement simple dans une opération reduce:

const arr = [ 
{flag: true, other: 1}, 
{flag: true, other: 2}, 
{flag: false, other: 3}, 
{flag: true, other: 4}, 
{flag: true, other: 5}, 
{flag: true, other: 6}, 
{flag: false, other: 7}]; 

const sortedArr = arr.reduce((acc, element) => { 
    if (element.flag === false) { 
    return [element, ...acc]; 
    } 
    return [...acc, element]; 
}, []);