js算法。。。

/**
 * 三个请求A，B，C，A 1s , B 2s, C 3s；
 * B用A的返回值，C单独，搞个函数返回[resB,resC]；
 * 先请求a,在返回值里用promise.all请求b, c返回的就是那个数组
 */
let A = () => Promise.resolve('a');  // 1s
let B = (a) => Promise.resolve('b'); // 2s
let C = () => Promise.resolve('c');  // 3s


async function request() {
  try {
    let resC = C();
    let resA = await A();
    Promise.all([B(resA), resC]).then(result => {
      console.log('result=', result);
    }).catch(err => console.log(err));
  } catch {
    throw Errow('err');
  }
  
}

request();
 
/**
 * 数组去重
 */
let arr = [1,2,3,4,5,6,6,6];
// ES6
Array.from(new Set(arr));
let arrRepeat = [];
// 2 indexOf
arr.forEach((item, index) => {
  if(arrRepeat.indexOf(item) === -1) {
    arrRepeat.push(item);
  }
});
// 3 includes
arr.forEach((item, index) => {
  if(!arrRepeat.includes(item)) {
    arrRepeat.push(item);
  }
});
// 4 filter
let newArr = arr.filter((item, index) => {
  return arr.indexOf(item) === index; // indexOf 只能查找到第一个
})

/**
 * 找到字符串中某一个字符的具体位置以及次数
 * 找到d出现的位置和次数
 */
const str = 'abcdddedf';
let num = 0;
let index = str.indexOf('d');
for(var key of str) {
  if(key === 'd') {
    num ++;
  }
}
console.log('index=',index);
console.log('num=',num);

/**
 * 计算数组中每个元素出现的次数
 */
const arr2 = ["b", "c","b", "c","a", "b", "c"];
let obj = {};
arr2.forEach((item, index) => {
  if(obj[item]) {
    obj[item] ++;
  } else {
    obj[item] = 1;
  }
})
console.log(obj);

/**
 * 将 URL 字符串的参数解析为对象的形式
 * 先截取？后的内容，再split分割
 */
// let url = 'https://coder.itclan.cn?name=itclanCoder&study=css';
// let arr3 = url.substring(url.indexOf('?') + 1).split('&');
// let obj3 = {};
// arr3.forEach((item, index) => {
//   let tmp = item.split('=');
//   obj3[tmp[0]] = tmp[1];
// });
// console.log('obj3=', obj3);

// 正则表达式
// url.match(/([^?=&]+)(=([^&]*))/g)
// .reduce((a, v) => (a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') + 1), a), {}
// );

// 需要处理兼容性 npm install url-search-params-polyfill --save
// const url = new URL("https://www.example.com/pathname/?key1=value1&key2=value2");
// const urlParams = url.searchParams;
// const paramsObj = {};
// for (const [key, value] of urlParams) {
//   paramsObj[key] = value;
// }
// console.log(paramsObj);

/**
 * js 统计一个字符串出现频率最高的字符
 */
let str0 = 'asdfghjklaqwertyuiopiaia';
const strChar = str0 => {
    let arr = [...str0], // 字符串转换为数组
        maxValue = '', // 最大的字符
        obj = {},
        max = 0; // 最大出现次数
      arr.forEach(value => {
        // 如果首次出现赋值为1，否则+1
        obj[value] = obj[value] == undefined ? 1 : obj[value] + 1
        if (obj[value] > max) {
            max = obj[value]
            maxValue = value
        }
    })
return maxValue;
}
console.log(strChar(str0));

/**
 * 数组中最大差值
 */
function A() {
  let arr = [23, 4, 5, 2, 4, 5, 6, 6, 71, -3];
  let min = Math.min(...arr);
  let max = Math.max(...arr);
  return max - min;
}
console.log(A());

function B() {
  let arr = [23, 4, 5, 2, 4, 5, 6, 6, 71, -3];
  let min = arr[0], max = 0;
  arr.forEach((item, index) => {
    if(item< min) {
      min = item;
    }
    if(item > max) {
      max = item;
    }
  })
  return max - min;
}
console.log(B());

/**
 * 冒泡排序
 */
function sort() {
  let arr = [43, 32, 1, 5, 9, 22];
  for(let i = 0; i < arr.length; i++) {
    for(let j = i+1; j < arr.length; j++) {
      if(arr[i] > arr[j]) {
        [arr[i], arr[j]] = [arr[j], arr[i]];
      }
    }
  }
  return arr;
}
console.log(sort());

/**
 * js对象怎么通过value找到key
 */
function findKeyByValue(obj, value) {
  for(let key in obj) {
    if(obj[key] === value) {
      return key;
    }
  }
  return null;
}
const myObj = { a: 1, b: 2, c: 3 };
console.log(findKeyByValue(myObj, 2));

/**
 * js list to tree
 */
const list = [
  { id: 1, name: 'Node 1', parentId: null },
  { id: 2, name: 'Node 2', parentId: 1 },
  { id: 3, name: 'Node 3', parentId: 1 },
  { id: 4, name: 'Node 4', parentId: 2 },
  { id: 5, name: 'Node 5', parentId: 2 },
  { id: 6, name: 'Node 6', parentId: 3 },
];
function listToTree(list) {
  // 使用一个map对象来存储每个节点
  const map = {};
  let node;
  let roots = [];

  // 将每个节点的id作为键，以节点自身作为值存储到map中
  for (let i = 0; i < list.length; i++) {
    node = list[i];
    map[node.id] = node;
    node.children = [];
  }

  // 遍历每个节点，将其添加到其父节点的children数组中
  for (let i = 0; i < list.length; i++) {
    node = list[i];
    if (node.parentId !== null && map[node.parentId]) {
      map[node.parentId].children.push(node);
    } else {
      // 如果没有parentId，将其添加到根节点数组中
      roots.push(node);
    }
  }

  // 返回根节点数组
  return roots;
};
listToTree(list);

// 返回值
[
  {
    "id": 1,
    "name": "Node 1",
    "children": [
      {
        "id": 2,
        "name": "Node 2",
        "children": [
          {
            "id": 4,
            "name": "Node 4"
          },
          {
            "id": 5,
            "name": "Node 5"
          }
        ]
      },
      {
        "id": 3,
        "name": "Node 3",
        "children": [
          {
            "id": 6,
            "name": "Node 6"
          }
        ]
      }
    ]
  }
]