js 數組、字符串相關操做

時間 2019-12-06

原文原文鏈接

找出多個數組中的最大數 javascript

如：largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]]) 應該返回 [27,5,39,1001].html

function largestOfFour(arr) {
  var array = [];
  arr = arr.map(function(val, idx){
    val.sort(function(a,b){ return b-a;});
    array[idx] = val[0];
  });
  return array;
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

句中單詞首字母大寫 (Title Case a Sentence)java

好比接收的是 "short sentence"，那麼輸出就是 "Short Sentence"，若是接收的是 "shOrT sEnTEnce"，那麼輸出也應該是 "Short Sentence"數組

function titleCase(str) {
    return str.toLowerCase().split(" ").map(function (word) {
        return word[0].toUpperCase() + word.slice(1);
    }).join(" ");
}

中級解法編輯器

function titleCase(str) {
    return str.toLowerCase().replace(/(\s|^)[a-z]/g, function (match) {
        return match.toUpperCase();
    })
}

刪除數組中的全部假值ide

在JavaScript中，假值有false、null、0、""、undefined 和 NaN。函數

function bouncer(arr) {
  arr = arr.filter(function(val){
    return val;
  });
  return arr;
}

bouncer([false, null, 0, NaN, undefined, ""]); // 返回 []

摧毀數組oop

實現一個摧毀(destroyer)函數，第一個參數是待摧毀的數組，其他的參數是待摧毀的值。測試

function destroyer(arr) {
  var args = [];
  for(var i = 1; i < arguments.length; i++){
    args.push(arguments[i]);
  }
  var temp = arr.filter(function(item,index,array){
   return args.indexOf(item) < 0; // indexOf()查詢不到是返回-1；
  });
  return temp;
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3); // 返回 [1,1]

Diff Two Arraysthis

比較兩個數組，而後返回一個新數組，該數組的元素爲兩個給定數組中全部獨有的數組元素。換言之，返回兩個數組的差別。

function diff(arr1, arr2) { 
  return arr1.filter(function(v){
   return arr2.indexOf(v)==-1;        //第一個數組在第二個數組中不一樣的項
  }).concat(arr2.filter(function(v){
   return arr1.indexOf(v)==-1;
  }));                                //第二個數組在第一個數組中不一樣的項
}

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 arr = [];
  var keys = Object.keys(source);
  arr = collection.filter(function(item){
    for (var i = 0; i < keys.length; i++) {
      if ( !item.hasOwnProperty(keys[i]) || item[keys[i]] !== source[keys[i]]) {
        return false;
      }
    }
    return true;
  });
  return arr;
}

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

Pig Latin

把一個英文單詞的第一個輔音或輔音叢（consonant cluster）移到詞尾，而後加上後綴 "ay"。若是單詞以元音開始，你只須要在詞尾添加 "way" 就能夠了。

function translate(str) {
  var temp=[];
  var answer;
  temp=str.split('');//將str分解爲單個字符存入數組
  var i=0;
  while(temp[i]!='a'&&temp[i]!='o'&&temp[i]!='i'&&temp[i]!='e'&&temp[i]!='u'){
    i++;//若是不是元音i++，若是是元音推出循環
  }
  answer=str.substr(i);//將str不是元音的部分提出
  answer+=str.substr(0,i);//將str的元音部分加在answer以後
  if(i===0){
   answer+="way";//首字母爲元音加 way
  }else{
   answer+="ay";//不是加 ay
  }
  return answer;
}

translate("consonant");

Missing letters

從傳遞進來的字母序列中找到缺失的字母並返回它。全部字母都在序列中，返回 undefined。

function fearNotLetter(str) {
   for(var i=0,len=str.length;i<len;i++){  
   var cha = str.charCodeAt(i+1)-str.charCodeAt(i);  
   if(cha>1){  
     return String.fromCharCode(str.charCodeAt(i)+1);  
   }  
 }  
  return undefined; 
}

fearNotLetter("abce");

Sorted Union

寫一個 function，傳入兩個或兩個以上的數組，返回一個以給定的原始數組排序的不包含重複值的新數組。換句話說，全部數組中的全部值都應該以原始順序被包含在內，可是在最終的數組中不包含重複值。非重複的數字應該以它們原始的順序排序，但最終的數組不該該以數字順序排序。

unite([1, 3, 2], [5, 2, 1, 4], [2, 1]) 應該返回 [1, 3, 2, 5, 4]。

unite([1, 3, 2], [1, [5]], [2, [4]]) 應該返回 [1, 3, 2, [5], [4]]。

function unite(arr1, arr2, arr3) {
  var arr=[];
  //unite中參數總數目（即數組個數）
  var len=arguments.length;
  //控制遍歷哪一個數組（arguments[i],i可取0~len-1）
  var i=0;  
  while(i<len){
    //控制遍歷的數組arguments[i]中元素下標
    var j=0;
    while(j<arguments[i].length){
      //若是arr中沒有索引爲i的數組參數中的索引爲j的元素
      //將其push到arr中
      if(arr.indexOf(arguments[i][j])==-1)
         arr.push(arguments[i][j]);
      j++;
    }
    i++;   
  }  
  return arr;
}

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

Spinal Tap Case

將字符串轉換爲 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 這種形式的，也就是以連字符鏈接全部小寫單詞。

spinalCase("This Is Spinal Tap") 應該返回 "this-is-spinal-tap"。

spinalCase("thisIsSpinalTap")應該返回 "this-is-spinal-tap"。

function spinalCase(str) {
  return str.split(/\s|_|(?=[A-Z])/).join('-').toLowerCase();
}

spinalCase('ThisIsSpinalTap');

// 方法2
function spinalCase(str) {
  // Create a variable for the white space and underscores.
  var regex = /\s+|_+/g;

  // Replace low-upper case to low-space-uppercase
  str = str.replace(/([a-z])([A-Z])/g, '$1 $2');

  // Replace space and underscore with -
  return str.replace(regex, '-').toLowerCase();
}

Sum All Odd Fibonacci Numbers

給一個正整數num，返回小於或等於num的斐波納契奇數之和。斐波納契數列中的前幾個數字是一、一、二、三、5 和 8，隨後的每個數字都是前兩個數字之和。

function sumFibs(num) {
  if(num < 0) {
    return undefined;
  }
  var sumOdds = 0; // Sum of all odd fib numbers
  for(var n1 = 0, n2 = 1, temp; n2 <= num; temp = n2, n2 += n1, n1 = temp) {
    sumOdds += n2 * (n2 % 2);
  }
  return sumOdds;
}

sumFibs(4);

// ---------
function sumFibs(num) {
  var prevNumber = 0;
    var currNumber = 1;
    var result = 0;
    while (currNumber <= num) {
        if (currNumber % 2 !== 0) {
            result += currNumber;
        }

        currNumber += prevNumber;
        prevNumber = currNumber - prevNumber;
    }

    return result;
}

Finders Keepers

寫一個 function，它遍歷數組 arr，並返回數組中第一個知足 func 返回值的元素。舉個例子，若是 arr 爲 [1, 2, 3]，func 爲 function(num) {return num === 2; }，那麼 find 的返回值應爲 2。

function find(arr, func) {
  filterArr = arr.filter(func); //filter array with the function provided
  return filterArr[0]; 
}

find([1, 2, 3, 4], function(num){ return num % 2 === 0; });

Drop it

讓咱們來丟棄數組(arr)的元素，從左邊開始，直到回調函數return true就中止。

第二個參數，func，是一個函數。用來測試數組的第一個元素，若是返回fasle，就從數組中拋出該元素(注意：此時數組已被改變)，繼續測試數組的第一個元素，若是返回fasle，繼續拋出，直到返回true。

最後返回數組的剩餘部分，若是沒有剩餘，就返回一個空數組。

function drop(arr, func) {
  // drop them elements.
  var times = arr.length;
  for (var i = 0; i < times; i++) {
    if (func(arr[0])) {
      break;
    } else {
      arr.shift();
    }
  }
  return arr;
}

drop([1, 2, 3], function(n) {return n < 3; });

// 方法2
function drop(arr, func) {
    return arr.slice(arr.findIndex(func) >= 0 ? arr.findIndex(func): arr.length, arr.length);
}

// 方法3
function drop(arr, func) {
  while(arr.length > 0 && !func(arr[0])) {
    arr.shift();
  }
  return arr;
}

Steamroller

對嵌套的數組進行扁平化處理。你必須考慮到不一樣層級的嵌套。

steamroller([[["a"]], [["b"]]]) 應該返回 ["a", "b"]。

steamroller([1, [2], [3, [[4]]]]) 應該返回 [1, 2, 3, 4]。

function steamroller(arr) {
  var flattenedArray = [];
  // Create function that adds an element if it is not an array.
  // If it is an array, then loops through it and uses recursion on that array.
  var flatten = function(arg) {
    if (!Array.isArray(arg)) {
      flattenedArray.push(arg);
    } else {
      for (var a in arg) {
        flatten(arg[a]);
      }
    }
  };
  // Call the function for each element in the array
  arr.forEach(flatten);
  return flattenedArray;
}

steamroller([1, [2], [3, [[4]]]]);

// 方法2
function steamroller(arr) {
  return arr.toString()
    .replace(',,', ',')       // "1,2,,3" => "1,2,3"
    .split(',')               // ['1','2','3']
    .map(function(v) {
      if (v == '[object Object]') { // bring back empty objects
        return {};
      } else if (isNaN(v)) {        // if not a number (string)
        return v;
      } else {
        return parseInt(v);         // if a number in a string, convert it
      }
    });
}

Everything Be True

完善編輯器中的every函數，若是集合(collection)中的全部對象都存在對應的屬性(pre)，而且屬性(pre)對應的值爲真。函數返回ture。反之，返回false。

function every(collection, pre) {
  // Is everyone being true?
  return collection.every(obj => obj[pre]);
}

every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, 
  {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");

// 方法2
function every(collection, pre) {
  return collection.every(function (element) {
    return element.hasOwnProperty(pre) && Boolean(element[pre]);
  });
}

// 方法3
function every(collection, pre) {
  // Create a counter to check how many are true.
  var counter = 0;
  // Check for each object
  for (var c in collection) {
    // If it is has property and value is truthy
    if (collection[c].hasOwnProperty(pre) && Boolean(collection[c][pre])) {
      counter++;
    }
  }
  // Outside the loop, check to see if we got true for all of them and return true or false
  return counter == collection.length;
}

Arguments Optional

建立一個計算兩個參數之和的 function。若是隻有一個參數，則返回一個 function，該 function 請求一個參數而後返回求和的結果。

例如，add(2, 3) 應該返回 5，而 add(2) 應該返回一個 function。

function add() {
  // Function to check if a number is actually a number
  // and return undefined otherwise.
  var checkNum = function(num) {
    if (typeof num !== 'number') {
      return undefined;
    } else
      return num;
  };

  // Check if we have two parameters, check if they are numbers
  // handle the case where one is not
  // returns the addition.
  if (arguments.length > 1) {
    var a = checkNum(arguments[0]);
    var b = checkNum(arguments[1]);
    if (a === undefined || b === undefined) {
      return undefined;
    } else {
      return a + b;
    }
  } else {
    // If only one parameter was found, returns a new function that expects two
    // Store first argument before entering the new function scope
    var c = arguments[0];

    // Check the number again, must be outside the function to about returning an object
    // instead of undefined.
    if (checkNum(c)) {
      // Return function that expect a second argument.
      return function(arg2) {
        // Check for non-numbers
        if (c === undefined || checkNum(arg2) === undefined) {
          return undefined;
        } else {
          // if numbers then add them.
          return c + arg2;
        }
      };
    }
  }
}

add(2,3);

// 方法2
function add() {
  var args = Array.from(arguments);
  return args.some(n => typeof n !== 'number') ? 
    undefined: 
    args.length > 1 ?
      args.reduce((acc, n) => acc += n, 0):
      (n) => typeof n === "number" ? 
        n + args[0]:
        undefined;
}