數組方法

• 模擬堆棧

  • push 在數組尾部添加數據

arr.push( 需要添加的元素，不添加也不報錯 ): 返回數組的元素個數

      var a = [1];
      a.push('abc') //2
      console.log(a);//[1,'abc'];

• pop 刪除數組 最后一個元素

arr.pop (不需放值，放了不報錯也不生效 ): 返回被刪除的元素本身

     var a = [1,2,3];
     a.pop() //3
     console.log(a);//[1,2];

• 模擬隊列

• unshift 在數組頭部添加數據

arr.unshift ( 需要添加的元素，不添加也不報錯 ) // 返回數組的元素個數

     var a = [1,2,3];
     a.unshift(4,5) //5
     console.log(a);//[4,5，1,2，3];

• shift 刪除數組 第一個元素

arr.shift ( 不需放值，放了不報錯也不生效 ) // 返回被刪除的元素本身

     var a = [1,2,3];
     a.shift(4,5) //2
     console.log(a);//[1,2];

• 連接分割

• join 把參數作為分隔符，數組所有元素連接成一個字符串返回

arr.join ( 放入分隔符，不放默認為逗號 ) // 返回字符串

     var a = [1, 2, 3, 4];
     a.join(' ') // '1 2 3 4'
     a.join(' | ') // "1 | 2 | 3 | 4"
     a.join() // "1,2,3,4"

• split 按規則分割字符串，返回一個由分割出來的子字符串組成的數組

'輸入字符串'.split('輸入分隔符') // 返回數組

    例子

• splice

• 一次完成添加刪除
  arr.splice ( 位置,數量,項目,.....,項目) // [返回被刪除的項目組成的數組]----> 替換
  arr.splice ( 位置, 0 ,項目,.....,項目) -----> 添加
  arr.splice ( 位置,數量) -------------------------> 刪除
  var a = [1, 2, 3, 4, 5];

   a.splice(2,1,6) // [3]   ----------------> 替換
   console.log(a) // [1, 2, 6, 4, 5]
  
   a.splice(2,0,6) // [3]   -----------------> 添加
   console.log(a) // [1, 2, 6, 3, 4, 5]        
  
   a.splice(2,0) // [3]   -------------------> 刪除
   console.log(a) // [1, 2, 4, 5]    
  

• tips：
  1位置=絕對索引數 而不是相對于數組索引
  2數量=刪除執行次數而不是刪除元素的個數
  var a = new Array();
  a[2]=2; a[3]=3; a[7]=4; a[8]=5;
  console.log(a)//[ 2, 3, 4, 5]
  //即[undefined, undefined, 2, 3, undefined, undefined, undefined, 4, 5]
  console.log(a.splice(3,4)); //[3]
  console.log(a)//[ 2, 4, 5]
  //即[undefined, undefined, 2, 4, 5]

• 應用
  用splice 完成實現 push、pop、shift、unshift方法

  function push(arr, val) { 
  arr.splice(arr.length, 0, val);    -------> 末位 添加 -------> push
  return arr.length; 
  }
  
  function pop(arr) { 
  var tmpArr = arr.splice(arr.length - 1, 1); -------> 末位 刪除 -------> pop
  return tmpArr[0]; 
  }
  
  function shift(arr) { 
  var tmpArr = arr.splice(0, 1); -------> 首位 刪除 -------> shift
  return tmpArr[0]; 
  } 
  
  function unshift(arr, val) { 
  arr.splice(0, 0, val); -------> 首位 添加 -------> unshift
  return arr.length; 
  }
  

數組遍歷

• for 循環
  var a = [1, 2, 3];
  for(var i = 0; i < a.length; i++) {
  console.log(a[i]);
  }

• while 循環
  var a = [1, 2, 3];

  var i = 0;  ----------------->正向遍歷
  while (i < a.length) { 
  console.log(a[i]);
   i++;
  }
  
  var l = a.length;  ----------->逆向遍歷
  while (l--) { 
  console.log(a[l]);
  }
  

• for …in 循環
  由于 for …in 不但遍歷數字鍵，還遍歷非數字鍵，所以不推薦

應用

數組

• 使用數組拼接出 字符串
  <dl class="product">
  <dt>女裝</dt>
  <dd>短款</dd>
  <dd>冬季</dd>
  <dd>春裝</dd>
  </dl>
  顯示列表：拼接html標簽，遍歷項目內容
  var prod = {
  name: '女裝',
  styles: ['短款', '冬季', '春裝']
  };
  function getTplStr(data) {
  var tpl = '<dl class="product">';
  tpl += '<dt' + data.name + '</dt>';
  for (var i = 0; i < prod.styles.length; i++) {
  tpl += '<dd>' + data.styles[i] + '</dd>';
  }
  tpl += '</dl>';
  return tpl;
  }

• 寫一個find函數，實現下面的功能
  var arr = [ "test", 2, 1.5, false ]
  find(arr, "test") // 0
  find(arr, 2) // 1
  find(arr, 0) // -1

.indexOf(指定元素) // 返回 第一個指定元素的位置索引 or 沒有查找到返回-1

  function find(data,val){ 
  return data.indexOf(val); 
  }

• 寫一個函數filterNumeric，把數組 arr 中的數字過濾出來賦值給新數組newarr， 原數組arr不變
  arr = ["a", "b", 1, 3, 5, "b", 2];
  newarr = filterNumeric(arr); // [1,3,5,2]

.filter(function(element)) //
返回數組的一個子集，回調函數用于邏輯判斷是否返回，
返回true則把當前元素加入到返回數組中，false則不加
新數組只包含返回true的值，索引缺失的不包括，原數組保持不變

  arr = ["a", "b", 1, 3, 5, "b", 2]; 
  function filterNumberic(arr){ 
   return arr.filter(function(e){ 
        return typeof e === "number" 
        }) 
   }
  newarr = filterNumberic(arr); //[1,3,5,2]

• 對象obj有個className屬性，里面的值為的是空格分割的字符串(和html元素的class特性類似)，寫addClass、removeClass函數，有如下功能：
  var obj = {
  className: 'open menu'
  }
  addClass(obj, 'new') // obj.className='open menu new'
  addClass(obj, 'open') // 因為open已經存在，所以不會再次添加 open
  addClass(obj, 'me') // me不存在，所以 obj.className變為'open menu new me'
  console.log(obj.className) // "open menu new me"

  removeClass(obj, 'open') // 去掉obj.className里面的 open，變成'menu new me'
  removeClass(obj, 'blabla') // 因為blabla不存在，所以此操作無任何影響
  

addClass函數：

  var obj = { 
  className: 'open menu'
  }; 
  function addClass(obj,ele){ 
      var arr = obj.className.split(' ');  ------> 字符串拆成 數組
      for(i=0;i<arr.length;i++){          ------> 遍歷數組
         if (arr[i] === ele) {            ------>判斷參數是否存在
           return;                     ------>存在，返回原數組
         }else{                  
           arr.push(ele);           ------>不存在，末位加入參數
           obj.className = arr.join(' ');  ------>數組合并為 字符串
         } 
      }
  }

removeClass函數
var obj = {
className: 'open menu'
};
function removeClass(obj,ele){
var arr = obj.className.split(' '); ------> 字符串拆成 數組
if(arr.indexOf (ele) === -1){ ------> 搜索參數，是否存在
return; ------>不存在，返回原數組
}else{
arr.splice(arr.indexOf (ele) , 1 ); ------>存在，去掉此參數
obj.className = arr.join(' '); ------>數組合并為 字符串
}
}

• 寫一個camelize函數，把my-short-string形式的字符串轉化成myShortString形式的字符串?
  camelize("background-color") == 'backgroundColor'
  camelize("list-style-image") == 'listStyleImage'

去掉分隔符

  function camelize(data){
     var a = data.split('-'); 
     return a.join('')
  }

• 分析輸出結果
  arr = ["a", "b"]; //數組內有兩個元素
  arr.push( function() { //數組末尾添加一個匿名元素為函數
  alert(console.log('hello hunger valley'))
  } );
  arrarr.length-1 // 調用這個匿名函數,控制臺打印出 "hello hunger valley"
  因為是匿名函數，彈框顯示undefined

• 寫一個函數isPalindrome,判斷一個字符串是不是回文字符串

arr.reverse() // 返回一個倒序數組

  function isPalindrome(data){ 
    var arr = data.split(''); 
    if(data == arr.reverse( ).join('') ){ 
       return true; 
    }else{ 
       return false; 
    }
  }

• 寫一個ageSort函數實現數組中對象按age從小到大排序

array.sort( sortFunction ) 參數可選。規定排序順序。必須是函數。 參考

  var john = { name: "John Smith", age: 23 }
  var mary = { name: "Mary Key", age: 18 }
  var bob = { name: "Bob-small", age: 6 }
  var people = [ john, mary, bob ]
  ageSort(people) 

  function ageSort(data){
      data.sort( function(a,b){
          return a.age - b.age ;
      )}
  }
      console.log(people) ;

• 寫一個filter(arr, func) 函數用于過濾數組，接受兩個參數，第一個是要處理的數組，第二個參數是回調函數(回調函數遍歷接受每一個數組元素，當函數返回true時保留該元素，否則刪除該元素)。實現如下功能：
  console.log(people);
  function isNumeric (el){
  return typeof el === 'number';
  }
  arr = ["a",3,4,true, -1, 2, "b"]
  arr = filter(arr, isNumeric) ; // arr = [3,4,-1, 2], 過濾出數字
  arr = filter(arr, function(val) {
  return typeof val === "number" && val > 0
  }); // arr = [3,4,2] 過濾出大于0的整數
  function isNumber (el){
  return typeof el === 'number';
  }
  filter(arr, func)函數
  function filter(arr,func){
  new a = [];
  for (var i = 0; i < arr.length; i++) {
  if (typeof arr[i] === 'number') {
  newArr.push(arr[i]);
  }
  }
  return a;
  }

字符串

• 寫一個 ucFirst函數，返回第一個字母為大寫的字符
  ucFirst("hunger") == "Hunger"

str.toUpperCase() // 返回調用該方法的字符串值轉換為大寫形式

  function ucFirst(str){ 
     return str[0].toUpperCase()+str.slice(1,str.length);
  }

• 寫一個函數truncate(str, maxlength), 如果str的長度大于maxlength，會把str截斷到maxlength長，并加上...，如
  truncate("hello, this is hunger valley,", 10)) == "hello, thi...";
  truncate("hello world", 20)) == "hello world"
  truncate(str, maxlength)函數

  funtion tiun(str, maxlenght){
     var newstr 
      if(str.length <= maxlength){
         return str ;
         return newstr = str.slice(0 ,maxlength) + "…";
     }
  }
  

數學函數

• 寫一個函數，獲取從min到max之間的隨機整數，

rand(min,max) 函數返回隨機整數 (min,max可選。規定隨機數產生的范圍）

  包括min不包括max

  function getRandStr(min,max){ 
       return Math.floor(Math.random()*(max-min))
  }

  包括min包括max

  function getRandStr(min,max){ 
       return Math.floor(Math.random()*(max-min+1))+min
  }

• 獲取一個隨機數組，數組中元素為長度為len，最小值為min，最大值為max(包括)的隨機數
  function randArr(len, min, max) {
  var arr = [], randVal;
  for (var i = 0; i < arr.length; i++) {
  randVal = min + Math.floor(Math.random() * (max - min + 1));
  arr.push(randVal);
  } return randArr;
  }

• 寫一個函數，生成一個長度為 n 的隨機字符串，字符串字符的取值范圍包括0到9，a到 z，A到Z
  function getRandStr(len) {
  var retStr = '', randIdx, dict = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  for (var i = 0; i < len; i++) {
  randIdx = Math.floor(Math.random() * dict.length);
  retStr += dict[randIdx];
  }
  return retStr;
  }