Boru sorununa göre


101

Bu kodu Angualr 1'den Angular 2'ye çeviremiyorum:

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

Thierry Templier'in cevabından sonra yaptığım şey bu:

Bileşen şablonu:

*ngFor="#todo of todos | sort"

Bileşen kodu:

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

})

Boru kodu:

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;
  }
}

TodoÖzelliğe göre sıralanan bir diziyi sıralamaya çalışıyorum completed. Önce todo.completed = falseve sonra todo.complete = true.

transformYöntemi ve bu yöntemdeki ve yöntemdeki argümanların nasıl iletileceğini çok iyi anlamıyorum sort.

Nedir args: stringargüman? Ne var ave bnereden geliyorlar?


OrderBy için bu modül paketini Angular5 + sürümlerinde buldum freakyjolly.com/…
Code Spy

Yanıtlar:


85

@Thierry Templier'in yanıtını değiştirdim, böylece boru özel nesneleri açısal 4'te sıralayabilir:

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;
  }
}

Ve kullanmak için:

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

Umarım bu birine yardımcı olur.


1
Ben mesajı aldım: The pipe 'sort' could not be found. Açısal 2 boru: [ArraySortPipe] gibi bileşenime bir şekilde boru enjekte edebilir miyim?
Matija Župančić

Boruyu uygulama bileşeninize nasıl enjekte edeceğinizle ilgili @Thierry Templier yanıtına bakın
Sal

Modül hiyerarşi bildirimlerine "ArraySortPipe" eklemeniz gerekir. Şuna benzer bir şey: {ArraySortPipe} './../../shared/filters.pipe'dan içe aktar; 'App.module.ts' ve altındaki herhangi bir modülde. put: declarations: [ArraySortPipe]
Dudi

73

Tam tartışma için lütfen https://angular.io/guide/pipes#appendix-no-filterpipe-or-orderbypipe bakın . Bu alıntı en alakalı. Temel olarak, agresif bir şekilde küçültülmesi gereken büyük ölçekli uygulamalar için filtreleme ve sıralama mantığı bileşenin kendisine taşınmalıdır.

"Bazılarımız bunu agresif bir şekilde küçültmek istemeyebilir. Bu bizim seçimimiz. Ancak Angular ürünü, başka birinin agresif bir şekilde küçültmesini engellememelidir. Bu nedenle, Angular ekibi Angular'da gönderilen her şeyin güvenli bir şekilde küçültülmesine karar verdi.

Angular ekibi ve birçok deneyimli Angular geliştiricisi, filtreleme ve sıralama mantığını bileşenin kendisine taşımanızı şiddetle tavsiye ediyor. Bileşen, bir filteredHeroes veya sıralanmışHeroes özelliğini açığa çıkarabilir ve destekleyici mantığın ne zaman ve ne sıklıkla çalıştırılacağını kontrol edebilir. Bir boruya ekleyeceğiniz ve uygulama genelinde paylaşacağınız tüm yetenekler, bir filtreleme / sıralama hizmetinde yazılabilir ve bileşene eklenebilir. "


7
Mantığı, "destekleyici mantığın ne zaman ve ne sıklıkla çalıştırılacağını kontrol edebilecek" bir şekilde "bileşenin kendisine" nasıl taşımalısınız? Bunun izlenecek iyi örnekleri var mı?
Mzzzzzz

1
@Mzzzzzz filteredHeroesve gibi bir özellikten bahsettiği yerde sortedHeroes, bence bileşen başlatılırken bir sıralama / filtreleme mantığı çalıştırmanız (belki ngOnInit'ten bir yöntemi çağırmanız), sonra bu özelliği sıralanmış / filtrelenmiş sonuçlarla ayarlamanız ve yalnızca bir ihtiyacı tetikleyen bir şey varsa mantığı yeniden çalıştırın / özelliği güncelleyin (örneğin, kullanıcı etkileşimi daha fazla kahraman almak için AJAX çağrısını tetikler veya kullanıcı bazı kriterlere göre yarısını filtrelemek için bir onay kutusunu tıklar)
jmq

Öyleyse onu bileşende mi kullanmalıyım yoksa yukarıdaki çözümü (özel boru) mu kullanmalıyım?
Ron Rofe

Bilginize: Bu bağlantı hedefi gitti.
tommueller

42

Bunun için sortdizi yöntemini kullanan özel bir kanal uygulayabilirsiniz :

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;
  }
}

Ve sonra bu boruyu aşağıda anlatıldığı gibi kullanın. Borunuzu pipesbileşenin özniteliğinde belirtmeyi unutmayın :

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

Bu, dize değerlerine sahip diziler için basit bir örnektir, ancak bazı gelişmiş sıralama işlemlerine sahip olabilirsiniz (nesne dizisi durumunda, sıralama parametrelerine dayalı olarak nesne özniteliklerine, ...).

İşte bunun için bir plunkr: https://plnkr.co/edit/WbzqDDOqN1oAhvqMkQRQ?p=preview .

Umarım sana yardımcı olur, Thierry


1
Cevabınız için teşekkürler, sıralama yöntemini açıklayabilir misiniz?

1
Aslında sortyöntem, JavaScript Arraynesnesinin bir yöntemidir . Şu bağlantıya bakın: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
Thierry Templier

Tamam anladım, argüman olarak karşılaştırma işlevi ile javascript sıralama yöntemini kullanıyor. teşekkür ederim!

1
Maalesef plunker kullanımdan kaldırıldı. Thierry?

4
pipes: [..]beyanı artık geçerli (ve artık gerekli) 'dir
phil294

9

Güncellenen OrderByPipe: dizelerin sıralanmaması düzeltildi.

OrderByPipe sınıfı oluşturun:

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;
  }
}

denetleyicinizde:

@Component({
pipes: [OrderByPipe]
})

veya senin içinde

 declarations: [OrderByPipe]

html'nizde:

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

ObjFieldName: sıralamak istediğiniz nesne alanı adı;

OrderByType: boolean; true: azalan sıra; yanlış: artan;


[OrderField] - b [orderField] 'ı karşılaştıran dize bağımsız değişkenleri için NaN
Piotr Pęczek

Tarih argümanları için çalışmıyor. Metin olarak tarih biçimi yanlış sıralanacak.
Rafael Pizao

9

Angular, bir siparişle gelmez Kutudan çıkan filtre ile, ancak bir tanesine ihtiyacımız olduğuna karar verirsek kolayca bir tane yapabiliriz. Bununla birlikte, hız ve küçültme konusunda bilmemiz gereken bazı uyarılar var. Aşağıya bakınız.

Basit bir boru şuna benzer.

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)
  }
}

Bu kanal bir sıralama işlevini ( fn) kabul eder ve ona bir ilkel diziyi mantıklı bir şekilde sıralayacak varsayılan bir değer verir. İstersek bu sıralama işlevini geçersiz kılma seçeneğimiz var.

Öznitelik adları küçültmeye tabi olduğundan, bir öznitelik adını bir dizge olarak kabul etmez. Kodumuzu küçülttüğümüzde değişecekler, ancak küçülticiler şablon dizesindeki değeri de küçültecek kadar akıllı değil.

İlkelleri sıralama (sayılar ve dizeler)

Varsayılan karşılaştırıcıyı kullanarak bir dizi veya dizeyi sıralamak için bunu kullanabiliriz:

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']
}

Bir dizi nesneyi sıralama

Bir nesne dizisini sıralamak istersek, ona bir karşılaştırma işlevi verebiliriz.

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
  }
}

Uyarılar - saf ve saf olmayan borular

Angular 2, saf ve saf olmayan boru konseptine sahiptir.

Saf bir boru , nesne kimliğini kullanarak değişiklik tespitini optimize eder. Bu, borunun yalnızca giriş nesnesinin kimlik değiştirmesi durumunda çalışacağı anlamına gelir, örneğin diziye yeni bir öğe eklersek. Nesnelere inmeyecek. Bu, iç içe geçmiş bir niteliği değiştirirsek: this.cats[2].name = "Fluffy"örneğin, borunun yeniden çalışmayacağı anlamına gelir. Bu, Angular'ın hızlı olmasına yardımcı olur. Açısal borular varsayılan olarak saftır.

Öte yandan saf olmayan bir boru , nesne özelliklerini kontrol edecektir. Bu, potansiyel olarak onu çok daha yavaş hale getirir. Boru işlevinin ne yapacağını garanti edemediği için (örneğin günün saatine göre farklı şekilde sıralanır), asenkron bir olay her meydana geldiğinde saf olmayan bir boru çalışacaktır. Dizi büyükse bu, uygulamanızı önemli ölçüde yavaşlatacaktır.

Yukarıdaki boru saftır. Bu, dizideki nesneler değişmez olduğunda yalnızca çalışacağı anlamına gelir. Bir kediyi değiştirirseniz, tüm kedi nesnesini yenisiyle değiştirmelisiniz.

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

Saf özelliğini ayarlayarak yukarıdakileri saf olmayan bir boruya dönüştürebiliriz:

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)
  }
}

Bu boru nesnelere inecek, ancak daha yavaş olacaktır. Dikkatle kullanın.


Teşekkürler .. Çok yardımcı oldum. Ama bir soru .. Sıralama için boru veya filtre kullanmamamız gerekiyorsa , en iyi yaklaşım nedir? Her yeri aradım, herkes boru oluşturarak çözüm veriyor.
Pavankumar Shukla

@PavanShukla Bir boru kullanabilirsiniz, sadece dizi girişlerinizin değişmez olduğundan emin olun ve saf bir boru oluşturun. Veya, büyük bir diziniz yoksa, saf olmayan bir boru oluşturun ve her bir işlemeyi sıralayın. Alternatif olarak, bileşeninizin bir özniteliği olarak sıralı bir dizi oluşturun ve bunu oluşturun.
süper parlak

Her bir cloumn başlığının tıklamasında array.sort mantığını kullandım. Bu işlemi görüntü veri dizisi üzerinde yapıyorum .. iyi bir yol mu?
Pavankumar Shukla

7

Tam ihtiyacınız olanı yapan bir OrderBy borusu oluşturdum. Ayrıca sayısız nesnenin birden çok sütununda sıralama yapabilmeyi destekler.

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

Bu kanal, sayfayı oluşturduktan sonra diziye daha fazla öğe eklemeye izin verir ve diziyi dinamik olarak güncellemelerle sıralar.

Burada süreçle ilgili bir yazı var .

Ve işte çalışan bir demo: http://fuelinteractive.github.io/fuel-ui/#/pipe/orderby ve https://plnkr.co/edit/DHLVc0?p=info


Boş değerleri işlemiyorsunuz.
Ali Habibzadeh

eğer (a == null) a = 0; eğer (b == null) b = 0;
Ali Habibzadeh

Ayrıca eşit değere sahip değerler arayüzde etrafında tıklayın olarak ürkek ve hareket vardır
Ali Habibzadeh

@XGreen bunun için teşekkürler. Fuel-ui'nin bir sonraki güncellemesinde boş / tanımsız değerler için destek ekleyeceğim. Eşit değerlerin gerginliğine gelince, bunu görmüyorum. Hangi tarayıcıyı kullanıyorsunuz?
Cory Shaw

Chrome Sürümü 50.0.2661.86 (64 bit), OSX El Capitan
Ali Habibzadeh

4

Köşeli lodash kullanmanızı öneririz, o zaman borunuz bir sonraki olacaktır:

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]);
    }

}

ve html gibi kullanın

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

ve modülünüze Boru eklemeyi unutmayın

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

Yaklaşımını severim Петрик ama şablonda dizi göndermeyi tercih ediyorum: orderBy: ['field1', 'field2'] Ve sonra boruyu çağırın: return _.sortBy (array, args);
Eric

1
_.SortBy kullanmanın sorunu, alt sıra belirtememenizdir. _.OrderBy kullanarak her alan için özel sipariş belirtebileceğinizi buldum. yani: _.orderBy (dizi, ['alan1', 'alan2'], ['artan', 'azalan'])
Eric

3

Bu, ona geçtiğiniz herhangi bir alan için çalışacaktır. ( ÖNEMLİ: Yalnızca alfabetik olarak sıralanacaktır, bu nedenle bir tarihi geçerseniz tarih olarak değil, alfabe olarak sıralayacaktır)

/*
 *      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
            });
        }
    }
}

Bir kullanım örneği gönderebilir misiniz?
TheUnreal

Sağladığınız kodu derleyemiyorum. Bunun mülkü @Componentolmadığını söyleyen bir hata alıyorum pipes.
Azimut

3

Bu angularjs için iyi yerine geçer orderby boru açısal 4 . Kullanımı kolay ve basit.

Bu, daha fazla bilgi için github URL'sidir 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

ANGULAR 2'den filtre ve sıralama kaldırıldığını bildiğimiz ve kendi yazmamız gerektiğine göre, burada plunker hakkında güzel bir örnek ve detaylı makale

Hem filtre hem de orderby kullandı, işte sipariş borusu kodu

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

Bunu nesneler için kullanabilirsiniz:

@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

Package.json içinde, (Bu sürüm Angular 2 için uygundur) gibi bir şey ekleyin:

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

Typecript modülünüzde (ve diziyi içe aktarır):

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

0

Angular2'nin geçerli sürümünde, orderBy ve ArraySort boruları desteklenmemektedir. Bunun için bazı özel borular yazmanız / kullanmanız gerekir.


0

Angular 5+ Sürüm için ngx-order-pipe paketini kullanabiliriz

Kaynak Eğitim Bağlantısı

Kurulum paketi

$ npm install ngx-order-pipe --save

Uygulama modülüne aktar

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 { }

her yerde kullan

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


0
<!-- 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
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;
  }
}
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.