underscorejs之_.filter(list, predicate, [context])

语法:

_.filter(list, predicate, [context])

说明:

对list集合的每个成员依次进行匹配(根据predicate迭代函数检测),返回匹配成功的集合

  • list可以为数组,对象,字符串和arguments
  • predicate会传第三个参数value, key, list(参数名可自定义)
  • predicate函数需要返回值
  • context可以改变predicate函数内部的this

代码示例:

示例一:filter对数组,对象,字符串,arguments进行操作并返回匹配成功的数据

var result;

// 操作数组
result = _.filter([1, 2, 3], function (value) {
    return value % 2 === 1;
});
console.log(result) //=> [1, 3]

// 操作对象
result = _.filter({ one: ‘一‘, two: ‘二‘, three: ‘三‘, num: 123, bool: false }, function (value) {
    return typeof value === "string";
});
console.log(result) //=> ["一", "二", "三"]

// 操作复杂的对象
var obj = {
    levelA: {
        level0: ‘level0‘,
        level1: ‘level1‘
    },
    levelB: ‘一‘,
    levelC: 1,
    levelD: {
        level3: ‘level3‘
    }
}
result = _.filter(obj, function (value) {
    return typeof value === "object";
});
console.log(result) //=> [{level0: "level0", level1: "level1", {level3: ‘level3‘}}]

// 操作字符串(此处将字符拆分为数组)
result = _.filter(‘123‘, function (value) {
    return value === ‘2‘ || value === ‘3‘;
});
console.log(result) //=> ["2", "3"]

//操作arguments
function abc() {
    result = _.filter(arguments, function (value) {
        return value % 2 === 1;
    });
    console.log(result); //=> [1, 3]
}
abc(1, 2, 3);

示例二:predicate函数传递的参数(函数内部需要return返回值,否则返回[])

var result;

//数组的情况
result = _.filter([1, 2, 3], function (value, key, list) {
    console.log(value, key, list);
    //=> 1 0 [1, 2, 3]
    //=> 2 1 [1, 2, 3]
    //=> 3 2 [1, 2, 3]
});
console.log(result) //=> []

//对象的情况
result = _.filter({one: ‘一‘, two: ‘二‘, three: ‘三‘}, function(value, key, list){
    console.log(value, key, list);
    //=> 一 one Object {one: "一", two: "二", three: "三"}
    //=> 二 two Object {one: "一", two: "二", three: "三"}
    //=> 三 three Object {one: "一", two: "二", three: "三"}
});
console.log(result) //=> []

示例三:context可以改变predicate内部的this

var result;

// 数组的情况
result = _.filter([1, 2, 3], function (value, key, list) {
    console.log(this); //=> [1, 2, 3] this是数组
}, [1, 2, 3]);

// 对象的情况
result = _.filter([1, 2, 3], function (value, key, list) {
    console.log(this); //=> Object {no: 10} this是对象
}, { "no": 10 });

// 字符串的情况
result = _.filter([1, 2, 3], function (value, key, list) {
    console.log(this); //=> String {0: "1", 1: "2", 2: "3", length: 3, [[PrimitiveValue]]: "123"}
                       //   this是将字符串拆分后的对象
}, "123");

_.select的功能和_.filter是一样的

var result = _.filter([1, 2, 3], function (value, key, list) {
    return value % 2 === 1;
});
console.log(result) //=> [1, 3]

特殊情况

示例一:list的特殊情况

//例如:null,undefined,0,true,this等;
var result = _.filter(null, function (value, key, list) {
    return true;
});
console.log(result) //=> []

示例二:predicate函数的this为window全局对象的情况

// 例如:null,undefined,window,this等
var result = _.filter([1, 2, 3], function (value, key, list) {
    console.log(this); //=> this是window全局对象
}, null);

list参数可为真假值?

var  result = _.filter([1, true, ‘1‘, 0, undefined, null]);
console.log(result) //=> [1, true, "1"]

predicate还有其他写法?

示例一:predicate参数为空的时候

var  result = _.filter({x: 1, y: 2});
console.log(result) //=> [1, 2]

示例二:predicate参数为一个字符的时候

var  result = _.filter([{x: 1}, {y: 2}], ‘x‘);
console.log(result) //=> [{x: 1}]

示例三:predicate参数为对象的时候

var obj = [
    {x: 1, y: 2},
    {x: 1},
    {y: 2, z: 3}
]
var  result = _.filter(obj, {x: 1});
console.log(result) //=> [{x: 1, y: 2},{x: 1}]
时间: 2024-10-16 20:38:58

underscorejs之_.filter(list, predicate, [context])的相关文章

underscorejs之_.find(list, predicate, [context])

语法: _.find(list, predicate, [context]) 说明: 对list集合的每个成员依次进行匹配(根据predicate迭代函数检测),匹配成功则立即返回当前成员 list可以为数组,对象,字符串和arguments predicate会传第三个参数value, key, list(参数名可自定义) predicate函数需要返回值 context可以改变predicate函数内部的this 代码示例: 示例一:find对数组,对象,字符串,arguments进行操作并

underscorejs之_.countBy(list, iteratee, [context])

语法 _.countBy(list, iteratee, [context]) 说明 排序一个列表组成一个组,并且返回各组中的对象的数量的计数.类似groupBy,但是不是返回列表的值,而是返回在该组中值的数目.就像EXCEL里的分类统计 list为 遍历的集合,如数组.对象.字符串.arguments等. iteratee 迭代器,可以是一个function也可以字符串等. iteratee 有三个参数 (element, index, list) iteratee 需要有返回 context

underscorejs之 _.indexBy(list, iteratee, [context])

语法 _.indexBy(list, iteratee, [context]) 说明 给定一个list,和 一个用来返回一个在列表中的每个元素键 的iterator 函数(或属性名), 返回一个每一项索引的对象.和groupBy非常像,但是当你知道list的key是唯一的时候可以使用indexBy**. 什么时候用_.indexBy? api都会给我们返回类似下面这样子的数据,现在我们要写一个方法.传入id,返回相对应的name或是其他. var data = [{ id: 1, name: '

underscorejs之_.map(list, iteratee, [context])

语法: _.map(list, iteratee, [context]) 说明: 对集合的每个成员依次进行某种操作,将返回的值依次存入一个新的数组.接收3个参数.list可理解为数据源iteratee迭代器可理解为回调方法;context执行上下文. list可以操作数组,对象,字符串和arguments iteratee 会传第三个参数(element, index, list)或(value, key, list) iteratee里面需要返回值. context可以改变iteratee内部

underscorejs类库之_.each(list, iteratee, [context])

语法: _.each(list, iteratee, [context]) 说明: 依次对集合的所有元素进行某种操作,原样返回list.接收3个参数,list集合可以理解为数据源:iteratee即迭代器可以理解为回调方法;context执行上下文. list可以为数组,对象,字符串和arguments iteratee 会传第三个参数(element, index, list)或(value, key, list) context可以改变iteratee内部的this 示例一:each可以循环

[Javascript] Lodash: Refactoring Simple For Loops (_.find, _.findLast, _.filter)

This lesson shows how to refactor your old loops into using a simpler and more powerful lodash-style. We will start by looking at how many people traditionally write JavaScript for loops and then talk about the alternate style and benefits that Lodas

浅谈 Underscorejs中 _.throttle 和 _.debounce 的差异和使用场景

通常的函数(或方法)调用过程分为三个部分:请求.执行和响应.(文中"请求"与"调用"同义,"响应"与"返回"同义,为了更好的表述,刻意采用请求和响应的说法.) 某些场景下,比如响应鼠标移动或者窗口大小调整的事件,触发频率比较高.若稍处理函数微复杂,需要较多的运算执行时间,响应速度跟不上触发频率,往往会出现延迟,导致假死或者卡顿感. 在运算资源不够的时候,最直观的解决办法就是升级硬件,诚然通过购买更好的硬件可以解决部分问题,但是

underscorejs之_.contains(list, item, fromIndex, guard)

语法: _.contains(list, item, fromIndex, guard) 说明: list集合包含指定的值则返回true,否则返回false list可以为数组,对象,字符串和arguments item是一个参数(contains会处理list中是否包含此参数),可以为数字,字符串 fromIndex是一个数字,根据此索引决定list开始检索的位置,可为正值,也可为负值:(负值不是真正的负值,而是list的倒数,下面会详细讲解):若非数字则fromIndex的索引从0开始 代码

Underscore.js find filter reject where where

_.find(); _.find(list, predicate, [context]); 在list中逐项查找,返回第一个通过predicate迭代函数真值检测的元素值.找到匹配元素立即返回,不会遍历整个list _.filter() _.filter(list, predicate, [context]); 遍历数组中的每个值,返回包含predicate迭代函数真值得所有元素值; _.reject(); _.reject(list, predicate, [context]); 返回list