数组操作,数组元素过滤

 

澳门葡京备用网址, 

1、数组的成立

数组的长度可变,元素类型可变。数组本身照旧是 Object
类型,对一个数组变量举办 typeof ,获得的字符串是 object。

array_filter($arr, ‘filter_func’);

array_filter($arr, ‘filter_func’);

var arrayObj = new Array(); //成立一个数组

定义

//参数1,要过滤的数组

//参数1,要过滤的数组

var arrayObj = new
Array([size]); //创设一个数组并指定长度,注意不是上限,是长度

new Array 形式

有如下二种概念方式:

var a1 = new Array()
var a2 = new Array(3);
var a3 = new Array('fd',
                    function (arg) {
                        return 'run is array'
                    },
                    3,
                    { name:'array element' }
                ); // 元素类型各不相同
alert(a1);
alert(a2); // 会输出两个逗号,表示一共有三个元素——各个元素通过逗号分隔
alert(a3);
  1. 即使在第三种概念格局中指定了数CEO度是 3 ,但数组的长短依然可变。

    var a = new Array(3);
    a[4]=function (arg) {
        return "run is a4";
    }// 虽然数组在定义时指定了长度为 3 ,但这里依旧操作了下标为 4 的元素
    alert(a[4]());
    
  2. 其三种艺术不仅开创了一个数组,而且向数组中储存了 4 个因素。

//参数2,过滤的函数,重回false时,不添加这一个因素,重临true添加那一个因素。

//参数2,过滤的函数,重回false时,不添加那几个因素,重返true添加那一个因素。

var arrayObj = new Array([element0[, element1[, …[,
elementN]]]]); 创立一个数组并赋值

[] 形式

如下:

var a = []; // 创建一个空数组
a[1] = {}; // 通过下标形式为元素指定值
alert(a);

var a2 = ['name',10] // 创建一个数组,同时指定两个元素值 
alert(a2);


   
要验证的是,纵然第三种格局创造数组指定了长短,但实际所有情形下数组都是变长的,也就是说即便指定了长短为5,还是能将元素存储在规定长度以外的,注意:那时长度会随着更改。

length 属性

获取数组的长短。数组本身也是一个目的,所以对目的的其余操作方法都可以用于数组。由于
length 是数组中的一个特性,所以length 也可被赋值

var a2 = ['name',10] 
var a2 = ['name',10] 
alert(a2.length);
a2[10] = 10;
alert(a2.length); // 11,因为上句为下标为 10 的元素赋值

var a3 =[];
a3.length = 20; // 为数组的 length 属性强制赋值。
alert(a3);

 

 

数组操作,数组元素过滤。2、数组的元素的拜会

常用方法

以身作则代码:

演示代码:

var testGetArrValue=arrayObj[1]; //获取数组的元素值

push pop

使数组具备栈的机能。push 将元素添加到数组的结尾,pop
弹出末尾元素。push 重回修改后的数老总度,pop 再次回到末尾元素。

 

 

arrayObj[1]= “那是新值”; //给数组元素赋予新的值

shift 与 unshift

  1. shift:移除数组中首先个因素,再次来到的是移除的元素值。与 push
    结合,可以使数组具备队列功效

    2.unshift:向数组的最前端添加一个元素,重返的是修改后数组的尺寸。
/***********array_filter(用回调函数过滤数组中的单元)*****************/
$arr = array();
for ($i = 0; $i < 10; $i++) {
        array_push($arr, $i);
}
$arrOdd = array_filter($arr, 'odd');
var_dump($arrOdd);
echo '<hr/>';
$arrEven = array_filter($arr, 'even');
var_dump($arrEven);

/**
 * 是否是奇数
 */
function odd($num) {
        return $num & 1;
}

/**
 * 是否是偶数
 */
function even($num) {
        return !($num & 1); 
}
/***********array_filter(用回调函数过滤数组中的单元)*****************/
$arr = array();
for ($i = 0; $i < 10; $i++) {
        array_push($arr, $i);
}
$arrOdd = array_filter($arr, 'odd');
var_dump($arrOdd);
echo '<hr/>';
$arrEven = array_filter($arr, 'even');
var_dump($arrEven);

/**
 * 是否是奇数
 */
function odd($num) {
        return $num & 1;
}

/**
 * 是否是偶数
 */
function even($num) {
        return !($num & 1); 
}

3、数组元素的拉长

排序

  1. reverse() :将原数组逆序。

  2. sort(function):依据指定的不二法门对数组中的元素举行排序。该格局截至后,原数组会变化。

 

 

arrayObj. push([item1 [item2 [. . . [itemN ]]]]);//
将一个或多少个新因素添加到数组结尾,并赶回数组新长度

一而再与截取

  1. concat():重返一个新数组,该数组中的元素为与 push
    时同样。即使不传参数,相当于对原数组开展复制

  2. join:以参数为连接符,连接数组中各个要素,该格局并不会影响数组本身。默认是逗号。

    var o = ['a','b'];
    alert(o); // a,b
    alert(o.join('-')); // a-b
    alert(o); ////输出的依旧 a,b
    
  3. slice() :
    截取数组的子串,并形成一个新数组重临。如果指定了八个参数,则含头不含尾。

    var o = [];
    for(x = 0;x<10;x++){
        o[x] = x;
    }
    alert(o.slice(2,5)); //2,3,4。参数中的2,5指的是截取原数组的起始、结束的下标。
    alert(o); // 0 到 9
    
  4. splice()
    轮换数组中指定地点的因素。依据参数的例外,它敢抱有删除、添加效用。

    var o = [1,2,3,4,5];
    
    o.splice(2,1,'aa');  // 第二个参数指的是要操作的元素的长度,它不是结束下标。
    alert(o);// 1,2,aa,4,5
    

    上述代码,会从下标为 2 的因素开始(含),取出长度为 1
    的要素,将那些要素交替 成 aa 。

    因而,若是第三个参数为
    0,就相当于向原数组中插入第五个因素;即使没有第多个要素,就相当于从原数组中剔除前多个元素指定的块。

    var o = [1,2,3,4,5];
    o.splice(2,1); // 相当于删除了从下标 2 开始,长度为 1 的一块元素
    alert(o);//1,2,4,5
    
    o = [1,2,3,4,5];
    o.splice(2,0,'a','b'); // 相当于从下标 2 开始,今次插入后面的元素。
    alert(o);//1,2,a,b,3,4,5
    

arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);//
将一个或多少个新因素添加到数组开头,数组中的元素自动后移,重返数组新长度

要素操作

  1. every():对数组中的每一个因素举办点名的函数操作。要是每一个要素都回去true,那么every方法重回true;否则重回false。

  2. some():类似于every(),但假如有一个因素重返true,该措施就会回去true,否则再次回到false。

  3. filter():过滤。遍历数组,对每一个要素执行指定的点子,并将函数再次回到为true的元素保留到新数组中,最终将新数组重临。

  4. forEach():遍历。遍历数组,并对每一元素执行指定方法。无重返值,且不操作数组本身。

  5. map():映射。遍历数组,并对每一个要素执行指定的办法,将艺术再次回到值存储到新数组中,并且将新数组重临。

    window.onload=function(){
        var a =[4,5,66];  
        var result = a.map(function(value,index,array){  
            return value * 2;  
        });  
        alert(result);
    }
    

    map的参数便是点名的章程,它的参数是永恒的。首个指当前因素,第三个指元素的下标,第五个指元素所在的数组。

  6. reduce()与reduceRight():遍历数组,只不过后边一个是从右往左遍历。其重回值为尾声一个要素时办法的重临值。如:

    window.onload=function(){
        var a =[4,5,66];  
        var result = a.reduce(function(pre,cur,index,array){  
            log(pre+","+cur)
            return pre*2+cur;  
        });  
        alert(result);//result = 92
    
        result = a.reduceRight(function(pre,cur,index,array){  
            log(pre+","+cur)
            return pre*2+cur;  
        });  
        alert(result);//result = 278
    }
    

    reduce()参数的格式固定。第三个参数为当下因素的上一次艺术的重回值,首个参数为眼前元素,第几个为下标,第八个为数组。

    • reduce(),第五回调用函数中 pre 为率先上元素。
    • reduceRight(),第四遍调用函数时,pre 为尾声一次元素。

arrayObj.splice(insertPos,0,[item1[, item2[, . . .
[,itemN]]]]);//将一个或三个新因素插入到数组的指定地点,插入地点的因素自动后移,重返””。

补充

4、数组元素的删减

Array 也属于 Object

因为 Array 也是 Object,所以上边的赋值方法也是足以的:

var a =[];
a['name']='name';
a['age']=18;
alert(a['name']+"----"+a[0]);// 最后输出的是 undefined

因为数组本身也是目标,所以第二、三句赋值时,将变量 a
根据目标开展处理,即:为变量 a 定义 name 与 age 七个特性,并分别赋值为
name 与 18。此时并不曾为数组 a 定义元素,所以 a[0] 输出 undefined。

一经添加上下述代码:

a[0] = 'array';
alert(a['name']+"----"+a[0]);// 分别输出 name 与 array
alert(a.length); // 1

先是句中为 a 定义了一个要素,那并不影响 a 作为一个对象中已具有的性质(即
name 与 age)。所以输出时,分别出口了 name 与 array 八个值。

数组的品质并不算作 length,所以经过 length 输出时,结果仍然是 1。

arrayObj.pop(); //移除最终一个因素并赶回该元素值

arrayObj.shift(); //移除最前一个因素并重临该元素值,数组中元素自动前移

arrayObj.splice(deletePos,deleteCount);
//删除从指定地方deletePos早先的指定数量deleteCount的元素,数组格局重回所移除的因素

5、数组的截取和合并

arrayObj.slice(start, [end]);
//以数组的方式再次回到数组的一有些,注意不包括 end 对应的因素,若是简单 end
将复制 start 之后的保有因素

arrayObj.concat([item1[, item2[, . . . [,itemN]]]]);
//将八个数组(也足以是字符串,或者是数组和字符串的良莠不齐)连接为一个数组,再次来到连接好的新的数组

6、数组的正片

arrayObj.slice(0); //重临数组的拷贝数组,注意是一个新的数组,不是指向

arrayObj.concat(); //再次来到数组的拷贝数组,注意是一个新的数组,不是指向

7、数组元素的排序

arrayObj.reverse();
//反转元素(最前的排到最终、最后的排到最前),重返数组地址

arrayObj.sort(); //对数组元素排序,再次来到数组地址

8、数组元素的字符串化

arrayObj.join(separator);
//再次来到字符串,这一个字符串将数组的每一个元素值连接在一道,中间用 separator
隔开。

toLocaleString 、toString 、valueOf:可以作为是join的异样用法,不常用

9.过滤数组

 $.grep(array, callback, [invert])
过滤数组,此函数至少传递七个参数(第二个参数为true或false,表示是不是取反):
待过滤数组和过滤函数. 过滤函数必须重返 true 以保存元素或 false
以删除元素

   grep(array,callback,invert)

  • array:待过滤数组;
  • callback:处理数组中的每个元素,并过滤元素,该函数中包括五个参数,第二个是当下数组元素的值,一个是当下数组元素的下标,即元素索引值,,此函数应重返一个布尔值
    如$.grep(arr,function(value,index){return
    index>1;});。别的,此函数可设置为一个字符串,当设置为字符串时,将视为“lambda-form”(缩写格局?),其中
    a 代表数组元素,i 代表元素索引值。如“a > 0”代表“function(a){
    return a > 0; }”
  • invert:布尔型可挑选,默许值false,值为true或false。 即便 “invert”
    为 false 或为设置,则函数重返数组中由过滤函数重临 true
    的元素,当”invert” 为 true,则赶回过滤函数中回到 false 的因素集。

  

扩展:

1.接纳grep删除指定值

var arr = [1, 2, 3, 4, 5];
var removeItem = 2;
     arr = $.grep(arr, function(value) {
    return value != removeItem;
});

 2.数组遍历

差别于例遍 jQuery 对象的 $().each()
方法,此方法可用来例遍任何对象(不仅仅是数组哦~).
回调函数拥有三个参数:第四个为目的的分子或数组的目录,
首个为对应变量或内容. 尽管急需退出 each 循环可使回调函数重返 false,
别的重返值将被忽略

var _mozi=['墨家','墨子','墨翟','兼爱非攻','尚同尚贤']; //本文所用到的数组, 下同 
$.each(_mozi,function(key,val){ 
    //回调函数有两个参数,第一个是元素索引,第二个为当前值 
    alert('_mozi数组中 ,索引 : '+key+' 对应的值为: '+val); 
}); 
  1. $.map(array,[callback])按给定条件转移数组 [一般]
    演说:作为参数的更换函数会为各类数组元素调用,
    而且会给这几个转换函数传递一个表示被撤换的要素作为参数.
    转换函数可以回到转换后的值、null(删除数组中的项目)或一个包蕴值的数组,
    并扩张至原始数组中.
    其一是个很有力的点子,但并不常用.
    它可以根据特定条件,更新数组元素值,或基于原值扩充一个新的副本元素.

    var _mapArrA=$.map(_mozi,function(val){

     return val+'[新加]';
    

    });
    var _mapArrB=$.map(_mozi,function(val){

     return val=='墨子' ? '[只给墨子加]'+val : val;
    

    });
    var _mapArrC=$.map(_mozi,function(val){

     //为数组元素扩展一个新元素
     return [val,(val+'[扩展]')];
    

    });
    alert(‘在各样元素前边加\'[新加]\’字符后的数组为: ‘+ _mapArrA);
    alert(‘只给元素 墨翟 添加字符后的数组为: ‘+ _mapArrB);
    alert(‘为原数组中每个元素,增加一个添加字符\'[新加]\’的要素,重临的数组为 ‘+_mapArrC);

4 .$.inArray(val,array)判断值是还是不是留存于数组中[常用]

表明: 确定第二个参数在数组中的地点, 从0起先计数(假设没有找到则赶回 -1
).
记 得indexOf()方法了吧?
indexOf()重回字符串的首次面世岗位,而$.inArray()重回的是传播参数在数组中的地点,同样的,假设找到的,重回的是一个高于或等于0
的值,若未找到则赶回-1.

var _exist=$.inArray('墨子',_mozi);
var _inexistence=$.inArray('卫鞅',_mozi)
if(_exist>=0){
    alert('墨子 存在于数组_mozi中,其在数组中索引值是: '+_exist);
}
if(_inexistence<0){
    alert('卫鞅 不存在于数组_mozi中!,返回值为: '+_inexistence+'!');
} 

5 .$.merge(first,second)合并四个数组[一般]

分解:
重返的结果会修改首个数组的情节——第四个数组的要素后边随着第一个数组的元素.
以此办法是用jQuery的法门替代原生concat()方法, 但作用并不曾concat()强大,
concat()可以而且统一多少个数组.

//原生concat()可能比它还简洁点
_moziNew=$.merge(_mozi,['鬼谷子','商鞅','孙膑','庞涓','苏秦','张仪'])
alert('合并后新数组长度为: '+_moziNew.length+'. 其值为: '+_moziNew); 

6 .$.unique(array)过滤数组中重复元素[不常用]
诠释: 删除数组中再度元素.
只处理删除DOM元素数组,而无法处理字符串或者数字数组.

var _h2Arr=$.makeArray(h2obj);
//将数组_h2Arr重复一次
_h2Arr=$.merge(_h2Arr,_h2Arr);
var _curLen=_h2Arr.length;
_h2Arr=$.unique(_h2Arr);
var _newLen=_h2Arr.length;
alert('数组_h2Arr原长度值为: '+_curLen+' ,过滤后为: '+_newLen+' .共过滤 '+(_curLen-_newLen)+'个重复元素') 
  1. $.makeArray(obj) 将类数组对象转换为数组[不常用]
    释疑: 将类数组对象转换为数组对象, 类数组对象有 length
    属性,其成员索引为0至 length-1.
    这是个多余的办法, 神通广大的$本来就富含了这么些功用.
    jQuery官网上诠释的不得了模糊. 其实,
    它就是将某个类数组对象(比如用getElementsByTagName获取的要素对象集合)转换成数组对象.

    var _makeArr=$.makeArray(h2obj);
    alert(‘h2元素对象集合的数据类型转换为: ‘+_makeArr.constructor.name);//输出Array

  2. $(dom).toArray()将所有DOM元素恢复生机成数组[不常用]

释疑: 把jQuery集合中颇具DOM元素恢复生机成一个数组; 并不常用的章程,
个人依然以为它和$.makeArray一样多余.

var _toArr=$('h2').toArray();
alert('h2元素集合恢复后的数据类型是: '+_toArr.constructor.name);

参考:

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website