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

数组方法

模拟堆栈
- 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;
}

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

数组方法

模拟堆栈

模拟队列

连接分割

splice

数组遍历

应用

数组

字符串

数学函数

推荐阅读更多精彩内容

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