OrderBy pipe issue


97

Non sono in grado di tradurre questo codice da Angualr 1 ad Angular 2:

ng-repeat="todo in todos | orderBy: 'completed'"

Questo è quello che ho fatto seguendo la risposta di Thierry Templier:

Modello componente:

*ngFor="#todo of todos | sort"

Codice componente:

@Component({
    selector: 'my-app',
    templateUrl: "./app/todo-list.component.html",
    providers: [TodoService],
    pipes: [ TodosSortPipe ]

})

Codice tubo:

import { Pipe } from "angular2/core";
import {Todo} from './todo';

@Pipe({
  name: "sort"
})
export class TodosSortPipe {
  transform(array: Array<Todo>, args: string): Array<Todo> {
    array.sort((a: any, b: any) => {
      if (a < b) {
        return -1;
      } else if (a > b) {
        return 1;
      } else {
        return 0;
      }
    });
    return array;
  }
}

Sto cercando di ordinare un array di messaggi di posta Todoelettronica, ordinati dalla proprietà completed. Prima todo.completed = falsee poi il todo.complete = true.

Non capisco molto bene il transformmetodo e come passare gli argomenti in quel metodo e nel sortmetodo.

Qual è l' args: stringargomento? Cosa sono ae da bdove vengono?


Ho trovato questo pacchetto di moduli per OrderBy nelle versioni Angular5
Code Spy

Risposte:


78

Ho modificato la risposta di @Thierry Templier in modo che la pipe possa ordinare gli oggetti personalizzati in angolare 4:

import { Pipe, PipeTransform } from "@angular/core";

@Pipe({
  name: "sort"
})
export class ArraySortPipe  implements PipeTransform {
  transform(array: any, field: string): any[] {
    if (!Array.isArray(array)) {
      return;
    }
    array.sort((a: any, b: any) => {
      if (a[field] < b[field]) {
        return -1;
      } else if (a[field] > b[field]) {
        return 1;
      } else {
        return 0;
      }
    });
    return array;
  }
}

E per usarlo:

*ngFor="let myObj of myArr | sort:'fieldName'"

Si spera che questo aiuti qualcuno.


1
Ho ricevuto il messaggio: The pipe 'sort' could not be found. Posso in qualche modo iniettare il tubo nel mio componente come in 2 tubi angolari: [ArraySortPipe]?
Matija Župančić,

Guarda la risposta di @Thierry Templier su come iniettare il tubo nel componente della tua app
Sal

È necessario includere "ArraySortPipe" nelle dichiarazioni della gerarchia dei moduli. Qualcosa come: import {ArraySortPipe} da './../../shared/filters.pipe'; In "app.module.ts" e qualsiasi modulo sottostante. put: dichiarazioni: [ArraySortPipe]
Dudi

71

Si prega di consultare https://angular.io/guide/pipes#appendix-no-filterpipe-or-orderbypipe per la discussione completa. Questa citazione è molto rilevante. Fondamentalmente, per le app su larga scala che dovrebbero essere minimizzate in modo aggressivo, la logica di filtraggio e ordinamento dovrebbe spostarsi sul componente stesso.

"Ad alcuni di noi potrebbe non interessare minimizzare in modo aggressivo. Questa è la nostra scelta. Ma il prodotto Angular non dovrebbe impedire a qualcun altro di minimizzare in modo aggressivo. Pertanto, il team di Angular ha deciso che tutto ciò che viene spedito in Angular verrà minimizzato in modo sicuro.

Il team Angular e molti sviluppatori Angular esperti consigliano vivamente di spostare la logica di filtraggio e ordinamento nel componente stesso. Il componente può esporre una proprietà filteredHeroes o SortHeroes e assumere il controllo su quando e con che frequenza eseguire la logica di supporto. Qualsiasi funzionalità che avresti messo in una pipe e condivisa attraverso l'app può essere scritta in un servizio di filtraggio / ordinamento e iniettata nel componente. "


7
Come si dovrebbe spostare la logica "nel componente stesso" in un modo che possa "assumere il controllo su quando e con che frequenza eseguire la logica di supporto"? Ci sono buoni esempi da seguire?
Mzzzzzz

1
@Mzzzzzz Dove sta menzionando una proprietà come filteredHeroese sortedHeroes, penso che l'idea sia che durante l'inizializzazione del componente avresti eseguito una logica di ordinamento / filtro (forse chiamando un metodo da ngOnInit), quindi impostando quella proprietà con i risultati ordinati / filtrati e riesegui solo la logica / aggiorna la proprietà se c'è qualcosa che fa scattare una necessità (ad es. l'interazione dell'utente attiva la chiamata AJAX per ottenere più eroi, o l'utente fa clic su una casella di controllo per
filtrarne

41

Potresti implementare una pipe personalizzata per questo che sfrutta il sortmetodo degli array:

import { Pipe } from "angular2/core";

@Pipe({
  name: "sort"
})
export class ArraySortPipe {
  transform(array: Array<string>, args: string): Array<string> {
    array.sort((a: any, b: any) => {
      if (a < b) {
        return -1;
      } else if (a > b) {
        return 1;
      } else {
        return 0;
      }
    });
    return array;
  }
}

E usa quindi questo tubo come descritto di seguito. Non dimenticare di specificare la tua pipe pipesnell'attributo del componente:

@Component({
  (...)
  template: `
    <li *ngFor="list | sort"> (...) </li>
  `,
  pipes: [ ArraySortPipe ]
})
(...)

È un semplice esempio di array con valori di stringa, ma è possibile disporre di un'elaborazione di ordinamento avanzata (basata sugli attributi dell'oggetto nel caso dell'array di oggetti, basata sui parametri di ordinamento, ...).

Ecco un plunkr per questo: https://plnkr.co/edit/WbzqDDOqN1oAhvqMkQRQ?p=preview .

Spero che ti aiuti, Thierry


1
Grazie per la tua risposta, puoi spiegare il metodo di ordinamento?

1
In effetti il sortmetodo è un metodo Arraydell'oggetto JavaScript . Vedi questo link: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
Thierry Templier

Ok ho capito, utilizza il metodo di ordinamento javascript con una funzione di confronto come argomento. grazie!

1
Purtroppo il plunker è deprecato. Thierry?

4
la pipes: [..]dichiarazione non è più valida (e non è più necessaria)
phil294

9

OrderByPipe aggiornato: corretto non ordinamento delle stringhe.

creare una classe OrderByPipe:

import { Pipe, PipeTransform } from "@angular/core";
@Pipe( {
name: 'orderBy'
} )
export class OrderByPipe implements PipeTransform {
transform( array: Array<any>, orderField: string, orderType: boolean ): Array<string> {
    array.sort( ( a: any, b: any ) => {
        let ae = a[ orderField ];
        let be = b[ orderField ];
        if ( ae == undefined && be == undefined ) return 0;
        if ( ae == undefined && be != undefined ) return orderType ? 1 : -1;
        if ( ae != undefined && be == undefined ) return orderType ? -1 : 1;
        if ( ae == be ) return 0;
        return orderType ? (ae.toString().toLowerCase() > be.toString().toLowerCase() ? -1 : 1) : (be.toString().toLowerCase() > ae.toString().toLowerCase() ? -1 : 1);
    } );
    return array;
  }
}

nel tuo controller:

@Component({
pipes: [OrderByPipe]
})

o nel tuo

 declarations: [OrderByPipe]

nel tuo html:

<tr *ngFor="let obj of objects | orderBy : ObjFieldName: OrderByType">

ObjFieldName: nome del campo dell'oggetto che si desidera ordinare;

OrderByType: boolean; true: ordine decrescente; falso: crescente;


Per argomenti stringa che confrontano a [orderField] - b [orderField] restituisce NaN
Piotr Pęczek

Per gli argomenti di data non funziona. Il formato della data come testo verrà ordinato in modo errato.
Rafael Pizao

9

Angular non viene fornito con un orderBy filter out of the box, ma se decidiamo di averne bisogno possiamo facilmente crearne uno. Ci sono tuttavia alcuni avvertimenti di cui dobbiamo essere consapevoli riguardo alla velocità e alla minimizzazione. Vedi sotto.

Un semplice tubo sarebbe simile a questo.

import { Pipe, PipeTransform } from '@angular/core';

@Pipe({
  name: 'sort'
})
export class SortPipe implements PipeTransform {
  transform(ary: any, fn: Function = (a,b) => a > b ? 1 : -1): any {
    return ary.sort(fn)
  }
}

Questa pipe accetta una funzione di ordinamento (fn ) e le fornisce un valore predefinito che ordinerà un array di primitive in modo sensato. Abbiamo la possibilità di sovrascrivere questa funzione di ordinamento, se lo desideriamo.

Non accetta il nome di un attributo come stringa, perché i nomi degli attributi sono soggetti a minimizzazione. Cambieranno quando minimizziamo il nostro codice, ma i minificatori non sono abbastanza intelligenti da minimizzare anche il valore nella stringa del modello.

Ordinamento delle primitive (numeri e stringhe)

Potremmo usarlo per ordinare un array di numeri o stringhe usando il comparatore predefinito:

import { Component } from '@angular/core';

@Component({
  selector: 'cat',
  template: `
    {{numbers | sort}}
    {{strings | sort}}
  `
})
export class CatComponent
  numbers:Array<number> = [1,7,5,6]
  stringsArray<string> = ['cats', 'hats', 'caveats']
}

Ordinamento di un array di oggetti

Se vogliamo ordinare un array di oggetti, possiamo assegnargli una funzione di confronto.

import { Component } from '@angular/core';

@Component({
  selector: 'cat',
  template: `
    {{cats | sort:byName}}
  `
})
export class CatComponent
  cats:Array<Cat> = [
    {name: "Missy"},
    {name: "Squoodles"},
    {name: "Madame Pompadomme"}
  ]
  byName(a,b) {
    return a.name > b.name ? 1 : -1
  }
}

Avvertenze: tubi puri e impuri

Angular 2 ha un concetto di tubi puri e impuri.

Un pipe puro ottimizza il rilevamento delle modifiche utilizzando l'identità dell'oggetto. Ciò significa che la pipe verrà eseguita solo se l'oggetto di input cambia identità, ad esempio se aggiungiamo un nuovo elemento all'array. Non scenderà negli oggetti. Ciò significa che se cambiamo un attributo annidato:this.cats[2].name = "Fluffy" ad esempio, la pipe non verrà rieseguita. Questo aiuta Angular ad essere veloce. I tubi angolari sono puri per impostazione predefinita.

Un tubo impuro, d'altra parte, controllerà gli attributi dell'oggetto. Questo potenzialmente lo rende molto più lento. Poiché non può garantire ciò che farà la funzione pipe (forse è stata ordinata in modo diverso in base all'ora del giorno, ad esempio), una pipe impura verrà eseguita ogni volta che si verifica un evento asincrono.Questo rallenterà notevolmente la tua app se l'array è grande.

Il tubo sopra è puro. Ciò significa che verrà eseguito solo quando gli oggetti nell'array non sono modificabili. Se cambi un gatto, devi sostituire l'intero oggetto gatto con uno nuovo.

this.cats[2] = {name:"Tomy"}

Possiamo cambiare quanto sopra in un tubo impuro impostando l'attributo puro:

import { Pipe, PipeTransform } from '@angular/core';

@Pipe({
  name: 'sort',
  pure: false
})
export class SortPipe implements PipeTransform {
  transform(ary: any, fn: Function = (a,b) => a > b ? 1 : -1): any {
    return ary.sort(fn)
  }
}

Questo tubo scenderà negli oggetti, ma sarà più lento. Usare con cautela.


Grazie .. Mi hai aiutato molto. Ma una domanda ... Se non dovessimo usare pipe o filtri per l'ordinamento, qual è l'approccio migliore? Ho cercato ovunque, tutti stanno dando una soluzione creando pipe.
Pavan Shukla

@PavanShukla Puoi usare una pipe, assicurati solo che le voci dell'array siano immutabili e crea una pipe pura. Oppure, se non si dispone di un array di grandi dimensioni, creare un tubo impuro e ordinare ogni rendering. In alternativa, crea un array ordinato come attributo del tuo componente e rendilo.
superluminario

Ho usato la logica array.sort al clic di ciascuna intestazione della colonna. Sto eseguendo questa operazione sull'array di dati del display .. è un buon modo?
Pavan Shukla

7

Ho creato un pipe OrderBy che fa proprio quello che ti serve. Supporta anche la possibilità di ordinare su più colonne di un enumerabile di oggetti.

<li *ngFor="#todo in todos | orderBy : ['completed']">{{todo.name}} {{todo.completed}}</li>

Questa pipe consente di aggiungere più elementi all'array dopo il rendering della pagina e ordinerà dinamicamente l'array con gli aggiornamenti.

Ho una recensione sul processo qui .

Ed ecco una demo funzionante: http://fuelinteractive.github.io/fuel-ui/#/pipe/orderby e https://plnkr.co/edit/DHLVc0?p=info


Non stai gestendo valori nulli.
Ali Habibzadeh

se (a == null) a = 0; se (b == null) b = 0;
Ali Habibzadeh

Anche i valori con lo stesso valore sono instabili e si muovono quando fai clic nell'interfaccia
Ali Habibzadeh

@XGreen grazie per questo. Aggiungerò il supporto per valori null / undefined nel prossimo aggiornamento di fuel-ui. Quanto al nervosismo di valori uguali, non lo vedo. Quale browser utilizzate?
Cory Shaw

Chrome versione 50.0.2661.86 (64 bit), OSX El Capitan
Ali Habibzadeh

4

Ti consiglio di usare lodash con angolare, quindi la tua pipa sarà la prossima:

import {Pipe, PipeTransform} from '@angular/core';
import * as _ from 'lodash'
@Pipe({
    name: 'orderBy'
})
export class OrderByPipe implements PipeTransform {

    transform(array: Array<any>, args?: any): any {
        return _.sortBy(array, [args]);
    }

}

e usalo in html come

*ngFor = "#todo of todos | orderBy:'completed'"

e non dimenticare di aggiungere Pipe al tuo modulo

@NgModule({
    ...,
    declarations: [OrderByPipe, ...],
    ...
})

Mi piace il tuo approccio Александр Петрик ma preferisco inviare array sul template: orderBy: ['field1', 'field2'] E poi chiamare sulla pipe: return _.sortBy (array, args);
Eric

1
Il problema dell'utilizzo di _.sortBy è che non è possibile specificare l'ordine discendente. Ho scoperto che usando _.orderBy puoi specificare un ordine personalizzato per ogni campo. es: _.orderBy (array, ['field1', 'field2'], ['asc', 'desc'])
Eric

3

Funzionerà per qualsiasi campo gli passi. ( IMPORTANTE: ordinerà solo in ordine alfabetico, quindi se passi una data la ordinerà come alfabeto non come data)

/*
 *      Example use
 *      Basic Array of single type: *ngFor="let todo of todoService.todos | orderBy : '-'"
 *      Multidimensional Array Sort on single column: *ngFor="let todo of todoService.todos | orderBy : ['-status']"
 *      Multidimensional Array Sort on multiple columns: *ngFor="let todo of todoService.todos | orderBy : ['status', '-title']"
 */

import {Pipe, PipeTransform} from "@angular/core";

@Pipe({name: "orderBy", pure: false})
export class OrderByPipe implements PipeTransform {

    value: string[] = [];

    static _orderByComparator(a: any, b: any): number {

        if (a === null || typeof a === "undefined") { a = 0; }
        if (b === null || typeof b === "undefined") { b = 0; }

        if (
            (isNaN(parseFloat(a)) ||
            !isFinite(a)) ||
            (isNaN(parseFloat(b)) || !isFinite(b))
        ) {
            // Isn"t a number so lowercase the string to properly compare
            a = a.toString();
            b = b.toString();
            if (a.toLowerCase() < b.toLowerCase()) { return -1; }
            if (a.toLowerCase() > b.toLowerCase()) { return 1; }
        } else {
            // Parse strings as numbers to compare properly
            if (parseFloat(a) < parseFloat(b)) { return -1; }
            if (parseFloat(a) > parseFloat(b)) { return 1; }
        }

        return 0; // equal each other
    }

    public transform(input: any, config = "+"): any {
        if (!input) { return input; }

        // make a copy of the input"s reference
        this.value = [...input];
        let value = this.value;
        if (!Array.isArray(value)) { return value; }

        if (!Array.isArray(config) || (Array.isArray(config) && config.length === 1)) {
            let propertyToCheck: string = !Array.isArray(config) ? config : config[0];
            let desc = propertyToCheck.substr(0, 1) === "-";

            // Basic array
            if (!propertyToCheck || propertyToCheck === "-" || propertyToCheck === "+") {
                return !desc ? value.sort() : value.sort().reverse();
            } else {
                let property: string = propertyToCheck.substr(0, 1) === "+" || propertyToCheck.substr(0, 1) === "-"
                    ? propertyToCheck.substr(1)
                    : propertyToCheck;

                return value.sort(function(a: any, b: any) {
                    let aValue = a[property];
                    let bValue = b[property];

                    let propertySplit = property.split(".");

                    if (typeof aValue === "undefined" && typeof bValue === "undefined" && propertySplit.length > 1) {
                        aValue = a;
                        bValue = b;
                        for (let j = 0; j < propertySplit.length; j++) {
                            aValue = aValue[propertySplit[j]];
                            bValue = bValue[propertySplit[j]];
                        }
                    }

                    return !desc
                        ? OrderByPipe._orderByComparator(aValue, bValue)
                        : -OrderByPipe._orderByComparator(aValue, bValue);
                });
            }
        } else {
            // Loop over property of the array in order and sort
            return value.sort(function(a: any, b: any) {
                for (let i = 0; i < config.length; i++) {
                    let desc = config[i].substr(0, 1) === "-";
                    let property = config[i].substr(0, 1) === "+" || config[i].substr(0, 1) === "-"
                        ? config[i].substr(1)
                        : config[i];

                    let aValue = a[property];
                    let bValue = b[property];

                    let propertySplit = property.split(".");

                    if (typeof aValue === "undefined" && typeof bValue === "undefined" && propertySplit.length > 1) {
                        aValue = a;
                        bValue = b;
                        for (let j = 0; j < propertySplit.length; j++) {
                            aValue = aValue[propertySplit[j]];
                            bValue = bValue[propertySplit[j]];
                        }
                    }

                    let comparison = !desc
                        ? OrderByPipe._orderByComparator(aValue, bValue)
                        : -OrderByPipe._orderByComparator(aValue, bValue);

                    // Don"t return 0 yet in case of needing to sort by next property
                    if (comparison !== 0) { return comparison; }
                }

                return 0; // equal each other
            });
        }
    }
}

Puoi pubblicare un esempio di utilizzo?
TheUnreal

Non riesco a compilare il codice che hai fornito. Ricevo un errore dicendo che @Componentnon ha pipesproprietà.
Azimuth

3

Questo è un buon sostituto per il tubo orderby AngularJs in angular 4 . Facile e semplice da usare.

Questo è l'URL di github per ulteriori informazioni https://github.com/VadimDez/ngx-order-pipe

import { Pipe, PipeTransform } from '@angular/core';

@Pipe({
  name: 'orderBy'
})
export class OrderPipe implements PipeTransform {

  transform(value: any | any[], expression?: any, reverse?: boolean): any {
    if (!value) {
      return value;
    }

    const isArray = value instanceof Array;

    if (isArray) {
      return this.sortArray(value, expression, reverse);
    }

    if (typeof value === 'object') {
      return this.transformObject(value, expression, reverse);
    }

    return value;
  }

  /**
   * Sort array
   *
   * @param value
   * @param expression
   * @param reverse
   * @returns {any[]}
   */
  private sortArray(value: any[], expression?: any, reverse?: boolean): any[] {
    const isDeepLink = expression && expression.indexOf('.') !== -1;

    if (isDeepLink) {
      expression = OrderPipe.parseExpression(expression);
    }

    let array: any[] = value.sort((a: any, b: any): number => {
      if (!expression) {
        return a > b ? 1 : -1;
      }

      if (!isDeepLink) {
        return a[expression] > b[expression] ? 1 : -1;
      }

      return OrderPipe.getValue(a, expression) > OrderPipe.getValue(b, expression) ? 1 : -1;
    });

    if (reverse) {
      return array.reverse();
    }

    return array;
  }


  /**
   * Transform Object
   *
   * @param value
   * @param expression
   * @param reverse
   * @returns {any[]}
   */
  private transformObject(value: any | any[], expression?: any, reverse?: boolean): any {
    let parsedExpression = OrderPipe.parseExpression(expression);
    let lastPredicate = parsedExpression.pop();
    let oldValue = OrderPipe.getValue(value, parsedExpression);

    if (!(oldValue instanceof Array)) {
      parsedExpression.push(lastPredicate);
      lastPredicate = null;
      oldValue = OrderPipe.getValue(value, parsedExpression);
    }

    if (!oldValue) {
      return value;
    }

    const newValue = this.transform(oldValue, lastPredicate, reverse);
    OrderPipe.setValue(value, newValue, parsedExpression);
    return value;
  }

  /**
   * Parse expression, split into items
   * @param expression
   * @returns {string[]}
   */
  private static parseExpression(expression: string): string[] {
    expression = expression.replace(/\[(\w+)\]/g, '.$1');
    expression = expression.replace(/^\./, '');
    return expression.split('.');
  }

  /**
   * Get value by expression
   *
   * @param object
   * @param expression
   * @returns {any}
   */
  private static getValue(object: any, expression: string[]) {
    for (let i = 0, n = expression.length; i < n; ++i) {
      const k = expression[i];
      if (!(k in object)) {
        return;
      }
      object = object[k];
    }

    return object;
  }

  /**
   * Set value by expression
   *
   * @param object
   * @param value
   * @param expression
   */
  private static setValue(object: any, value: any, expression: string[]) {
    let i;
    for (i = 0; i < expression.length - 1; i++) {
      object = object[expression[i]];
    }

    object[expression[i]] = value;
  }
}

2

Poiché sappiamo che il filtro e l'ordine per vengono rimossi da ANGULAR 2 e dobbiamo scrivere il nostro, ecco un buon esempio su plunker e un articolo dettagliato

Utilizzava sia filter che orderby, ecco il codice per order pipe

import { Pipe, PipeTransform } from '@angular/core';    
@Pipe({  name: 'orderBy' })
export class OrderrByPipe implements PipeTransform {

  transform(records: Array<any>, args?: any): any {       
    return records.sort(function(a, b){
          if(a[args.property] < b[args.property]){
            return -1 * args.direction;
          }
          else if( a[args.property] > b[args.property]){
            return 1 * args.direction;
          }
          else{
            return 0;
          }
        });
    };
 }

2

Puoi usarlo per gli oggetti:

@Pipe({
  name: 'sort',
})
export class SortPipe implements PipeTransform {

  transform(array: any[], field: string): any[] {
    return array.sort((a, b) => a[field].toLowerCase() !== b[field].toLowerCase() ? a[field].toLowerCase() < b[field].toLowerCase() ? -1 : 1 : 0);
  }

}

2

In package.json, aggiungi qualcosa come (Questa versione è ok per Angular 2):

  "ngx-order-pipe": "^1.1.3",

Nel tuo modulo dattiloscritto (e importa l'array):

  import { OrderModule } from 'ngx-order-pipe';

1
<!-- const cars=['Audi','Merc','BMW','Volvo','Tesla'] -->

<ul>
  <li *ngFor="let car of cars">{{car}}</li>
</ul>


/*
 *ngFor="let c of oneDimArray | sortBy:'asc'"
 *ngFor="let c of arrayOfObjects | sortBy:'asc':'propertyName'"
*/
import { Pipe, PipeTransform } from '@angular/core';
import { orderBy } from 'lodash';

@Pipe({ name: 'sortBy' })
export class SortByPipe implements PipeTransform {

  transform(value: any[], order = '', column: string = ''): any[] {
    if (!value || order === '' || !order) { return value; } // no array
    if (!column || column === '') { return sortBy(value); } // sort 1d array
    if (value.length <= 1) { return value; } // array with only one item
    return orderBy(value, [column], [order]);
  }
}

1
Grazie, ottima risposta
AM - EVS

0

Nella versione corrente di Angular2, le pipe orderBy e ArraySort non sono supportate. È necessario scrivere / utilizzare alcune pipe personalizzate per questo.


0

Per la versione Angular 5+ possiamo utilizzare il pacchetto ngx-order-pipe

Link al tutorial sorgente

Installa pacchetto

$ npm install ngx-order-pipe --save

Importa nel modulo app

import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';

import { FormsModule } from '@angular/forms';
import { AppComponent } from './app.component';
import { OrderModule } from 'ngx-order-pipe';

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    FormsModule,
    OrderModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }

utilizzare ovunque

  <ul>
    <li *ngFor="let item of (dummyData | orderBy:'name') ">
      {{item.name}}
    </li>
  </ul>


-1
Component template:
todos| sort: ‘property’:’asc|desc’

Pipe code:

import { Pipe,PipeTransform  } from "angular/core";
import {Todo} from './todo';

@Pipe({
  name: "sort"
})
export class TodosSortPipe implements PipeTransform {
  transform(array: Array<Todo>, args: string): Array<Todo> {
    array.sort((a: any, b: any) => {
      if (a < b) {
        return -1;
      } else if (a > b) {
        return 1;
      } else {`enter code here`
        return 0;
      }
    });
    return array;
  }
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.