常见笔试题

找出任意一个html当中所有不重复的标签

思路：1找出页面所有标签 2去重

    document.querySelectorAll("*") //获取所有标签  得到一个伪数组
    
    [...document.querySelectorAll("*")] // 用运算扩展符将伪数组转化成数组 es6
     Array.prototype.slice.call(document.querySelectorAll("*")) // 用slice将伪数组转化成数组 es5
     
    [...document.querySelectorAll("*")].map(v => v.tagName)
    
    [...new Set[...document.querySelectorAll("*")].map(v => v.tagName)]

补全下列函数 保证输出值

    function add (){
        if(!n){return res}
        res = n;
        return function(n){
            return add(res + n)
        }
    }
    add(1)(2)() // 3
    add(1)(2)(3)(4)() //10
    add(1)(1)(1)(1)(1)(1)(1)(1)(1)(1)() //  10

思路：

• add(1)(2) 第一次调用之后还可以调用函数 说明返回的是一个函数
• 递归函数最重要的是什么？ 要有出口
• 这个值是什么？这个值是每一次实参的和
• 要把上一次的值保存起来 累加

请使用 JavaScript 数组的 reduce 方法求合

function getSum(list) {
  // 请实现函数主体
  return list.reduce((pre,cur)=>{pre + cur.n},0)
}

getSum([{ n: 1 }, { n: 5 }, { n: 10 }, { n: 22 }]); //==> 38

用正则表达式从字符串 123ABC456ABC 中取出数字串

function reg(str) { 
// 请实现函数主体 
  const regex = /\d+/g;
  return str.match(regex)
}
reg('123ABC456ABC'); // [123,456]

问题：请实现 p3 函数，合并 p1, p2 2个 Promise 函数为一个异步返回。并使p3能正确执行输出（张三 18）

function p1() { 
    return Promise.resolve('张三'); 
} 
function p2() { 
    return Promise.resolve('18'); 
} 
function p3() { 
    // TODO: 请完成函数主体 
    return Promise.all([p1(),p2()]).then(([name,age])=>{
    return {
        name:name,
        age:age
    }
})
} 
p3().then((data) => { 
    console.log(data.name, data.age); // 张三 18 
});

请利用闭包实现一个计数器函数，要求每次调用该函数返回值加一：

function createCounter() {
  // TODO: 请完成函数主体
  function(){}
}

const counter = createCounter();
console.log(counter()); //1
console.log(counter()); //2
console.log(counter()); //3

function createCounter() {
  // TODO: 请完成函数主体
    var sum = 0;
    function add(){
        sum ++;
        return sum
    }
    return add;
}

const counter = createCounter();
console.log(counter()); //1
console.log(counter()); //2
console.log(counter()); //3

请实现一个函数，将一个字符串中的所有单词首字母大写并返回一个新字符串。

例如，传入字符串 'hello world'，函数应该返回 'Hello World'： function uppercaseWords(str) {
// TODO: 实现函数
}
console.log(uppercaseWords('hello world')); // 'Hello World'

function uppercaseWords(str) { 
    // TODO: 实现函数 
    var arr = [];
    arr = str.split(" ");
    var result = '';
    if(arr && arr.length){
        for(let i=0;i<arr.length;i++){
            result = result + arr[i].charAt(0).toUpperCase() +arr[i].slice(1) + ' '
        }
    }
    return result;
} 
console.log(uppercaseWords('hello world')); // 'Hello World'

请用promise改写下面的代码

// 请用promise改写下面的代码 
function loadScript(src, callback) {
const script = document.createElement('script');
  script.src = src;
  script.onload = () => {
  	callback(null);
  };
  script.onerror = () => {
  	callback(new Error(`Failed to load script ${src}`));
  };
  document.head.appendChild(script);
}
function newLoadScript(src) {
//TODO 请完成函数主体
}

// 测试用例
newLoadScript('https://o.alicdn.com/tbhome/tbnav/index.js').then(()=>{
	console.log("load success")
}).catch((e)=>{
	console.log(e.message)
})

//实现
function newLoadScript(src) {
//TODO 请完成函数主体
return new Promise((resolve, reject) => {
    const script = document.createElement('script');
    script.src = src;

    script.onload = () => {
      resolve();
    };

    script.onerror = () => {
      reject(new Error(`Failed to load script ${url}`));
    };

    document.head.appendChild(script);
  });
}

// 测试用例
newLoadScript('https://o.alicdn.com/tbhome/tbnav/index.js').then(()=>{
	console.log("load success")
}).catch((e)=>{
	console.log(e.message)
})

// 问题：清除对象中值为空，即 undefined 或 null 的属性，返回新对象，不修改原对象

const target = { a: undefined, b: null, c: false, d: '', e: 0, f : () => {} };
clean(target) // => { c: false, d: '', e: 0, f: () => {} }, 同时需要保证 target 不变
clean(100) // => 100
clean(false) // => false
clean() // => undefined
function clean(obj) { //TODO 请完成函数主体 }

const target = { a: undefined, b: null, c: false, d: '', e: 0, f : () => {} };
function clean(obj) {
    //TODO 请完成函数主体 
    // typeof判断数组 对象和null => object
    if (typeof obj !== 'object' || obj === null) {
        return obj;
    }
    let newobj = {}
    for (let key in obj) {
        if(obj[key] !=undefined && obj[key] != null){
            newobj[key] = obj[key]
        }
    }
    return newobj
}
clean(target) // => { c: false, d: '', e: 0, f: () => {} }, 同时需要保证 target 不变
clean(100) // => 100
clean(false) // => false
clean() // => undefined

请用【循环遍历】 或者【递归】将数组转为树状结构（children为子元素）

// 请用【循环遍历】 或者【递归】将数组转为树状结构（children为子元素） 
function traverseArray2Tree(arr = []) { 
    //TODO 请完成函数主体 
} 
// 测试用例 
console.log(traverseArray2Tree([ {
    id: 1, 
    pid: 0, 
    name: 'body' 
}, { 
    id: 2,
    pid: 1, 
    name: 'title' 
}, { 
    id: 3, 
    pid: 2, 
    name: 'div' 
}, { 
    id: 4, 
    pid: 0, 
    name: 'div' 
}, { 
    id: 9, 
    pid: 4, 
    name: 'div' 
 } 
])) 
// 期望输出 
[ { id: 1, 
    pid: 0, 
    children: [ { 
        id: 2, 
        pid: 1, 
        children: [ { id: 3,  pid: 2 } ] 
     } ]
   },
   { id: 4,
     pid: 0, 
     children: [ { id: 9, pid: 4 } ] 
   } 
 ]

function traverseArray2Tree(arr=[]) {
//   TODO 请完成函数主体
    //  通过pid分组
  const result = [];   // 存放结果集
  const itemMap = {};  // 
  for (const item of arr) {
    const id = item.id;
    const pid = item.pid;

    if (!itemMap[id]) {
      itemMap[id] = {
        children: [],
      }
    }

    itemMap[id] = {
      ...item,
      children: itemMap[id]['children']
    }

    const treeItem =  itemMap[id];

    if (pid === 0) {
      result.push(treeItem);
    } else {
      if (!itemMap[pid]) {
        itemMap[pid] = {
          children: [],
        }
      }
      itemMap[pid].children.push(treeItem)
    }

  }
  return result;  
}