lodash 学习记录

菜鸟一枚 学习lodash 把自己觉得常用的方法记录下来

 // 数组方法
 // 数组对象交集
   {
	    let data = [
	        {nameList: [{ category: '心累'}]},
	        {nameList: [{ category: '心不累'}]},
	        {nameList: [{ category: '心累'}]}
	    ]
	    let data2 = data.map(item=> item.nameList)
	    console.log(_.intersectionBy(data2,'nameList')); // [ { category: '心累' } ]
   }
   {
	    // 排除指定的值 对数组对象有效
	    let arr = [{ name: 1 }, { name: 2 }, { name: 3 }, { name: 1 }]
	    console.log('排除指定值 :>> ', _.differenceBy(arr, [{ name: 1 }, { name: 2 }], 'name')); //  [ { name: 3 } ]
	}
	{ 
		// 取交集，组成新的数组，新数组的值是从第一个 intersectionWith第一个参数取的
		var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
	    var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
	    _.intersectionWith(objects, others, _.isEqual);// => [{ 'x': 1, 'y': 2 }]
	}
	{
		// 删除数组指定 https://www.lodashjs.com/docs/lodash.remove  pull 到 remove都会改变原数组
		var array = [1, 2, 3, 4];
	    var evens = _.remove(array, function(n,index) {
	      	console.log(index); // 0 1 2 3
	        return n % 2 == 0;
	    });
	    console.log(array); // 1 3
	    console.log(evens); // 2 4
	}
	{ 
		// 数组对象 以某个字段为准 去重
		let arr1 = [
          { time: '2021-05-01', name: '张三' },
          { time: '2021-05-02', name: '张三222' },
          { time: '2021-05-01', name: '张三33' }
        ]
        console.log('去除某个属性相同', _.uniqBy(arr1,'time')); // [{ time: '2021-05-01', name: '张三' },{ time: '2021-05-02', name: '张三22' }]
	}
	{
		// 数组对象 去重 每个属性都相同的
		let objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 3 }];
        console.log(_.uniqWith(objects, _.isEqual));
	}
	{
		// 组成二维数组 如果要组合的数组对应下标没有值 组成后 则为undefined
		  let objects = _.zip([{name:111},{name:222}],[{age:18},{age:20}],[{address:'chongq'}])
	}

	// 对象方法
	{
		// assignIn 相当于深拷贝 可以遍历到 原型上的属性
		function Foo(){
			this.a = 1
		}
		Foo.prototype.b = 2
		console.log(_.assignIn({a:0}, new Foo)) // {a:1,b:2}
	}
	{
		// 会改变原对象 defaults
		let obj = { 'a': 1 }, { 'b': 2 }, { 'a': 3 }
		console.log(_.defaults(obj))
	}
	{
		// 对象找到符合条件的第一个Key
		 let users = {
          'barney':  { 'age': 36, 'active': true },
          'fred':    { 'age': 40, 'active': false },
          'pebbles': { 'age': 1,  'active': true }
        }
        console.log('对象找到符合条件的第一个Key',users[_.findKey(users,(item)=> item.age < 40)]);
	}
	{
		// 对象是否包含 某个属性
		  let obj = {
          'barney':  { 'age': 36, 'active': true },
          'fred':    { 'age': 40, 'active': false },
          'pebbles': { 'age': 1,  'active': true }
        }
        console.log('是否包含某个属性', _.has(obj, 'barney.active'));
	}
	{
		//  除了它递归合并 sources 来源对象自身和继承的可枚举属性到 object 目标对象。如果目标值存在，被解析为undefined的sources 来源对象属性将被跳过。数组和普通对象会递归合并，其他对象和值会被直接分配覆盖。源对象从从左到右分配。后续的来源对象属性会覆盖之前分配的属性。
		let obj = {
          arr:[{name:'嵌套'}],
          arr2:{age:14},
          arr3:[{address:{title:'嵌套'}}]
        }
        let x = Object.assign({},obj)
        x.arr[0].name='修改' // 浅拷贝 修改原对象也会被修改
        let y = _.merge({},obj) // 深拷贝 原对象不改变 
        y.arr2.age = 44 
        console.log(x, '-------',y, obj);
	}
	{
		// pick 找到指定的 key 名
		  let obj = {
          name:'张三',
          age:12,
          address:'cq',
        }
        let obj2={
          name:'',
          address:''
        }
        // 数据少 看着麻烦 但是 数据多 就 舒服了
        _.merge(obj2, _.pick(obj,['name','address']))
        console.log(obj2);
	}
	{
		// 把对象的 key value 组成二维数组
		 let obj = {
          name:'张三',
          age:12,
          address:'cq',
        }
        console.log('对象转二维数组', _.toPairs(obj));
	}