OrderBy 파이프 문제


98

이 코드를 Angualr 1에서 Angular 2로 번역 할 수 없습니다.

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

이것은 Thierry Templier의 답변에 따라 내가 한 일입니다.

구성 요소 템플릿 :

*ngFor="#todo of todos | sort"

구성품 코드 :

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

})

파이프 코드 :

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속성별로 정렬 된 배열을 정렬하려고 합니다 completed. 먼저 todo.completed = false다음 todo.complete = true.

나는 그 transform방법과 그 방법과 방법에서 인수를 전달하는 방법을 잘 이해하지 못합니다 sort.

args: string논쟁 은 무엇입니까 ? 무엇 ab그들이 어디에서 온?


나는 Angular5 + 버전 freakyjolly.com/
Code Spy

답변:


79

파이프가 사용자 지정 개체를 각도 4로 정렬 할 수 있도록 @Thierry Templier의 응답을 수정했습니다.

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

그리고 그것을 사용하려면 :

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

바라건대 이것은 누군가를 도울 것입니다.


1
메시지가 있습니다 : The pipe 'sort' could not be found. 앵귤러 2 파이프 [ArraySortPipe]처럼 내 컴포넌트에 어떻게 든 파이프를 주입 할 수 있습니까?
Matija Župančić

앱 구성 요소에 파이프를 주입하는 방법에 대한 @Thierry Templier의 응답을 참조하십시오
Sal

모듈 계층 선언에 "ArraySortPipe"를 포함해야합니다. 같은 것 : import {ArraySortPipe} from './../../shared/filters.pipe'; 'app.module.ts'및 그 아래의 모든 모듈. put : 선언 : [ArraySortPipe]
Dudi

72

전체 토론 은 https://angular.io/guide/pipes#appendix-no-filterpipe-or-orderbypipe 를 참조 하십시오 . 이 인용문은 가장 관련성이 있습니다. 기본적으로 적극적으로 축소해야하는 대규모 앱의 경우 필터링 및 정렬 논리가 구성 요소 자체로 이동해야합니다.

"우리 중 일부는 이것을 공격적으로 축소하는 데 신경 쓰지 않을 수 있습니다. 그것이 우리의 선택입니다. 그러나 Angular 제품은 다른 사람이 공격적으로 축소하는 것을 막아서는 안됩니다. 따라서 Angular 팀은 Angular에 제공된 모든 것이 안전하게 축소 될 것이라고 결정했습니다.

Angular 팀과 경험 많은 Angular 개발자는 필터링 및 정렬 논리를 구성 요소 자체로 이동할 것을 강력히 권장합니다. 구성 요소는 filterHeroes 또는 sortedHeroes 속성을 노출하고 지원 논리를 실행할시기와 빈도를 제어 할 수 있습니다. 파이프에 넣고 앱 전체에서 공유 할 수있는 모든 기능을 필터링 / 정렬 서비스로 작성하고 구성 요소에 삽입 할 수 있습니다. "


7
"지원 로직을 실행하는시기와 빈도를 제어"할 수있는 방식으로 로직을 "구성 요소 자체로"어떻게 이동해야합니까? 따라야 할 좋은 예가 있습니까?
Mzzzzzz

1
@Mzzzzzz 어디 같은 속성을 언급하는 것 filteredHeroes하고 sortedHeroes, 나는 아이디어가 구성 요소를 초기화하는 동안 (아마도 ngOnInit에서 메소드를 호출하는) 일부 필터링 / 정렬 로직을 실행하는 거라고 생각의가 / 필터링 된 결과를 분류하여 그 속성을 설정하고, 필요를 유발하는 무언가가있는 경우에만 논리를 다시 실행 / 속성을 업데이트합니다 (예 : 사용자 상호 작용이 AJAX 호출을 트리거하여 더 많은 영웅을 얻거나 사용자가 확인란을 클릭하여 일부 기준에 따라 절반을 필터링하는 등)
jmq

42

sort배열 방법 을 활용하는 사용자 지정 파이프를 구현할 수 있습니다.

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

그리고 아래에 설명 된대로이 파이프를 사용합니다. pipes구성 요소 의 속성에 파이프를 지정하는 것을 잊지 마십시오 .

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

문자열 값이있는 배열에 대한 간단한 샘플이지만 일부 고급 정렬 처리를 수행 할 수 있습니다 (정렬 매개 변수를 기반으로하는 객체 배열의 경우 객체 속성을 기반으로 함).

여기에 대한 plunkr가 있습니다 : https://plnkr.co/edit/WbzqDDOqN1oAhvqMkQRQ?p=preview .

도움이 되었기를 바랍니다, Thierry


1
답변 감사합니다. 정렬 방법을 설명해 주시겠습니까?

1
사실 sort메서드는 JavaScript Array객체 의 메서드입니다 . 다음 링크를 참조하십시오 : developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
Thierry Templier 2016

알았어. 비교 함수를 인수로 사용하여 자바 스크립트 정렬 방법을 사용합니다. 감사합니다!

1
불행히도 플 런커는 더 이상 사용되지 않습니다. 티에리?

4
pipes: [..]선언은 더 이상 유효 (더 이상 필요 없음)입니다
phil294

9

OrderByPipe 업데이트 : 정렬되지 않는 문자열 수정.

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

컨트롤러에서 :

@Component({
pipes: [OrderByPipe]
})

또는 당신의

 declarations: [OrderByPipe]

귀하의 HTML에서 :

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

ObjFieldName : 정렬하려는 개체 필드 이름입니다.

OrderByType : 부울; 참 : 내림차순; 거짓 : 오름차순;


a [orderField]-b [orderField]를 비교하는 문자열 인수의 경우 NaN
Piotr Pęczek

날짜 인수의 경우 작동하지 않습니다. 텍스트로 된 날짜 형식이 잘못 정렬됩니다.
Rafael Pizao

9

Angular는 orderBy 필터를 기본 제공하지 않지만 필요하다고 결정하면 쉽게 만들 수 있습니다. 그러나 속도 및 축소와 관련하여 알아야 할 몇 가지주의 사항이 있습니다. 아래를 참조하십시오.

간단한 파이프는 다음과 같습니다.

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

이 파이프는 정렬 함수 ( fn)를 받아들이고 기본 배열을 합리적인 방식으로 정렬하는 기본값을 제공합니다. 원하는 경우이 정렬 기능을 재정의 할 수 있습니다.

속성 이름은 축소 될 수 있으므로 속성 이름을 문자열로 허용하지 않습니다. 코드를 축소하면 변경되지만 축소자는 템플릿 문자열의 값도 축소 할만큼 똑똑하지 않습니다.

기본 요소 (숫자 및 문자열) 정렬

이를 사용하여 기본 비교기를 사용하여 숫자 또는 문자열 배열을 정렬 할 수 있습니다.

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

개체 배열 정렬

객체 배열을 정렬하려면 비교 함수를 제공 할 수 있습니다.

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

주의 사항-순수 파이프와 불순 파이프

Angular 2는 순수하고 불순한 파이프의 개념을 가지고 있습니다.

순수 파이프는 객체 ID를 사용하여 변경 감지를 최적화합니다. 이는 입력 객체가 ID를 변경하는 경우 (예 : 배열에 새 항목을 추가하는 경우)에만 파이프가 실행됨을 의미합니다. 물체로 내려 가지 않습니다. 즉, 중첩 된 속성을 변경 this.cats[2].name = "Fluffy"하면 파이프가 다시 실행되지 않습니다. 이것은 Angular가 빠르도록 도와줍니다. 각도 파이프는 기본적으로 순수합니다.

반면에 불순한 파이프 는 객체 속성을 확인합니다. 이것은 잠재적으로 훨씬 느리게 만듭니다. 파이프 함수가 수행 할 작업을 보장 할 수 없기 때문에 (예를 들어 시간에 따라 다르게 정렬 될 수 있음) 비동기 이벤트가 발생할 때마다 불순한 파이프가 실행됩니다. 배열이 큰 경우 앱 속도가 상당히 느려집니다.

위의 파이프는 순수합니다. 즉, 배열의 개체가 변경 불가능할 때만 실행됩니다. 고양이를 변경하는 경우 전체 고양이 개체를 새 개체로 바꿔야합니다.

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

pure 속성을 설정하여 위를 불순한 파이프로 변경할 수 있습니다.

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

이 파이프는 물체로 내려가지만 속도가 느려집니다. 주의해서 사용하십시오.


고마워 .. 많이 도와 줬어. 하지만 한 가지 질문이 있습니다. 정렬에 파이프 나 필터를 사용하지 않아야하는 경우 가장 좋은 방법은 무엇입니까? 나는 모든 곳을 검색했고, 모두가 파이프를 만들어 해결책을 제시하고 있습니다.
Pavan Shukla

@PavanShukla 파이프를 사용할 수 있습니다. 배열 항목이 변경 불가능한지 확인하고 순수 파이프를 생성하기 만하면됩니다. 또는 큰 배열이 없으면 불순한 파이프를 만들고 각 렌더링을 정렬하십시오. 또는 구성 요소의 속성으로 정렬 된 배열을 만들고 렌더링합니다.
superluminary

각 cloumn 제목을 클릭 할 때 array.sort 논리를 사용했습니다. 디스플레이 데이터 배열에서이 작업을 수행하고 있습니다. 좋은 방법입니까?
Pavan Shukla

7

필요한 작업을 수행하는 OrderBy 파이프를 만들었습니다. 또한 개체 열거 형의 여러 열에서 정렬 할 수 있도록 지원합니다.

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

이 파이프는 페이지를 렌더링 한 후 배열에 더 많은 항목을 추가 할 수 있도록하며 업데이트 된 배열을 동적으로 정렬합니다.

여기에 과정에 대한 글이 있습니다 .

그리고 여기에 작동하는 데모가 있습니다 : http://fuelinteractive.github.io/fuel-ui/#/pipe/orderbyhttps://plnkr.co/edit/DHLVc0?p=info


널 값을 처리하지 않습니다.
Ali Habibzadeh

만약 (a == null) a = 0; 만약 (b == null) b = 0;
Ali Habibzadeh

또한 동일한 값을 가진 값은 인터페이스에서 클릭 할 때 불안정하고 이동합니다.
Ali Habibzadeh

@XGreen에 감사드립니다. 다음 fuel-ui 업데이트에서 null / 정의되지 않은 값에 대한 지원을 추가 할 것입니다. 동등한 가치의 불안정성에 관해서는 이것을 보지 못했습니다. 어떤 브라우저를 사용하고 있습니까?
Cory Shaw

Chrome 버전 50.0.2661.86 (64 비트), OSX El Capitan
Ali Habibzadeh

4

각도와 함께 lodash를 사용하는 것이 좋습니다. 그러면 파이프가 다음이 될 것입니다.

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

}

html에서 사용하십시오.

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

모듈에 파이프를 추가하는 것을 잊지 마십시오.

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

나는 당신의 접근 방식 Александр Петрик를 좋아하지만 템플릿에 배열을 보내는 것을 선호합니다 : orderBy : [ 'field1', 'field2'] 그런 다음 파이프를 호출합니다. return _.sortBy (array, args);
에릭

1
_.sortBy 사용의 문제는 하위 순서를 지정할 수 없다는 것입니다. _.orderBy를 사용하면 모든 필드에 대해 사용자 지정 순서를 지정할 수 있습니다. ie : _.orderBy (array, [ 'field1', 'field2'], [ 'asc', 'desc'])
Eric

3

이것은 전달하는 모든 필드에서 작동합니다. ( 중요 : 알파벳순으로 만 정렬되므로 날짜가 지나면 날짜가 아닌 알파벳순으로 정렬됩니다.)

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

사용 예를 게시 할 수 있습니까?
TheUnreal

제공하신 코드를 컴파일 할 수 없습니다. 속성 @Component이 없다는 오류가 발생 pipes합니다.
Azimuth

3

이것은 angular 4의 AngularJs orderby 파이프를 대체하는 좋은 방법 입니다. 사용하기 쉽고 간단합니다.

자세한 내용은 github URL입니다. 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에서 filter와 order by가 제거되었고 우리 자신을 작성해야한다는 것을 알고 있듯이, 여기에 plunker상세한 기사 에 대한 좋은 예가 있습니다.

필터와 orderby를 모두 사용했습니다. 여기에 주문 파이프 코드가 있습니다.

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

객체에 사용할 수 있습니다.

@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에 다음과 같은 내용을 추가합니다 (이 버전은 Angular 2에 적합합니다).

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

typescript 모듈 (및 가져 오기 배열)에서 :

  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
감사합니다. 훌륭한 답변
AM-EVS

0

Angular2의 현재 버전에서는 orderBy 및 ArraySort 파이프가 지원되지 않습니다. 이를 위해 사용자 지정 파이프를 작성 / 사용해야합니다.


0

Angular 5+ 버전의 경우 ngx-order-pipe 패키지를 사용할 수 있습니다.

소스 튜토리얼 링크

패키지 설치

$ npm install ngx-order-pipe --save

앱 모듈에서 가져 오기

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

어디서나 사용

  <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;
  }
}
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.