澳门葡京备用网址，

1、数组的成立

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

array_filter($arr, ‘filter_func’);

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

定义

//参数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);

即使在第三种概念格局中指定了数CEO度是 3 ，但数组的长短依然可变。

var a = new Array(3);
a[4]=function (arg) {
    return "run is a4";
}// 虽然数组在定义时指定了长度为 3 ，但这里依旧操作了下标为 4 的元素
alert(a[4]());

其三种艺术不仅开创了一个数组，而且向数组中储存了 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

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、数组元素的拉长

排序

reverse() ：将原数组逆序。
sort(function)：依据指定的不二法门对数组中的元素举行排序。该格局截至后，原数组会变化。

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

一而再与截取

concat()：重返一个新数组，该数组中的元素为与 push
时同样。即使不传参数，相当于对原数组开展复制。
join：以参数为连接符，连接数组中各个要素，该格局并不会影响数组本身。默认是逗号。
```
var o = ['a','b'];
alert(o); // a,b
alert(o.join('-')); // a-b
alert(o); ////输出的依旧 a,b
```

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

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 ]]]]);//
将一个或多少个新因素添加到数组开头，数组中的元素自动后移，重返数组新长度

要素操作

every()：对数组中的每一个因素举办点名的函数操作。要是每一个要素都回去true，那么every方法重回true；否则重回false。
some()：类似于every()，但假如有一个因素重返true，该措施就会回去true，否则再次回到false。
filter()：过滤。遍历数组，对每一个要素执行指定的点子，并将函数再次回到为true的元素保留到新数组中，最终将新数组重临。
forEach()：遍历。遍历数组，并对每一元素执行指定方法。无重返值，且不操作数组本身。
map()：映射。遍历数组，并对每一个要素执行指定的办法，将艺术再次回到值存储到新数组中，并且将新数组重临。
```
window.onload=function(){
    var a =[4,5,66];  
    var result = a.map(function(value,index,array){  
        return value * 2;  
    });  
    alert(result);
}
```
map的参数便是点名的章程，它的参数是永恒的。首个指当前因素，第三个指元素的下标，第五个指元素所在的数组。
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); 
});

$.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)+'个重复元素')

$.makeArray(obj) 将类数组对象转换为数组[不常用]
释疑: 将类数组对象转换为数组对象, 类数组对象有 length
属性,其成员索引为0至 length-1.
这是个多余的办法, 神通广大的$本来就富含了这么些功用.
jQuery官网上诠释的不得了模糊. 其实,
它就是将某个类数组对象(比如用getElementsByTagName获取的要素对象集合)转换成数组对象.

var _makeArr=$.makeArray(h2obj);
alert(‘h2元素对象集合的数据类型转换为: ‘+_makeArr.constructor.name);//输出Array
$(dom).toArray()将所有DOM元素恢复生机成数组[不常用]

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

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

参考：

数组操作，数组元素过滤

定义

new Array 形式

[] 形式

length 属性

常用方法

push pop

shift 与 unshift

排序

一而再与截取

要素操作

补充

Array 也属于 Object

相关文章

发表评论取消回复

定义

new Array 形式

[] 形式

length 属性

常用方法

push pop

shift 与 unshift

排序

一而再与截取

要素操作

补充

Array 也属于 Object

相关文章

发表评论 取消回复

发表评论取消回复