{ 数组 丨 字符串 丨 数学函数}

数组方法

• 模拟堆栈

  • 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;
  }