json 数据操作 查找，重组，分组，排序，分页

代码

/**
 * 从json筛选数据
 * @fn 筛选条件
 */
function where(fn) {
    var $json = [];
    this.map(function(val, index){
        if (fn) {
            var t = fn(val, index);
            if (t == true) {
                $json.push(val);
            }
        }
    });
    return $json;
}

/**
 * 从json筛选数据 返回一条
 * @fn 筛选条件
 */
function Find(fn) {
    var $json =false;
    for (var i = 0; i < this.length; i++) {
        if (fn) {
            var t = fn(this[i]);
            if (t == true) {
                $json=this[i];
                break;
            }
        }
    }
    return $json;
}

/**
 * 从json筛选数据 返回一条
 * @key 字段
 * @val 值
 */
function FindKey(key,val) {
    var $json = false;
    for (var i = 0; i < this.length; i++) {
        if(this[i][key]==val){
            $json=this[i];
            break;
        }
    }
    return $json;
}

/**
 * 重新组装数据返回新的json数组
 * @$obj {*} $obj 
 */
function select(fn) {
    var $json = [];
    this.map(function (val, index) {
            if (fn) {
                var t = fn(val, index);
                if (t) {
                    $json.push(t);
                }
            }
        }
    );
    return $json;
}

/**
 *根据指定字段分组
 * @n 字段名称
 */
function GroupBy(n) {
    var list = [];
    var _t=this;
    for (var i = 0; i < this.length; i++) {
        var json_str = '{"' + n + '":"' + this[i][n] + '"}';
        if (list.length > 0) {
            var l = list.where2(JSON.parse(json_str));
            if (l.length == 0) {
                list.push(JSON.parse(json_str))
            }
        } else {
            list.push(JSON.parse(json_str))
        }
    }

    for (var i = 0; i < list.length; i++) {
        list[i].list = this.where(function (val) {
            if (val[n] == list[i][n]) {
                return true;
            }
            return false
        });
    }
    //console.log(list)
    return list;
}


/**
 * 排序
 * @_sort 排序字段
 * @by 排序方式，默认 asc
 */
function OrderBy(_sort,by){
    by=by||'asc'
    this.sort(function(a,b){
        if(typeof(a[_sort])=='number'||(!isNaN(a[_sort]))){
            if(by=='asc'){
                return Number(a[_sort])-Number(b[_sort]);
            }
            if(by=='desc'){
                return Number(b[_sort])-Number(a[_sort]);
            }
        }
        if(typeof(a[_sort])=='string'){
            if(by=='asc'){
                return a[_sort].localeCompare(b[_sort]);
            }
            if(by=='desc'){
                return b[_sort].localeCompare(a[_sort]);
            }
        }
    });
    return this;
}

/**
 * 将指定字段的值转化为数组
 * @_clo  字段名称
 */
function ToArray(_clo){
    if(!_clo){
        console.error('没有指定字段!');
        return [];
    }
    var arr=[];
    this.map(function(val,i){
        arr.push(val[_clo]);
    });
    return arr;
}

/**
 * 分页
 * @pageindex 页码
 * @pagesize 每页数据量 
 */
function limit(pageindex,pagesize){
    return this.skip((pageindex-1)*pagesize).take(pagesize);
}

/**
 * 返回连续的数据
 * @n 返回数据量
 */
function take(n){
    var list=[];
    if(n>this.length){
        n=n-(n-this.length);
    }
    for (var i = 0; i <n; i++) {
        list.push(this[i]);
    }
    return list;
}

/**
 * 跳过数据
 * @n 跳过数据量
 */
function skip(n){
    var list=[];
    if(n>this.length){
        n=this.length;
    }
    for(var i=n;i<this.length;i++){
        list.push(this[i]);
    }
    return list;
}


/**
 * 将指定列相加
 * @col 指定列
 * @spl 非数字时用来分割字符串，默认英文逗号
 */
function sum(col,spl=','){
    var count='';
    this.map(function(val){
        if(typeof(val[col])=='number'){
            count=Number(count);
            count+=Number(val[col]);
        }else{
            count+=val[col]+spl;
        }
    });
    return count;
}

Array.prototype.where=where;//根据条件查询
Array.prototype.select=select;//重组
Array.prototype.GroupBy=GroupBy;//分组
Array.prototype.OrderBy=OrderBy;//排序
Array.prototype.ToArray=ToArray;//将指定的指定转化为数组
Array.prototype.Find=Find;//根据条件查询一条
Array.prototype.FindKey=FindKey;//查找指定字段指定值的一条数据
Array.prototype.limit=limit;//分页
Array.prototype.take=take;//返回连续的数据
Array.prototype.skip=skip;//跳过数据
Array.prototype.sum=sum;//将指定列相加


/**
 * 判断字符串是否包含字符串 包含返回true 不包含返回false
 * @str 被包含的字符串
 */
function Contains(str){
    if(this.indexOf(str)>-1){
        return true;
    }
    return false;
}
String.prototype.Contains=Contains;//判断字符串是否包含字符串 

使用方法

json数据

var json=[
{"name":"Q蕠蕠","sex":"女","age":24},
{"name":"Q援","sex":"男","age":46},
{"name":"Q陹雭","sex":"男","age":35},
{"name":"Q黬","sex":"女","age":41},
{"name":"Q畺","sex":"女","age":26},
{"name":"Q湻","sex":"女","age":51},
{"name":"Q銃","sex":"男","age":37},
{"name":"Q沺","sex":"男","age":12},
{"name":"Q弈","sex":"男","age":28},
{"name":"Q鱣鱣","sex":"女","age":31},
{"name":"Q卼","sex":"男","age":3},
{"name":"Q皽廘","sex":"女","age":21},
{"name":"Q锱閸","sex":"男","age":40},
{"name":"Q败败","sex":"男","age":56},
{"name":"Q幇換","sex":"男","age":40},
{"name":"Q罢","sex":"女","age":28},
{"name":"Q癧黉","sex":"女","age":63},
{"name":"Q孖俒","sex":"女","age":26},
{"name":"Q耤耤","sex":"女","age":5},
{"name":"Q猢","sex":"女","age":31}
]

where 筛选数据

// age>20
var new_json=json.where(function(val){
	return val.age>20;
});
console.log(new_json)

Find/FindKey 筛选数据 返回一条

//name=Q蕠蕠
var new_json = json.Find(function (val) {
	return val.name=='Q蕠蕠';
});
console.log(new_json)

var new_json = json.FindKey('name','Q蕠蕠');
console.log(new_json)

select 重组数据（仿C# select）

var new_json = json.select(function(val){
	return {
		a:val.name,
		b:val.age
	}
});
console.log(new_json)

GroupBy 根据指定字段分组

var new_json = json.GroupBy("sex");
console.log(new_json)

OrderBy 根据指定字段排序

var new_json = json.OrderBy("age");
console.log(new_json)

ToArray 将指定字段的值转化为数组

var new_json = json.ToArray("age");
console.log(new_json)

limit 分页

var new_json = json.limit(1,5);
console.log(new_json)

sum 将指定列相加

var new_json = json.sum('age');
console.log(new_json)