几道算法...

创建一个函数，并返回具有匹配的名称和值对的所有对象的数组。 如果要包含在返回的数组中，则源对象的每个名称和值对都必须存在于集合中的对象中。

如：whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" })

应返回 [{ first: "Tybalt", last: "Capulet" }]。

  function whatIsInAName(collection, source) {
  let b = Object.keys(source);
  let a =b.length;//这是b的长度
  let count=0;
  let c = [];
  for(let i=0;i<collection.length;i++){
      count=0;  //每项匹配度数都应重置为0，假如你的source的长度只有1，本来匹配一次就加入了c数组中，但如果不为0，collection后面的每项被+1，每项被匹配上时，但因为count已经为2或者递加上去，无法再加入c中
   for(let j=0;j<b.length;j++){
     if(collection[i].hasOwnProperty(b[j]) && collection[i][b[j]]==source[b[j]]){
      count++；   //这里是保证source每项都匹配上才被添加进数组
      console.log(count)
     }
     if(count==a){
       c.push(collection[i])
       continue; //结束本轮循环，进入下一轮循环中
     }
   }
  }

  console.log(c)
  return c;
}

比较两个数组并返回一个新数组，包含所有只在其中一个数组中出现的元素，排除两个数组都存在的元素。 换言之，我们需要返回两个数组的对称差。

如[1, 2, 3, 5], [1, 2, 3, 4, 5] 应返回 [4]。

  function diffArray(arr1, arr2) {
  let newArr = [];
  let arr = [...arr1,...arr2];
  let obj = new Map(); //用map的原因是map的key值key是任意值，传进去的值是什么就是什么，不会像object那样硬转为字符串，改变了原有数据类型
  for(let i=0;i<arr.length;i++){
    if(obj.has(arr[i])){
      obj.set(arr[i],obj.get(arr[i])+1)
    }else{
      obj.set(arr[i],1)
    }
  }
  console.log(obj)
  for(let [key,value] of obj){
    if(value==1){
      newArr.push(key)
    }
  }
  return newArr;
}

编写一个带有两个或更多数组的函数，并按原始提供的数组的顺序返回一个新的唯一值数组。换句话说，所有数组中出现的所有值都应按其原始顺序包括在内，但最终数组中不得重复。去重后的数字应按其出现在参数中的原始顺序排序，最终数组不应按数字大小进行排序。

如：uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]) 应返回 [1, 3, 2, 5, 4]``uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]) 应返回 [1, 3, 2, 5, 4]

  function uniteUnique(arr) {
  let len = arguments.length;
  let concatArr =[];
  let res=[];
  for(let i=0;i<len;i++){
    concatArr = concatArr.concat(arguments[i])
  }
  res = Array.from(new Set([...concatArr]))
  console.log(res)
  return res;
}

写一个函数，参数为一个正整数 num，返回值为斐波那契数列中，小于或等于 num 的奇数之和。

如：sumFibs(4) 应返回 5。

function sumFibs(num) {
  let start=0;
  let second=1;
  let sum = 1;
  let res=0;
  while(res<=num){
    res = start+second;
    start = second;
    second=res;
    if( res<=num && res % 2 != 0){ //这里多加重复判断是因为在循环体中，res可能比num大了，也会加入了sum的和中，res只有比num或者等于num的，才可以加入sum计算中
      sum+=res;
    }
  }
  return sum;
}

创建一个将两个参数相加的函数。 如果只提供了一个参数，则返回一个需要一个参数并返回总和的函数。

如addTogether(23, 30) 应返回 53。addTogether(5)(7) 应返回 12。addTogether("http://bit.ly/IqT6zt") 应返回 undefined。addTogether(2, "3") 应返回 undefined

function addTogether() {
  for(let i=0;i<arguments.length;i++){
    if(typeof arguments[i] != 'number'){
      return undefined;
    }
  }
  if(arguments.length>1){
    let arr = Array.from(arguments);
    return arr.reduce((v,e)=>{
      return v=v+e;
    },0)
  }else{
    return (y)=>{
       if(typeof y != 'number'){
        return undefined;
      }else{
        return y+arguments[0]}
      }
  }
}