根据已有子级key，找到它的所有对应的父级们的集合。

• 比如我们现在有 let keys = [‘group300’,‘group301’,‘group302’]，我们要找到它们的父级，然后再找爷级，以此类推。this.parentsKeyList:[]存储它们。

• 我们先看下初始数据data树的结构：

  const data = {
        "key": "root",
         "type": "root",
         "name": "root",
         "child": [
             "key": "competition01",
             "type": "competition",
             "name": "菜菜大赛",
             "child": [
                 "key": "area100",
                 "type": "area",
                 "name": "华南赛区",
                 "child": [
                     "key": "contest200",
                     "type": "contest",
                     "name": "挑战赛",
                     "child": [
                         "key": "group300",
                         "type": "group",
                         "name": "少儿组",
                         "child": []
                         "key": "group301",
                         "type": "group",
                         "name": "小学组",
                         "child": []
             "key": "competition02",
             "type": "competition",
             "name": "花花大赛",
             "child": [
                 "key": "area101",
                 "type": "area",
                 "name": "东北赛区",
                 "child": [
                     "key": "contest201",
                     "type": "contest",
                     "name": "创意赛",
                     "child": [
                         "key": "group302",
                         "type": "group",
                         "name": "初中组",
                         "child": []
             "key": "competition03",
             "type": "competition",
             "name": "坤坤大赛",
             "child": [
                 "key": "area103",
                 "type": "area",
                 "name": "海外赛区",
                 "child": [
                     "key": "contest202",
                     "type": "contest",
                     "name": "科技赛",
                     "child": [
                         "key": "group304",
                         "type": "group",
                         "name": "高中组",
                         "child": []
//查找父级kye集合
         bindFindKeys(data, val) {
             let [arr,newArr] = [[],[]];
             let list = data.child;
             if (!list || !val) {
               return ''
             let findParent = (item, nodeKey, parentVal) => {
               // console.log(item, nodeKey, parentVal)
               for (let i = 0; i < item.length; i++) {
                 let node = item[i];
                 if (node.key === nodeKey) {
                   arr.unshift(nodeKey);
                   if (nodeKey === list[0].key) {
                     break
                   findParent(list, parentVal);
                   break
                 } else {
                   if (node.child) {
                     findParent(node.child, nodeKey, node.key);
                   continue
               return arr;
             newArr = findParent(list, val);
 			this.parentsKeyList = Array.from(new Set([...this.parentsKeyList,...newArr]));
             return this.parentsKeyList;  //存储去重一下
//假如我们要找keys里面的父级key们
 let keys = ['group300','group301','group302'];
  for(let v of keys){
    this.bindFindKeys(data,v);
打印一下：
 
                    根据已有子级id，找到它的所有对应的父级们的集合。比如我们现在有 levelIdList:[“166”]，我们要找到这个166它的父级，然后再找爷级，以此类推。数据效果图：我们也得到的下方的数据。我们先看下初始数据data树的结构：（因为层级有点深，截图来看）            bindFindKeys(data, val) {                let arr = [], newArr = [];                for (let i = 0; i&lt;
        "id": "quis consequat culpa ut pariatur",
        "name": "et quis irure dolore ullamco",
        "ompany": "sunt mollit",
        "address": "anim reprehenderit aliquip labore velit"
				
大家开发的时候是不是会经常遇到这种需求，一个N个层级的数组，只有叶子级的数据有金额或者其他的信息，然后需求需要你把每个父级都加上汇总的数据集合。那么我们该怎么做呢？
实战项目需求参考：
上面的数据是计算错误的，圈出来的地方要求数据是正确的，需要计算。
我们自己的解决思路整理如下：
既然只有子级有数据，然后上面的每一个层级都需要汇总那么肯定是优先计算最深的层级了。所以我们遍历数据需要做特殊处理或...




    

				
// 查找名称
//data是数组数据   family_tree所有父类id    id当前id
findName = (id,family_tree,data) =&amp;amp;amp;amp;gt;{
//  console.log(data)
let name=’’
let item = ‘’
if (family_treenull||family_tree’’){
item = this.findItem(data...
var sequentialSearch = function(arr, item) {
    for (var i = 0; i < arr.length; i++) {
	    if (item === arr[i]) {
		    return i;
    return -1;
				
[js]  写一个方法判断数组内元素是否全部相同
const isSameArray = function (array) {
  if (Array.isArray(array)) {
    return new Set(array).size === 1;
  return false;
我是歌谣，欢迎和大家一起交流前后端知识。放弃很容易，
但坚持一定很酷。欢迎大家一起讨论
与歌谣一起通关前端面试题
要使用 JavaScript 来实现多层嵌套的对象数组递归查找，可以使用递归函数，来遍历每一层对象和数组，以寻找查找的对象或元素。举个例子，例如你有一个数组嵌套的多层对象，如下： ```
var data = [
    name: 'John',
    items: [
        name: 'phone',
        items: [
            name: 'iPhone',
            items: [
                name: 'iPhone 7'
```你可以创建一个递归函数，以遍历每一层对象和数组，来查找你需要的元素： ```
function findItem (arr, name) {
  for (let item of arr) {
    if (item.name === name) {
      return item;
    if (item.items) {
      let foundItem = findItem(item.items, name);
      if (foundItem) {
        return foundItem;
  return null;
```使用这个函数，你可以查找你想要的元素，比如查找名字为“iPhone 7”的元素： ```
let result = findItem(data, 'iPhone 7');