Diff Two Arrays

比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中一切独占的数组元素。换言之，返回两个数组的差别。

function diff(arr1, arr2) {
   var a1=arr1.filter(function(val){
        return arr2.indexOf(val)< 0;
   });
   var a2=arr2.filter(function(val){
       return arr1.indexOf(val)< 0;
   });
   return a1.concat(a2);
}

diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);

Roman Numeral Converter

将给定的数字转换成罗马数字。
一切返回的 罗马数字 都应当是大写情势。
可参考Here

function convert(num) {
  var nums = [1000,900,500,400,100,90,50,40,10,9,5,4,1];
  var romans =["m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"];
  var str = '';
  nums.forEach(function(item,index,array){
    while(num >= item){
      str += romans[index];
      num -= item;
    }
  });
  
 return str.toUpperCase();
}
convert(36);

Where art thou

写一个 function，它遍历一个对象数组（第一个参数）并返回一个包括相婚配的属性-值对（第二个参数）的一切对象的数组。假如返回的数组中包括 source 对象的属性-值对，那末此对象的每个属性-值对都必需存在于 collection 的对象中。

比方，假如第一个参数是 [{ first: “Romeo”, last: “Montague” }, { first: “Mercutio”, last: null }, { first: “Tybalt”, last: “Capulet” }]，第二个参数是 { last: “Capulet” }，那末你必需从数组（第一个参数）返回个中的第三个对象，由于它包括了作为第二个参数通报的属性-值对。

//法一
function where(collection, source) {
  var keys =  Object.keys(source);
  return collection.filter(function(obj){
      return keys.every(function(item){
          return obj.hasOwnProperty(item) && obj[item] === source[item];
      });
  });
}
//法二
function where(collection, source) {
  var keys =  Object.keys(source);
  return collection.filter(function(obj){
      return keys.every(function(item){
          return obj.hasOwnProperty(item) && obj[item] === source[item];
      });
  });
}

where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });

Search and Replace

运用给定的参数对句子实行一次查找和替代，然后返回新句子。第一个参数是将要对其实行查找和替代的句子。第二个参数是将被替代掉的单词（替代前的单词）。第三个参数用于替代第二个参数（替代后的单词）。
注重：替代时坚持原单词的大小写。比方，假如你想用单词 “dog” 替代单词 “Book” ，你应当替代成 “Dog”。

//法一
function myReplace(str, before, after) {
    if(before[0] === before[0].toUpperCase()){
        after = after[0].toUpperCase() + after.slice(1);
    }
    str = str.replace(before,after);
    return str;
}


//法二
function myReplace(str, before, after) {
  var re = /^[A-Z]/;
  if(re.test(before.charAt(0))){
    after = after.charAt(0).toUpperCase() + after.slice(1);
  }
  str = str.replace(before,after);
  return str;
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

Pig Latin

把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个子音或子音丛（consonant cluster）移到词尾，然后加上后缀 “ay”。
假如单词以元音最先，你只需要在词尾增加 “way” 就能够了。

function translate(str) {
    var myStr = '';
    var regex = /[aeiou]/gi;
    if(str[0].match(regex)){
        myStr = str + 'way';
    }else{
        var index = str.indexOf(str.match(regex)[0]);
        myStr = str.substr(index) + str.substring(0,index) + 'ay';
    }
  return myStr;
}

translate("consonant");//onsonantcay

DNA Pairing

DNA 链缺乏配对的碱基。根据每个碱基，为其找到配对的碱基，然后将效果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母婚配缺失的碱基。
在每个数组中将给定的字母作为第一个碱基返回。
比方，关于输入的 GCG，响应地返回 [[“G”, “C”], [“C”,”G”],[“G”, “C”]]
字母和与之配对的字母在一个数组内，然后一切数组再被组织起来封装进一个数组。

function pair(str) {
  var arr = str.split('');
  var pair = '';
  return arr.map(function(item){
      switch(item){
          case 'C':
              pair = 'G';
            break;
          case 'G':
              pair = 'C';
            break;
        case 'A':
            pair = 'T';
            break;
        case 'T':
            pair = 'A';
             break;
      }
      return [item,pair];
  });
}

pair("GCG");

Missing letters

从通报进来的字母序列中找到缺失的字母并返回它。
假如一切字母都在序列中，返回 undefined。

法一：
    var arr = str.split('');
    for(var i = 0;i < arr.length;i++){
        var minus = arr[i+1].charCodeAt() - arr[i].charCodeAt();/后项减去前项/
        if( minus > 1){
            return String.fromCharCode(arr[i].charCodeAt()+1);
        }
    }
法二:
function fearNotLetter(str) {
    var compare = str.charCodeAt(0),missing;
    str.split('').map(function(item,index){
        if(str.charCodeAt(index) === compare){
            ++ compare;
        }else{
            missing = String.fromCharCode(compare);
        }
    });
    return missing;
}
fearNotLetter("abce");

Boo who

搜检一个值是不是是基础布尔范例，并返回 true 或 false。
基础布尔范例即 true 和 false。

function boo(bool) {
 return typeof bool === 'boolean';
}

boo(true);

Sorted Union

写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包括反复值的新数组。
比方：unite([1, 3, 2], [5, 2, 1, 4], [2, 1]) 应当返回 [1, 3, 2, 5, 4]。

function unite(arr1, arr2, arr3) {
  var args = Array.from(arguments);
  var arr = args.reduce(function(prev,cur){
    return prev.concat(cur);
  });
  return arr.filter(function(item,index,arr){
    return arr.indexOf(item) === index;  
  });
}
unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);

Convert HTML Entities

将字符串中的字符 &、<、>、” （双引号）, 以及 ‘ （单引号）转换为它们对应的 HTML 实体。

法一
function convert(str) {
  str = str.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")
           .replace(/"/g,"&quot;").replace(/'/g,"&apos;");
  return str;
}
convert("Dolce & Gabbana");
法二：
function convert(str) {
    var htmlEntities={
        '&':'&amp;',
        '<':'&lt;',
        '>':'&gt;',
        '\"':'&quot;',
        '\'':'&apos;',
    };
    return str.split('').map(function(entity){
        return htmlEntities[entity] || entity;
    }).join('');
}
convert("Dolce & Gabbana");