angular2 table pipe ---orderby

import {Pipe, PipeTransform} from "@angular/core";
@Pipe({
    name: 'orderBy'
})

export class OrderByPipe implements PipeTransform {

    transform(input:any, [config = "+"]): any {
        // if (!Array.isArray(value)) return value; //value 不是array，因此不能sort
        if (!Array.isArray(config) || Array.isArray(config) && config.length == 1) {
            //单一属性进行排序
            var propertyToCheck:string = !Array.isArray(config) ? config : config[0];
            var desc = propertyToCheck.substr(0, 1) == '-'; //得到一个boolean值
            if (!propertyToCheck || propertyToCheck == '-' || propertyToCheck == '+') {
                //是个简单数组，可以根据数组对象进行排序，sort  reverse 都是js原生代码
                return !desc ? input.sort() : input.sort().reverse();
            }
            else {
                //是个复杂数组，只对其中一个属性进行排序
                var property:string = propertyToCheck.substr(0,1) == "+" || propertyToCheck.substr(0,1) == "-"
                                        ? propertyToCheck.substr(1)
                                        : propertyToCheck;
                return input.sort(function (a:any, b:any) {
                    //需要在这里使用比较器
                    return !desc ? OrderByPipe._orderByComparator(a[property],b[property])
                                    : -OrderByPipe._orderByComparator(a[property],b[property]);
                });
            }
        }
        else {
            //是个复杂数组，对多个属性进行排序
            return input.sort(function (a:any, b:any) {
                for (var i = 0; i < config.length; i++) {
                    var desc = config[i].substr(0,1) == "-";
                    var property:string = config[i].substr(0,1) == "+" || config[i].substr(0,1) == "-"
                                            ? config[i].substr(1)
                                            : config[i];
                    var comparison = !desc ? OrderByPipe._orderByComparator(a[property],b[property])
                                        : -OrderByPipe._orderByComparator(a[property],b[property]);
                    if (comparison != 0) return comparison;
                }
                return 0;
            });
        }
    }

    static _orderByComparator(a:any, b:any):number {
        //isFinite() 函数用于检查其参数是否是无穷大
        if ((isNaN(parseFloat(a)) || !isFinite(a)) || (isNaN(parseFloat(b)) || !isFinite(b))) {
            //判断条件：如果a是数字，则parseFloat(a)会报错，判断条件会直接跳到else
            //如果a是string，且是数字开头，比如1212a，这样的可以转换为数字1212，a会被忽略，如果以字母开头则会报错NaN，比如a1212
            if (a.toLowerCase() > b.toLowerCase()) return 1; //说明a 的首字母比b的首字母要大，字母相比，比的是26个字母的顺序，顺序越往后表示越大
            if (a.toLowerCase() < b.toLowerCase()) return -1; //要注意，大写的A比小写的z要大，所以要转换成小写字母
        }
        else {
            if (parseFloat(a) > parseFloat(b)) return 1;
            if (parseFloat(a) < parseFloat(b)) return -1;
        }
        return 0; //等于0则相等
    }

}

转载于:https://my.oschina.net/u/2499632/blog/776336