Sự cố về đường ống đặt hàng


97

Tôi không thể dịch mã này từ Angualr 1 sang Angular 2:

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

Đây là những gì tôi đã làm sau câu trả lời của Thierry Templier:

Mẫu thành phần:

*ngFor="#todo of todos | sort"

Mã thành phần:

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

})

Mã ống:

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

Tôi đang cố gắng sắp xếp một mảng Todos, được sắp xếp theo thuộc tính completed. Đầu tiên todo.completed = falsevà sau đó todo.complete = true.

Tôi không hiểu lắm về transformphương thức và cách truyền các đối số trong phương thức đó và trong sortphương thức.

Là gì args: stringtranh cãi? Chúng là gì abđến từ đâu?


Tôi tìm thấy gói mô-đun này cho OrderBy trong Angular5 + phiên bản freakyjolly.com/...
Mã Spy

Câu trả lời:


78

Tôi đã sửa đổi phản hồi của @Thierry Templier để đường ống có thể sắp xếp các đối tượng tùy chỉnh theo góc 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;
  }
}

Và để sử dụng nó:

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

Hy vọng rằng điều này sẽ giúp ai đó.


1
Tôi đã nhận được thông báo: The pipe 'sort' could not be found. Bằng cách nào đó tôi có thể chèn đường ống trong thành phần của mình như trong 2 đường ống góc cạnh: [ArraySortPipe] không?
Matija Župančić 27/09/17

Xem phản hồi của @Thierry Templier về cách đưa đường ống vào thành phần ứng dụng của bạn
Sal

Bạn cần đưa "ArraySortPipe" vào khai báo phân cấp mô-đun của mình. Một cái gì đó như: nhập {ArraySortPipe} từ './../../shared/filters.pipe'; Trong 'app.module.ts' và bất kỳ mô-đun nào trong đó. put: tuyên bố: [ArraySortPipe]
Dudi

71

Vui lòng xem https://angular.io/guide/pipes#append-no-filterpipe-or-orderbypipe để có cuộc thảo luận đầy đủ. Trích dẫn này là phù hợp nhất. Về cơ bản, đối với các ứng dụng quy mô lớn cần được giảm thiểu mạnh mẽ, logic lọc và sắp xếp sẽ chuyển sang chính thành phần đó.

"Một số người trong chúng tôi có thể không quan tâm đến việc giảm thiểu điều này một cách mạnh mẽ. Đó là lựa chọn của chúng tôi. Nhưng sản phẩm Angular sẽ không ngăn cản người khác giảm thiểu một cách tích cực. Do đó, nhóm Angular đã quyết định rằng mọi thứ được vận chuyển trong Angular sẽ được giảm thiểu một cách an toàn.

Nhóm Angular và nhiều nhà phát triển Angular có kinh nghiệm khuyên bạn nên chuyển tính năng lọc và sắp xếp logic vào chính thành phần. Thành phần có thể hiển thị thuộc tính LọcHeroes hoặc SortedHeroes và kiểm soát thời gian và tần suất thực thi logic hỗ trợ. Bất kỳ khả năng nào bạn đã đặt trong một đường dẫn và chia sẻ trên ứng dụng đều có thể được viết trong một dịch vụ lọc / phân loại và được đưa vào thành phần. "


7
Bạn nên di chuyển logic "vào chính thành phần" theo cách có thể "kiểm soát khi nào và tần suất thực thi logic hỗ trợ" như thế nào? Có những ví dụ tốt về điều này để làm theo?
Mzzzzzz

1
@Mzzzzzz Nơi nó đề cập đến một thuộc tính như filteredHeroessortedHeroes, tôi nghĩ ý tưởng là trong khi khởi tạo thành phần, bạn sẽ chạy một số logic sắp xếp / lọc (có thể gọi một phương thức từ ngOnInit), sau đó đặt thuộc tính đó với các kết quả được sắp xếp / lọc và chỉ chạy lại logic / cập nhật thuộc tính nếu có thứ gì đó kích hoạt nhu cầu (ví dụ: tương tác người dùng kích hoạt lệnh gọi AJAX để có thêm anh hùng hoặc người dùng nhấp vào hộp kiểm để lọc một nửa trong số họ dựa trên một số tiêu chí, v.v.)
jmq

41

Bạn có thể triển khai một đường ống tùy chỉnh cho điều này để tận dụng sortphương thức của mảng:

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

Và sử dụng sau đó đường ống này như mô tả bên dưới. Đừng quên chỉ định đường ống của bạn vào pipesthuộc tính của thành phần:

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

Đó là một mẫu đơn giản cho mảng có giá trị chuỗi nhưng bạn có thể có một số xử lý sắp xếp nâng cao (dựa trên thuộc tính đối tượng trong trường hợp mảng đối tượng, dựa trên tham số sắp xếp, ...).

Đây là một plunkr cho việc này: https://plnkr.co/edit/WbzqDDOqN1oAhvqMkQRQ?p=preview .

Hy vọng nó sẽ giúp bạn, Thierry


1
Cảm ơn bạn đã trả lời, bạn có thể giải thích phương pháp sắp xếp?

1
Trong thực tế, sortphương thức là một phương thức của Arrayđối tượng JavaScript . Xem liên kết này: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
Thierry Templier

Được rồi, tôi hiểu rồi, nó sử dụng phương pháp sắp xếp javascript với một hàm so sánh làm đối số. cảm ơn bạn!

1
Thật không may, plunker không được dùng nữa. Thierry?

4
các pipes: [..]tuyên bố là không còn giá trị (và không còn cần thiết)
phil294

9

Đã cập nhật OrderByPipe: đã sửa lỗi không sắp xếp chuỗi.

tạo một lớp 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;
  }
}

trong bộ điều khiển của bạn:

@Component({
pipes: [OrderByPipe]
})

hoặc trong của bạn

 declarations: [OrderByPipe]

trong html của bạn:

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

ObjFieldName: tên trường đối tượng bạn muốn sắp xếp;

OrderByType: boolean; true: thứ tự giảm dần; false: tăng dần;


Đối với đối số chuỗi so sánh một [orderField] - b [orderField] trả về NaN
Piotr Pęczek

Đối với các đối số ngày, nó không hoạt động. Định dạng ngày dưới dạng văn bản sẽ được sắp xếp không chính xác.
Rafael Pizao

9

Angular không đi kèm với đơn đặt hàng Bằng cách lọc ra khỏi hộp, nhưng nếu chúng tôi quyết định cần một cái thì chúng tôi có thể dễ dàng tạo ra một cái. Tuy nhiên, có một số lưu ý mà chúng ta cần lưu ý đối với tốc độ và sự thu nhỏ. Xem bên dưới.

Một đường ống đơn giản sẽ trông giống như thế này.

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

Đường ống này chấp nhận một hàm sắp xếp ( fn) và cung cấp cho nó một giá trị mặc định sẽ sắp xếp một mảng nguyên thủy theo cách hợp lý. Chúng tôi có tùy chọn ghi đè chức năng sắp xếp này nếu chúng tôi muốn.

Nó không chấp nhận tên thuộc tính là một chuỗi, vì tên thuộc tính có thể được rút gọn. Chúng sẽ thay đổi khi chúng ta giảm thiểu mã của mình, nhưng các bộ thu nhỏ không đủ thông minh để giảm thiểu giá trị trong chuỗi mẫu.

Sắp xếp nguyên thủy (số và chuỗi)

Chúng tôi có thể sử dụng điều này để sắp xếp một mảng số hoặc chuỗi bằng cách sử dụng bộ so sánh mặc định:

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

Sắp xếp một mảng đối tượng

Nếu chúng ta muốn sắp xếp một mảng các đối tượng, chúng ta có thể cung cấp cho nó một hàm so sánh.

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

Lưu ý - đường ống tinh khiết và không tinh khiết

Angular 2 có một khái niệm về đường ống tinh khiết và không tinh khiết.

Một đường ống thuần túy tối ưu hóa việc phát hiện thay đổi bằng cách sử dụng nhận dạng đối tượng. Điều này có nghĩa là đường ống sẽ chỉ chạy nếu đối tượng đầu vào thay đổi danh tính, ví dụ: nếu chúng ta thêm một mục mới vào mảng. Nó sẽ không đi xuống thành các đối tượng. Điều này có nghĩa là nếu chúng ta thay đổi một thuộc tính lồng nhau: this.cats[2].name = "Fluffy"ví dụ: đường ống sẽ không chạy lại. Điều này giúp Angular nhanh chóng. Theo mặc định, ống góc là nguyên chất.

Mặt khác, một đường ống không tinh khiết sẽ kiểm tra các thuộc tính của đối tượng. Điều này có thể làm cho nó chậm hơn nhiều. Bởi vì nó không thể đảm bảo chức năng của đường ống sẽ làm gì (có lẽ nó sắp xếp khác nhau dựa trên thời gian trong ngày chẳng hạn), một đường ống không tinh khiết sẽ chạy mỗi khi sự kiện không đồng bộ xảy ra. Điều này sẽ làm chậm ứng dụng của bạn đáng kể nếu mảng lớn.

Đường ống trên là nguyên chất. Điều này có nghĩa là nó sẽ chỉ chạy khi các đối tượng trong mảng là bất biến. Nếu bạn thay đổi một con mèo, bạn phải thay thế toàn bộ đồ vật con mèo bằng một vật mới.

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

Chúng tôi có thể thay đổi ở trên thành một đường ống không tinh khiết bằng cách đặt thuộc tính 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)
  }
}

Đường ống này sẽ đi xuống các đối tượng, nhưng sẽ chậm hơn. Sử dụng cẩn thận.


Cảm ơn .. Đã giúp đỡ rất nhiều. Nhưng một câu hỏi .. Nếu chúng ta không nên sử dụng đường ống hoặc bộ lọc để phân loại, thì cách tiếp cận tốt nhất là gì? Tôi đã tìm kiếm khắp nơi, mọi người đều đưa ra giải pháp bằng cách tạo đường ống.
Pavan Shukla

@PavanShukla Bạn có thể sử dụng một đường ống, chỉ cần đảm bảo rằng các mục nhập mảng của bạn là bất biến và tạo một đường ống thuần túy. Hoặc, nếu bạn không có một mảng lớn, hãy tạo một đường ống không tinh khiết và sắp xếp từng kết xuất. Ngoài ra, hãy tạo một mảng được sắp xếp như một thuộc tính của thành phần của bạn và hiển thị nó.
siêu thường

Tôi đã sử dụng logic array.sort khi nhấp vào mỗi tiêu đề cloumn. Tôi đang thực hiện thao tác này trên mảng dữ liệu hiển thị .. có cách nào tốt không?
Pavan Shukla

7

Tôi đã tạo một đường dẫn OrderBy thực hiện những gì bạn cần. Nó cũng hỗ trợ khả năng sắp xếp trên nhiều cột của vô số đối tượng.

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

Đường ống này cho phép thêm nhiều mục hơn vào mảng sau khi hiển thị trang và sẽ sắp xếp mảng với các bản cập nhật động.

Tôi có một bài viết về quá trình ở đây .

Và đây là bản demo hoạt động: http://fuelinteractive.github.io/fuel-ui/#/pipe/orderbyhttps://plnkr.co/edit/DHLVc0?p=info


Bạn không xử lý giá trị null.
Ali Habibzadeh

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

Ngoài ra giá trị với giá trị tương đương là tăng vọt và di chuyển khi bạn nhấp vào xung quanh trong giao diện
Ali Habibzadeh

@XGreen cảm ơn vì điều này. Tôi sẽ bổ sung hỗ trợ cho các giá trị null / undefined trong bản cập nhật tiếp theo của fuel-ui. Đối với sự nhảy vọt của các giá trị bằng nhau, tôi không thấy điều này. Bạn đang dùng trình duyệt nào?
Cory Shaw

Phiên bản Chrome 50.0.2661.86 (64-bit), OSX El Capitan
Ali Habibzadeh

4

Đề nghị bạn sử dụng lodash với góc cạnh, sau đó đường ống của bạn sẽ là tiếp theo:

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

}

và sử dụng nó trong html như

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

và đừng quên thêm Pipe vào mô-đun của bạn

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

Tôi thích cách tiếp cận của bạn Александр Петрик nhưng tôi thích gửi mảng trên mẫu: orderBy: ['field1', 'field2'] Và sau đó gọi trên pipe: return _.sortBy (array, args);
Eric

1
Vấn đề của việc sử dụng _.sortBy là bạn không thể chỉ định thứ tự con cháu. Tôi thấy rằng bằng cách sử dụng _.orderBy bạn có thể chỉ định thứ tự tùy chỉnh cho mọi trường. tức là: _.orderBy (array, ['field1', 'field2'], ['asc', 'desc'])
Eric

3

Điều này sẽ hoạt động cho bất kỳ lĩnh vực nào bạn vượt qua nó. ( QUAN TRỌNG: Nó sẽ chỉ sắp xếp theo thứ tự bảng chữ cái nên nếu bạn vượt qua một ngày, nó sẽ sắp xếp nó dưới dạng bảng chữ cái chứ không phải ngày)

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

Bạn có thể đăng một ví dụ sử dụng?
TheUnreal

Tôi không thể biên dịch mã bạn đã cung cấp. Tôi nhận được một lỗi nói rằng @Componentkhông có pipestài sản.
Azimuth

3

Đây là sự thay thế tốt cho AngularJs orderby ống ở góc 4 . Dễ dàng và đơn giản sử dụng.

Đây là URL github để biết thêm thông tin 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

Như chúng ta biết bộ lọc và thứ tự theo đã bị xóa khỏi ANGULAR 2 và chúng ta cần phải viết riêng, đây là một ví dụ điển hình về plunkerbài viết chi tiết

Nó đã sử dụng cả bộ lọc cũng như orderby, đây là mã cho đường ống đặt hàng

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

Bạn có thể sử dụng điều này cho các đối tượng:

@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

Trong package.json, hãy thêm một cái gì đó như (Phiên bản này ổn cho Angular 2):

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

Trong mô-đun typecript của bạn (và mảng nhập khẩu):

  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
Cảm ơn bạn, câu trả lời tuyệt vời
AM - EVS

0

Trong phiên bản hiện tại của Angular2, các đường ống orderBy và ArraySort không được hỗ trợ. Bạn cần viết / sử dụng một số đường ống tùy chỉnh cho việc này.


0

Đối với Phiên bản Angular 5+, chúng ta có thể sử dụng gói ngx-order-pipe

Nguồn hướng dẫn liên kết

Cài đặt gói

$ npm install ngx-order-pipe --save

Nhập trong mô-đun ứng dụng

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

sử dụng mọi nơi

  <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;
  }
}
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.