精华内容
下载资源
问答
  • js,根据一个数组,遍历对象数组,进行条件并列的筛选或过滤1. 筛选是否2. 筛选特定值 条件并列:某一条数据的两以上的属性,同时满足筛选条件 1. 筛选是否 业务场景:返回一个对象数组,在UI界面勾选了...

    js,根据一个数组,遍历对象数组,进行多条件并列的筛选或过滤

    多条件并列:某一条数据的两个以上的属性,同时满足筛选条件

    1. 筛选是否

    业务场景:返回一个对象数组,在UI界面勾选了checkbox,则对整个列表进行“是/否”的并列筛选

    let list = [
      {a:0, b:1, c:0},
      {a:1, b:1, c:null},    // 筛选出这一条数据
      {a:1, b:0, c:null},
    ]
    let filters = ["a", "b"];
    let filterList = list.filter((item) => {
      // 遍历list,每个item都要检查a、b字段值是否等于1
      let isShow = filters.every((prop) => {
        return item.hasOwnProperty(prop) && item[prop] == 1
      })
      // isShow=true,表示通过筛选;isShow=false,表示不符合筛选条件(也就是 a!=1 或者 b!=1)
      return isShow;
    })
    console.log(filterList)    // 筛选结果 filterList = [{a:1, b:1, c:null}]
    

    效果
    在这里插入图片描述

    2. 筛选特定值

    根据filters的特定值进行筛选,修改一下filters的数据形式:

    let list = [
      {age:"通过", gender:"女", name:"Ada"},
      {age:"不通过", gender:"女", name:"Lily"},
      {age:"通过", gender:"男", name:"John"},
    ]
    let filters = [
      {age:"通过"},
      {gender:"女"},
    ];
    let filterList = list.filter((item) => {
      let isShow = filters.every((prop) => {
        let key = Object.keys(prop)[0];
        let value = prop[key];
        return item.hasOwnProperty(key) && item[key] == value;
      })
      return isShow;
    })
    console.log(filterList)    // 筛选结果 filterList = [{age:"通过", gender:"女", name:"Ada"}]
    

    效果
    在这里插入图片描述

    注:不想进行并列筛选,可以将every函数转为some函数,满足filters其中一个条件即可。

    展开全文
  • 1、两对象数组中,筛选出不相等的对象 this.dataSource 是原始的数据源,总数组 this.selectedRows 是表格选择后带对象数组 constnewDataSource=this.dataSource.filter((item,index)=>{ returnJSON....

    1、两个带对象的数组中,筛选出不相等的对象

    this.dataSource 是原始的数据源,总数组

    this.selectedRows 是表格选择后带对象的数组

    const newDataSource = this.dataSource.filter((item, index) => {

         return JSON.stringify(item).indexOf(JSON.stringify(this.selectedRows[index])) == -1 })

    2、带对象的数组去重

      const object = {}

       const newobject = this.serialOk.filter(item => (object[item.serialno] ? ' ' : (object[item.serialno] = true)))

    3、纯数组去重

        const newArr = [...new Set(arr)]

    展开全文
  • 根据一个或者多个属性对数组进行排序,支持嵌套的属性。而且可以在每个条件中指定排序的方向,并支持传入比较函数。 安装 采用 npm 安装: $ npm install --save arr-sort 采用 yarn 安装: $ yarn add arr-sort 用法 ...
        

    arr-sort GitHub license NPM version NPM monthly downloads NPM total downloads Windows Build Status

    根据一个或者多个属性对数组进行排序,支持嵌套的属性。而且可以在每个条件中指定排序的方向,并支持传入比较函数。

    安装

    采用 npm 安装:

    $ npm install --save arr-sort

    采用 yarn 安装:

    $ yarn add arr-sort

    用法

    通过给定的对象属性进行排序:

    var arrSort = require('arr-sort');
    
    arrSort([{foo: 'y'}, {foo: 'z'}, {foo: 'x'}],[{attr:'foo'}]);
    //=> [{foo: 'x'}, {foo: 'y'}, {foo: 'z'}]

    逆向排序

    arrSort([{foo: 'y'}, {foo: 'z'}, {foo: 'x'}],[{attr:'foo', asc: false}]);
    //=> [{foo: 'z'}, {foo: 'y'}, {foo: 'x'}]

    参数

    arrSort(array, comparisonArgs);
    • array: { Object Array } 待排序的数组
    • comparisonArgs: { Object Array } 一个或者多个对象组成的数组。 结构如下:{ 'attr': attr, 'asc': asc }

      • attr: { String } 对象属性
      • asc: { Boolean | Function } 指定排序的方向

        • true: 升序(默认值)
        • false: 降序
        • function: 传入的比较函数

    注意

    • 如何没有提供 attr 属性, 则这次的排序会自动跳过
    • attr 属性值类型可以是 string 或者 number

      • 如果是 string, 我们采用 localeCompare 去比较排序
      • 如果是 number, 我们直接比较值的大小
    • 如果提供的比较函数没有返回值,则这次的排序会自动跳过

    例子

    1. 多重条件排序

    var arrSort = require('arr-sort');
    
    var array = [
      { foo: 'bbb', num: 4,  flag: 2 },
      { foo: 'aaa', num: 3,  flag: 1 },
      { foo: 'ccc', num: -6, flag: 2 },
      { foo: 'ccc', num: 8,  flag: 2 },
      { foo: 'bbb', num: 2,  flag: 4 },
      { foo: 'aaa', num: -3, flag: 4 }
    ];
    
    // sort by `flag`, then `foo`, then `num`
    var result = arrSort(array,
        [{
            attr: 'flag',
            asc: true
        },
        {
            attr: 'foo',
            asc: false
        },
        {
            attr: 'num',
            asc: true
        }]
    );
    
    console.log(result);
    // [ { foo: 'aaa', num: 3,  flag: 1},
    //   { foo: 'ccc', num: -6, flag: 2},
    //   { foo: 'ccc', num: 8,  flag: 2},
    //   { foo: 'bbb', num: 4,  flag: 2},
    //   { foo: 'bbb', num: 2,  flag: 4},
    //   { foo: 'aaa', num: -3, flag: 4} ]

    2. 嵌套的属性排序

    var arrSort = require('arr-sort');
    
    var array = [
      { locals: { foo: 'bbb', num: 4 },  flag: 2},
      { locals: { foo: 'aaa', num: 3 },  flag: 1},
      { locals: { foo: 'ccc', num: -6 }, flag: 2},
      { locals: { foo: 'ccc', num: 8 },  flag: 2},
      { locals: { foo: 'bbb', num: 2 },  flag: 4},
      { locals: { foo: 'aaa', num: -3 }, flag: 4},
    ];
    
    // sort by `flag`, then `locals.foo`, then `locals.num`
    var result = arrSort(array,
        [{
            attr: 'flag',
            asc: true
        },
        {
            attr: 'locals.foo',
            asc: false
        },
        {
            attr: 'locals.num',
            asc: true
        }]
    );
    
    console.log(result);
    // [ { locals: { foo: 'aaa', num: 3 },  flag: 1},
    //   { locals: { foo: 'ccc', num: -6 }, flag: 2},
    //   { locals: { foo: 'ccc', num: 8 },  flag: 2},
    //   { locals: { foo: 'bbb', num: 4 },  flag: 2},
    //   { locals: { foo: 'bbb', num: 2 },  flag: 4},
    //   { locals: { foo: 'aaa', num: -3 }, flag: 4} ]

    3. 传入比较函数排序

    如果提供了比较函数,数组会根据其返回值排序。比较函数具体可以参考docs

    var arrSort = require('arr-sort');
    
    var array = [
      { locals: { foo: 'bbb', num: 4 },  flag: -2},
      { locals: { foo: 'aaa', num: 3 },  flag: 1},
      { locals: { foo: 'ccc', num: -6 }, flag: 2},
      { locals: { foo: 'ccc', num: 8 },  flag: 2},
      { locals: { foo: 'bbb', num: 2 },  flag: 4},
      { locals: { foo: 'aaa', num: -3 }, flag: 4},
    ];
    
    // sort by `flag`, then `locals.foo`, then `locals.num`
    var result = arrSort(array,
        [{
            attr: 'flag',
            asc: function(a,b){return (Math.abs(a) - Math.abs(b))}
        },
        {
            attr: 'locals.foo',
            asc: false
        },
        {
            attr: 'locals.num',
            asc: true
        }]
    );
    
    console.log(result);
    // [ { locals: { foo: 'aaa', num: 3 },  flag: 1},
    //   { locals: { foo: 'ccc', num: -6 }, flag: 2},
    //   { locals: { foo: 'ccc', num: 8 },  flag: 2},
    //   { locals: { foo: 'bbb', num: 4 },  flag: -2},
    //   { locals: { foo: 'bbb', num: 2 },  flag: 4},
    //   { locals: { foo: 'aaa', num: -3 }, flag: 4} ]

    关于

    相关项目

    集成测试

    跑集成测试是一个非常好的熟悉一个项目及其API的方法。你可以通过以下命令安装依赖并跑测试:

    $ npm install && npm test

    作者

    tywei90

    许可证

    Copyright © 2018, tywei90.
    Released under the MIT License.

    展开全文
  • push、unshift、shift、pop的区别。...选择数组的子元素(对象)的一个(多个属性 合并两个数组,生成新的数组数组中的元素进行分组 删除数组中指定的元素或不合法的值(undefined, null, '') 清空数组中的元素

    Array


    定义:数组对象是使用单独的变量名来存储一系列的值。


    一、创建数组


    字面方式
    var myCars = ['Audi', 'Benz', 'BMW']
    
    常规方式
    var myCars = new Array()
    myCars[0] = 'Audi'
    myCars[1] = 'Benz'
    myCars[2] = 'BMW'
    
    简洁方式
    var myCars = new Array('Audi', 'Benz', 'BMW')
    

    二、常用属性


    属性 描述
    length 设置或返回数组元素的个数。
    prototype 允许你向数组对象添加属性或方法。
    constructor 返回创建数组对象的原型函数。

    三、常用方法


    方法 描述
    push() 向数组的末尾添加一个或更多元素,并返回新的长度。
    unshift() 向数组的开头添加一个或更多元素,并返回新的长度。
    shift() 删除并返回数组的第一个元素。
    pop() 删除并返回数组的最后一个元素。
    splice(index,howmany,itemX) 从数组中添加或删除元素。
    slice(start, end) 返回一个新的数组,包含从 start 到 end (不包括该元素)的数组中的元素。
    join() 连接数组,返回字符串。
    reverse() 反转数组的元素顺序。
    sort(sortby) 对数组的元素进行排序。如果不传参数则按照字符编码的顺序
    forEach(function(item, index){}) 调用数组的每个元素,并将元素传递给回调函数。(不能break
    filter(function(item, index){ return *** }) 返回一个新的数组,新数组中的元素是 return true 的所有元素。不会改变原始数组

    四、伪数组(类数组)


    定义:无法直接调用数组方法或期望length属性有什么特殊的行为,但仍可以对真正数组遍历方法来遍历它们。

    • 函数的 argument 参数;
    • 调用 getElementsByTagNamedocumentchildNodes 之类的,它们都返回 NodeList 对象都属于伪数组。

    如何将伪数组数组转化为真正的Array对象

    Array.prototype.slice.call(fakeArray)
    

    五、array 数组方法封装


    u.array = {};
    

    检索数组(子元素为数组、对象、字符串等)
    /**
     * @description 检索数组(子元素为数组、对象、字符串等)
     * @param {Array} source [''] [[]] [{}]
     * @param {*} searchElement 当子元素为对象时,只用匹配该对象的某一个(几个)属性即可
     * @return {Number} 索引 或 -1
     */
    u.array.indexOf = function(source, searchElement) {
        var index = -1
        // 子元素为对象
        if (u.isObject(searchElement)) {
            u.forEach(source, function(i, item) {
                var isHas = true
                u.forEach(searchElement, function(searchKey, searchValue) {
                    if (item[searchKey]) {
                        if (!u.equal(item[searchKey], searchValue)) {
                            isHas = false
                            return false
                        }
                    }
                    else {
                        isHas = false
                    }
                })
                if (isHas) {
                    index = i
                    return false
                }
            })
            return index
        }
        // 子元素为数组
        if (u.isArray(searchElement)) {
            u.forEach(source, function(i, item) {
                if (u.equal(item, searchElement)) {
                    index = i
                    return false
                }
            })
            return index
        }
        // 子元素为字符串
        else {
            return source.indexOf(searchElement)
        }
    }
    
    向数组的末尾添加一个或多个元素,并返回新的长度
    /**
     *@description 向数组的末尾添加一个或多个元素,并返回新的长度
     * @param {Array} target 目标数组
     * @param {Array} array 要添加的数组
     * @return {Number} 新数组的长度
     */
    u.array.push = function(target, array) {
        if (u.isEmpty(array)) return
        if (!u.isArray(array)) array = [array]
        return Array.prototype.push.apply(target, array)
    }
    
    对数组排序
    /**
     * @description 对数组排序
     * @param {Array} array 源数组 [{}]
     * @param {String} sortKey 排序字段
     * @param {String} order 排序方式,asc升序,desc降序,默认为升序
     * @return {Array} 排序后的新数组
     */
    u.array.sort = function(array, sortKey, order) {
        if (u.isEmpty(array)) return []
        var ret = array.concat([])
        order = order || 'asc'
        ret.sort(function(a, b) {
            var aVal = a[sortKey]
            var bVal = b[sortKey]
            if (aVal > bVal) return order === 'asc' ? 1 : -1
            else if (aVal < bVal) return order === 'asc' ? -1 : 1
            return 0
        })
        return ret
    }
    
    数组去重(子元素为数组、对象、字符串等)
    /**
     * @description 数组去重(子元素为数组、对象、字符串等)
     * @param {Array} array [''] [[]] [{}]
     * @param {String Array} keys 根据属性去重(针对子元素是对象时)
     * @param {Boolean} ignoreSort 是否忽略排序(针对子元素是数组时)
     * @return {Array}
     */
    u.array.unique = function(array, keys, ignoreSort) {
        var ret = []
        u.forEach(array, function(i, item) {
            if (keys && u.isObject(item)) { // 根据属性去重,去掉排在末位的对象
                if (!u.isArray(keys)) keys = [keys]
                var searchObj = {}
                u.forEach(keys, function(i, selectKey) {
                    searchObj[selectKey] = item[selectKey]
                })
                if (u.array.indexOf(ret, searchObj) === -1) ret.push(item)
            }
            else if (ignoreSort && u.isArray(item)) {
                if (u.array.indexOf(ret, item.sort()) === -1) ret.push(item)
            }
            else {
                if (u.array.indexOf(ret, item) === -1) ret.push(item)
            }
        })
        return ret
    }
    
    筛选出符合条件的数组,生成新的数组
    /**
     * @description 筛选出符合条件的数组,生成新的数组
     * @param {Array} source 原数组 [{}]
     * @param {Object} filterProperty 条件对象 { status: ['1','2'] }
     * @param {Boolean} getDeleteData 是否返回被过滤掉的数组,默认false
     * @return {Array} 符合条件的数据 或 不符合条件的数据
     */
    u.array.filter = function(source, filterProperty, getDeleteData) {
        if (u.isEmpty(source) || u.isEmpty(filterProperty)) return []
    
        var ret = []
        var retByDelete = []
        u.forEach(source, function(i, item) {
            var equal = true
            u.forEach(filterProperty, function(filterKey, filterValue) {
                var itemValue = item[filterKey]
                if (!u.isArray(filterValue)) filterValue = [filterValue]
                if (filterValue.indexOf(itemValue) === -1) {
                    equal = false
                    return false
                }
            })
            if (equal) ret.push(item)
            else retByDelete.push(item)
        })
        if (getDeleteData) return retByDelete
        return ret
    }
    
    选择数组的子元素(对象)的一个(多个)属性
    /**
     * @description 选择数组的子元素(对象)的一个(多个)属性
     * @param {Array} source 源数组 [{}]
     * @param {String Array} keys 属性(集合)
     * @return {Array} 新数组 [''] 或 [{}]
     */
    u.array.select = function(source, keys) {
        if (u.isEmpty(source) || u.isEmpty(keys)) return source
    
        var ret = []
        u.forEach(source, function(i, item) {
            if (u.isArray(keys)) {
                var obj = {}
                u.forEach(keys, function(j, key) {
                    obj[key] = u.object.getValue(item, key)
                })
                ret.push(obj)
            }
            else {
                ret.push(u.object.getValue(item, keys))
            }
        })
        return ret
    }
    
    合并两个数组,生成新的数组
    /**
     * @description 合并两个数组,生成新的数组
     * @param {Array} source 原数组
     * @param {Array} array 待合并的数组
     * @param {String Array} keys 根据属性去重(针对子元素是对象时)
     * @param {Boolean} ignoreSort 是否忽略排序(针对子元素是数组时)
     * @return {Object}
     */
    u.array.concat = function(source, array, keys, ignoreSort) {
        if (u.isEmpty(source)) return array
        if (u.isEmpty(array)) return source
    
        var ret = []
        ret = source.concat(array)
        ret = u.array.unique(ret, keys, ignoreSort)
        return ret
    }
    
    对数组中的元素进行分组
    /**
     * @description 对数组中的元素进行分组
     * @param {Array} array 数组
     * @param {Array} fields 分组的依据字段
     * @return {Array} 分组后的新数组
     */
    u.array.group = function(array, fields) {
        if (u.isEmpty(array) || u.isEmpty(fields)) return null
    
        var ret = []
        u.forEach(array, function(i, item) {
            if (!u.isArray(fields)) fields = [fields]
    
            var itemGroup = {}
            u.forEach(fields, function(i, field) {
                itemGroup[field] = item[field]
            })
            var index = u.array.indexOf(ret, itemGroup)
            if (index === -1) {
                itemGroup.group = []
                itemGroup.group.push(item)
                ret.push(itemGroup)
            }
            else {
                ret[index].group.push(item)
            }
        })
        return ret
    }
    
    删除数组中 指定的元素 或 不合法的值(undefined, null, ‘’)
    /**
     * @description 删除数组中 指定的元素 或 不合法的值(undefined, null, '')
     * @param {Array} source 原数组
     * @param {*} values 被删除的元素集合,不传则删除不合法的值
     */
    u.array.remove = function(array, values) {
        if (u.isEmpty(array)) return []
        // 删除不合法的值
        if (u.isEmpty(values)) {
            var i = array.length
            while (i--) {
                var item = array[i]
                if (item === null || item === undefined || item === '') {
                    array.splice(i, 1)
                }
            }
        }
        // 删除指定的元素
        else {
            if (!u.isArray(values)) values = [values]
            u.forEach(values, function(i, value) {
                var index = u.array.indexOf(array, value)
                if (index > -1) array.splice(index, 1)
            })
        }
    }
    
    清空数组中的元素
    /**
     * @description 清空数组中的元素
     * @param {Array} array 源数组
     */
    u.array.clear = function(array) {
        if (u.isEmpty(array)) return
    
        array.splice(0, array.length)
    }
    

    下载

    npm i sg-utils -S
    

    GitHub地址(记得给星哦)

    https://github.com/shiguang0116/sg-utils


    系列文章

    JavaScript工具类(一):util.js创建及上传
    JavaScript工具类(二):cookie缓存
    JavaScript工具类(三):localStorage本地储存
    JavaScript工具类(四):数据类型
    JavaScript工具类(五):string字符串
    JavaScript工具类(六):number数字
    JavaScript工具类(七):array数组
    JavaScript工具类(八):object对象
    JavaScript工具类(九):date日期
    JavaScript工具类(十):base64编码、解码
    JavaScript工具类(十一):浏览器、移动端类型
    JavaScript工具类(十二):validate表单验证
    JavaScript工具类(十三):url路径处理
    JavaScript工具类(十四):json数据格式
    JavaScript工具类:util.js用法实例


    展开全文
  • pick: 筛选key属性对象 el: const object= {a:1,b:2,c:3} const newobject = _.pick(object,'a','b') 得到 newobject打印结果 {a:1,b:2} omit:排除key属性对象 el: const object= {a:1,b:2,c:3} ...
  • 除实现了接口原有的方法成员外,其本身也定义多个专门的方法成员,例如新增、移除、在指定位置插入元素或是返回特定元素在集合中所在的位置索引,这些方法主要为集合对象提供类似数组的元素访问功能。 ILsit接口...
  • 在要筛选的标签中加:filters属性,它由一个或多个包含text、value值的对象组成的数组。tableStatus: [{ text: '异常', value: '异常' },{ text: '正常', value: '正常' },{ text: '请假', value: '请假' },{ text...
  • 在序列化的过程中,被序列化的每个属性都会经过该函数的转换和处理 --- 筛选 举例: 2. 数组: 只有包含在这个数组中的属性名才会被序列化 可以明显的看到:在序列化的时候只是将其中的属性值是one进行序列化 ...
  • 1.业务场景:数据结构是数组里面是多个数组,三级是多个对象,需要实现类似淘宝商品筛选的时候属性大于3行显示全部折叠按钮,控制展开还是上合 2.这时候需要一个字段去控制true/false,来实现展开还是上合 3.实现 ...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • 6.4.6 筛选运算符 223 6.4.7 生成运算符 223 6.4.8 分组运算符 224 6.4.9 联接运算符 224 6.4.10 分区运算符 225 6.4.11 量词运算符 226 6.4.12 集合运算符 226 6.4.13 排序运算符 227 6.5 泛型预览 228 第...
  • VBSCRIP5 -ASP用法详解

    2010-09-23 17:15:46
    ExecuteGlobal 语句 执行一个或多个在全局脚本名字空间中所指定的语句。 Exit 语句 退出 Do...Loop、For...Next、 Function 或 Sub 代码块。 Exp 函数 返回 e (自然对数的底)的多少次方。 自乘运算符 (^) 指数...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 157
精华内容 62
关键字:

数组对象多个属性筛选