Сортировка не применяется в списке объектов

Question

Я сортирую массив объектов, и функция сортировки, похоже, не имеет никакого результата для массива. Таким образом, он возвращает тот же список.

Я экспортировал массив и функции сортировки в окно и выполнил их вручную, после чего полученный массив был хорошо отсортирован.

import { connect } from "react-redux"

import DestinationsGallery from "./destinationsGallery"

import DestinationFilter from "./functions/filter"
import WindPoint from "./functions/windPoint"
import {sortCosts,sortWind, sortName} from "./functions/sort"

const getSelectedDestinations = ( catalog, filter ) => { 
    let paramCatalog = null 
    let paramSorted = null

    if (catalog) {
        paramCatalog =  catalog
            .map(spot => WindPoint(spot,filter))
            .filter( item => DestinationFilter( item,filter ) )
            .sort( ( a,b ) => a.name.localeCompare( b.name ) )


        window.catalog = paramCatalog
        window.sortCosts = sortCosts
        window.sortWind = sortWind
        window.sortName = sortName

        console.log("Unsorted",paramCatalog)    
        paramSorted = paramCatalog.sort( sortName )
        console.log( "Sorted name",paraSorted, paramCatalog.sort( sortName ) )


        let paraSorted = paramCatalog.sort( sortWind )
        console.log( "Sorted wind",paraSorted )
    }
    return paramSorted
}

export default connect( store => ({
    destinations: getSelectedDestinations(store.kiteSpots.catalog.list, store.kiteSpots.filter),
    filter: store.kiteSpots.filter,
}),null)(DestinationsGallery)

и мои функции сортировки:

export const sortCosts = ( a,b ) => ( a.data.CostsRank > b.data.CostsRank? 1 : -1 )  
export const sortWind = ( a,b ) => ( a.windPoint.probability > b.windPoint.probability ? 1 : -1 ) 
export const sortName = ( a,b ) => { return a.name > b.name ? 1 : -1 }

Так что я просто хотел бы, чтобы список вывода был правильным

Answer 1

Вы можете попробовать использовать String.prototype.localeCompare для сравнения строк. См. MDN .

const x = [
  { name: "James"},
  { name: "Zeb"},
  { name: "Annie"},
  { name: "Michaèl"},
  { name: "James"},
];

console.log( x.slice(0).sort( (a, b) => a.name.localeCompare(b.name) ) );
// include value equality
console.log( x.slice(0).sort( (a, b) => -(a.name < b.name) || +(a.name > b.name)) );

Или включить в сравнение возможное равенство значений:

a.name > b.name ? 1 : a.name < b.name ? -1 : 0) или (см. Комментарии)

-(a.name < b.name) || +(a.name > b.name)

Или (для исполнения) вы можете использовать Intl.Collator ( см. MDN и следующий фрагмент)

const intlCollator = new Intl.Collator("de", {sensitivity: "variant"});
console.log( 
  [
    { name: "Anna"},
    { name: "Michiel"},
    { name: "Desiré"},
    { name: "Siënna"},
    { name: "Jøn"},
    { name: "Mariêke"},
    { name: "José"},
    { name: "Anna"},
    { name: "Renée"},
    { name: "Désirée"},
  ].sort( (a, b) => 
      intlCollator.compare(a.name, b.name) )
);

.as-console-wrapper { top: 0; max-height: 100% !important; }

Answer 2

Этот код не изменяет (сортирует) массив каталога, если это то, что вы ожидали, будет отсортирован только каталог параметров, так как сортировка применяется к результату отображения и фильтрации каталога, которые оба возвращают новые экземпляры массива.

Возможно, если вы опубликуете больше кода и исходных данных, мы сможем выяснить, что не так.

При этом не следует сравнивать строки таким образом, используя математический оператор, поскольку он может вести себя не так, как вы ожидаете.

В этом обсуждении из stackoverflow немного объясняются различия. В коротком порядке кодовой точки (используется при сравнении с>) не совпадает с фактическим алфавитным порядком.

Кроме того, возвращаемое значение функции сравнения должно быть 1, -1 или 0, потому что иногда не имеет значения замена одинаковых значений.

Например, сортировка [0,0,1,1,2,2,3,3] путем разрешения замены равных значений сравнения не имеет значения.

Но сортировка [{name: 'foo ', значение: 0}, {name:' bar ', value: 0}, {name:' fuu ', value: 1}, {name:' ber ', value: 1}] в соответствии со значением может изменитьпорядок исходного массива, когда это может быть нежелательно.

Это правда, что более ранняя реализация нативной сортировки не заботилась о равном значении сравнения и может иметь порядок в любом случае, но теперь реализации nore не соблюдают договор о том, чтобы не изменятьуже отсортированные массивы.

Если вам важен алфавитный порядок строк в кодировке Юникод, попробуйте использовать String.prototype.localeCompare .

Если вы сравниваете числа (например,и б) и если вам не нужно иметь дело сth NaN или бесконечность или не определено, более корректно и требует меньше собственных инструкций для возврата a-b в порядке возрастания и b-a в порядке убывания.