liang14658fox

Appearance

^finished

删除对象数组中指定属性等于指定数组元素的对象 ​

假设你有一个对象数组 objects，每个对象都有一个名为 name 的属性，以及一个数组 names，包含了需要删除的对象的 name 值。 你可以使用 filter() 函数来过滤出不包含需要删除的对象的新数组。

示例函数：

javascript
function removeObjectsByName(objects, names) {
  return objects.filter(obj => !names.includes(obj.name));
}
function removeObjectsByName(objects, names) {
  return objects.filter(obj => !names.includes(obj.name));
}

这个函数使用 filter() 函数遍历对象数组 objects，并返回一个新数组，其中不包含与 names 数组中的元素对应的对象。 示例用法：

javascript
let objects = [
  { name: 'John', age: 25 },
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 35 },
  { name: 'John', age: 40 }
];
let names = ['John', 'Alice'];
let filteredObjects = removeObjectsByName(objects, names);
console.log(filteredObjects);
let objects = [
  { name: 'John', age: 25 },
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 35 },
  { name: 'John', age: 40 }
];
let names = ['John', 'Alice'];
let filteredObjects = removeObjectsByName(objects, names);
console.log(filteredObjects);

输出结果：

js
[
  { name: 'Bob', age: 35 },
  { name: 'John', age: 40 }
]
[
  { name: 'Bob', age: 35 },
  { name: 'John', age: 40 }
]

提取对象数组中部分属性，组成新对象 ​

  1. [方案1] 找到属性值相等的对象，然后输出，不排除空字符串相等的对象
js
function findDuplicateNames(objects) {
  const nameCount = {};
  const duplicates = [];

  for (const obj of objects) {
    const name = obj.name;
    if (nameCount[name]) {
      nameCount[name]++;
      if (nameCount[name] === 2) {
        duplicates.push(name);
      }
    } else {
      nameCount[name] = 1;
    }
  }

  // 找到重复的对象
  const duplicateObjects = objects.filter(obj => duplicates.includes(obj.name));

  return duplicateObjects;
}

// 使用示例
const objectArray = [
  { name: "Alice", age: 25 },
  { name: "Bob", age: 30 },
  { name: "Alice", age: 28 },
  { name: "Charlie", age: 35 },
];

const duplicates = findDuplicateNames(objectArray);
console.log(duplicates);
function findDuplicateNames(objects) {
  const nameCount = {};
  const duplicates = [];

  for (const obj of objects) {
    const name = obj.name;
    if (nameCount[name]) {
      nameCount[name]++;
      if (nameCount[name] === 2) {
        duplicates.push(name);
      }
    } else {
      nameCount[name] = 1;
    }
  }

  // 找到重复的对象
  const duplicateObjects = objects.filter(obj => duplicates.includes(obj.name));

  return duplicateObjects;
}

// 使用示例
const objectArray = [
  { name: "Alice", age: 25 },
  { name: "Bob", age: 30 },
  { name: "Alice", age: 28 },
  { name: "Charlie", age: 35 },
];

const duplicates = findDuplicateNames(objectArray);
console.log(duplicates);
  1. [方案2] 输出重复部分，每种重复只输出一个对象
js
function findAllDuplicateNames(objects) {
  const nameCount = {};
  const duplicates = [];

  for (const obj of objects) {
    const name = obj.name;

    if (name !== "") {
      nameCount[name] = (nameCount[name] || 0) + 1;
      if (nameCount[name] === 2) {
        duplicates.push(name);
      }
    }
  }

  return objects.filter(obj => duplicates.includes(obj.name));
}

// 示例用法
const objectArray = [
  { name: "John" },
  { name: "Alice" },
  { name: "Bob" },
  { name: "Alice" },
  { name: "Eve" },
  { name: "" },
  { name: "Bob" },
];

const duplicateObjects = findAllDuplicateNames(objectArray);
console.log(duplicateObjects);
function findAllDuplicateNames(objects) {
  const nameCount = {};
  const duplicates = [];

  for (const obj of objects) {
    const name = obj.name;

    if (name !== "") {
      nameCount[name] = (nameCount[name] || 0) + 1;
      if (nameCount[name] === 2) {
        duplicates.push(name);
      }
    }
  }

  return objects.filter(obj => duplicates.includes(obj.name));
}

// 示例用法
const objectArray = [
  { name: "John" },
  { name: "Alice" },
  { name: "Bob" },
  { name: "Alice" },
  { name: "Eve" },
  { name: "" },
  { name: "Bob" },
];

const duplicateObjects = findAllDuplicateNames(objectArray);
console.log(duplicateObjects);
  1. [方案3]
js
function findDuplicateNames(objects) {
  const nameCount = {};
  const duplicates = [];

  for (const obj of objects) {
    const name = obj.name;
    
    if (name !== "") {
      if (nameCount[name]) {
        if (!duplicates.includes(name)) {
          duplicates.push(name);
        }
      } else {
        nameCount[name] = 1;
      }
    }
  }

  return objects.filter(obj => duplicates.includes(obj.name));
}

// 示例用法
const objectArray = [
  { name: "John" },
  { name: "Alice" },
  { name: "Bob" },
  { name: "Alice" },
  { name: "Eve" },
  { name: "" },
  { name: "Bob" },
];

const duplicateObjects = findDuplicateNames(objectArray);
console.log(duplicateObjects);
function findDuplicateNames(objects) {
  const nameCount = {};
  const duplicates = [];

  for (const obj of objects) {
    const name = obj.name;
    
    if (name !== "") {
      if (nameCount[name]) {
        if (!duplicates.includes(name)) {
          duplicates.push(name);
        }
      } else {
        nameCount[name] = 1;
      }
    }
  }

  return objects.filter(obj => duplicates.includes(obj.name));
}

// 示例用法
const objectArray = [
  { name: "John" },
  { name: "Alice" },
  { name: "Bob" },
  { name: "Alice" },
  { name: "Eve" },
  { name: "" },
  { name: "Bob" },
];

const duplicateObjects = findDuplicateNames(objectArray);
console.log(duplicateObjects);

对象数组根据某一属性排序 ​

排序算法 [方案1]

js
var compare = function (obj1, obj2) {
    var val1 = obj1.name;
    var val2 = obj2.name;
    if (val1 < val2) {
        return -1;
    } else if (val1 > val2) {
        return 1;
    } else {
        return 0;
    }
}

// 测试
let testObjArr = [{}] 
let result = testObjArr.sort(compare)
var compare = function (obj1, obj2) {
    var val1 = obj1.name;
    var val2 = obj2.name;
    if (val1 < val2) {
        return -1;
    } else if (val1 > val2) {
        return 1;
    } else {
        return 0;
    }
}

// 测试
let testObjArr = [{}] 
let result = testObjArr.sort(compare)
  1. [方案2]可指定要排序的属性
js
function sortKeyValue(objArr, key) {
    objArr.sort(function (a, b) {
        let nameA = a[key]
        let nameB = b[key]
        if (nameA < nameB) {
            return -1
        }
        if (nameA > nameB) {
            return 1
        }
        return 0
    })
    return objArr
}

// 测试
let testObjArr = [{}]
let result = sortKeyValue(testObjArr, 'engName') // 指定键名进行排序：engName
function sortKeyValue(objArr, key) {
    objArr.sort(function (a, b) {
        let nameA = a[key]
        let nameB = b[key]
        if (nameA < nameB) {
            return -1
        }
        if (nameA > nameB) {
            return 1
        }
        return 0
    })
    return objArr
}

// 测试
let testObjArr = [{}]
let result = sortKeyValue(testObjArr, 'engName') // 指定键名进行排序：engName

对象数组根据指定属性值排序 ​

js
let objArr =[
  {
    id:99,
    name:'五十'
  },{
    id:2,
    name:'鲁棒'
  },{
    id:16,
    name:'三毛'
  },
]
function sortBy(attr, rev) { // attr：根据该属性排序；rev：升序1或降序-1，不填则默认为1
	if (rev == undefined) {
		rev = 1
	} else {
		(rev) ? 1: -1;
	}
	return function(a, b) {
		a = a[attr];
		b = b[attr];
		if (a < b) {
			return rev * -1
		}
		if (a > b) {
			return rev * 1
		}
		return 0;
	}
}
objArr.sort(sortBy('id', 1))
let objArr =[
  {
    id:99,
    name:'五十'
  },{
    id:2,
    name:'鲁棒'
  },{
    id:16,
    name:'三毛'
  },
]
function sortBy(attr, rev) { // attr：根据该属性排序；rev：升序1或降序-1，不填则默认为1
	if (rev == undefined) {
		rev = 1
	} else {
		(rev) ? 1: -1;
	}
	return function(a, b) {
		a = a[attr];
		b = b[attr];
		if (a < b) {
			return rev * -1
		}
		if (a > b) {
			return rev * 1
		}
		return 0;
	}
}
objArr.sort(sortBy('id', 1))

对象组成的数组深拷贝 ​

js
let oldObjArray = [{},{},{}]
var objDeepCopy = function (source) {
  var sourceCopy = source instanceof Array ? [] : {}
  for (var item in source) {
    sourceCopy[item] =
      typeof source[item] === 'object'
        ? objDeepCopy(source[item])
        : source[item]
  }
  return sourceCopy
}
let newObjArr = objDeepCopy(oldObjArray)
let oldObjArray = [{},{},{}]
var objDeepCopy = function (source) {
  var sourceCopy = source instanceof Array ? [] : {}
  for (var item in source) {
    sourceCopy[item] =
      typeof source[item] === 'object'
        ? objDeepCopy(source[item])
        : source[item]
  }
  return sourceCopy
}
let newObjArr = objDeepCopy(oldObjArray)

字典对象数组特征 ​

提取对象数组中部分属性，并更换键名，组成新对象 ^finished ​

现有一个对象数组 OriginArray ，提取这个数组中的每一个对象的任意数量的指定键值对的值，赋予他们新的键名（或者取旧键名）， 输出新的对象数组。

示例对象数组 OriginArray：

js
let OriginArray = [
    {
        oldId:'007',
        oldName:'小火猴',
        uselessData:'useless'
    },
    {
        oldId:'001',
        oldName:'果冻鸭',
        uselessData:'useless'
    }
]
let OriginArray = [
    {
        oldId:'007',
        oldName:'小火猴',
        uselessData:'useless'
    },
    {
        oldId:'001',
        oldName:'果冻鸭',
        uselessData:'useless'
    }
]

期望输出结果：

js
[
    {
        newUUID:'007',
        newName:'小火猴'
    },
    {
        newUUID:'001',
        newName:'果冻鸭'
    }
]
[
    {
        newUUID:'007',
        newName:'小火猴'
    },
    {
        newUUID:'001',
        newName:'果冻鸭'
    }
]

算法：

js
let resultArray = OriginArray.map((item, index) => {
	return Object.assign({}, {
		'newUUID': item.oldId,
		'newName': item.oldName
	})
})
console.log(resultArray)
let resultArray = OriginArray.map((item, index) => {
	return Object.assign({}, {
		'newUUID': item.oldId,
		'newName': item.oldName
	})
})
console.log(resultArray)
js
var NewArray = []
for (let index = 0; index < this.OriginArray.length; index++) {
	NewArray.push({
		NewID: '',
		NewName: ''
	});
	NewArray[index].NewName = OriginArray[index].oldName;
	NewArray[index].NewID = OriginArray[index].oldID;
}
console.log(NewArray)
var NewArray = []
for (let index = 0; index < this.OriginArray.length; index++) {
	NewArray.push({
		NewID: '',
		NewName: ''
	});
	NewArray[index].NewName = OriginArray[index].oldName;
	NewArray[index].NewID = OriginArray[index].oldID;
}
console.log(NewArray)