JavaScript数组笔记：(4)实战案例（JavaScript）

快速交换

有两个变量，设计交换它们的值，简单的做法是：

ar a=10,b=13;
var temp=a;
a=b;
b=temp;
alert("a等于"+a+"；\nb等于"+b);

利用数组实现交换两个变量的值。

var a=10;
var b=13;
var a=[b,b=a][0];
alert("a等于"+a+"；\nb等于"+b);

数组下标

数组下标必须是大于等于0的整数，也可以是表达式，甚至可以是任意类型的数据。

扩展数组方法

Array内置了很多方法，但是它无法满足所有用户的需求，这时可以为Array对象扩展方法，提高代码重用率。扩展数组的方法一般通过为Array对象定义原型方法来实现。这些原型方法能够被所有数组对象继承。

Array.prototype.f=function(){	//定义Array对象的原型方法
	alert("hello!);
}

说明：
Array是数组构造函数，prototype是构造函数的属性，由于该属性指向一个原型对象，然后通过运算符为其定义属性或方法，这些属性和方法将被构造函数的所有实例对象继承。
数组对象定义了一个原型方法 f()，这样可以在任意一个数组调用该方法。

• 设计一种安全的、可兼容的数组扩展方法模式：

Array.prototype._m=Array.prototype.m||(Array.prototype.m=function(){
	//扩展方法的具体代码
});
Object.prototype.m=Array.prototype._m;

• 为数组扩展一个求属于元素和的方法。

Array.prototype._sum=Array.prototype.sum||(Array.prototype.sum=function(){
	var _n=0;
	for(var i in this){
		if(this[i]=parseFloat(this[i]))
			_n+=this[i];
	};
	return _n;
});
Object.prototype.sum=Array.prototype._sum;

var s=[1,2,3,4,5,6,7,8,"9"];
alert(s.sum());

设计迭代器

迭代器（Iterator）提供了一种对数据集合中每个元素执行重复操作的机制，通常与循环结构配合使用，因此也称为循环器，它能够根据传递的函数型参数，为集合中每个元素反复执行相同的命令，直到满足某些条件为止。迭代器通常用于迭代数组的值，或者执行重复的任务。

设计一个迭代器，把可执行的函数作为参数传递给迭代器，让它帮助自动完成在每个元素上调用函数任务。

Array.prototype.each=function(f){
	try{
		this.i||(this.i=0);
		if(this.length>0&&f.constructor==Function){
			while (this.i<this.length){
				var e=this[this.i];
				if(e&&e.constructor==Array){
					e.each(f);
				}else{
					f.apply(e,[e]);
				}
				this.i++;
			}
			this.i=null;
		}
	}
	catch(w){}
	return this;
}

var a=[1,[2,[3,4]]];
var f=function(x){
	alert(x);
}
a.each(f);	//返回1    2     3    4

使用迭代器

为Array对象扩展了一个迭代器之后就可以利用这个迭代器进一步扩展Array的方法，使其能够完成更多使用功能。

• 动态改变数组中每个元素的值。

Array.prototype.each=function(f){
	try{
		this.i||(this.i=0);
		if(this.length>0&&f.constructor==Function){
			while (this.i<this.length){
				var e=this[this.i];
				if(e&&e.constructor==Array){
					e.each(f);
				}else{
					f.apply(e,[e]);
				}
				this.i++;
			}
			this.i=null;
		}
	}
	catch(w){}
	return this;
}

Array.prototype._edit=Array.prototype.edit||(Array.prototype.edit=function(){
	var b=arguments;
	var a=[];
	this.each(function(){
		a.push(b[0].call(b[1],this))
	});
	return a;
});

Object.prototype.edit=Array.prototype._edit;

var a=[1,2,3,4];
var f=function(x){
	return x*x;
}

var b=a.edit(f);
alert(b);

• 过滤数组元素。

实现过滤数组元素功能，可以考虑调用迭代器，遍历数组元素，然后定义一个过滤函数，对每个元素进行检测。如果满足条件，则返回false。最后把过滤函数传递给迭代器即可实现过滤数组元素的目的。

Array.prototype._filter=Array.prototype.filter||(Array.prototype.filter=function(){
	var b=arguments,a=[];
	this.each(function(){
		if(b[0].call(b[1],this))
		a.push(this);
	});
	return a;
});
Object.prototype.filter=Array.prototype._filter;

var a=[1,2,3,4,5,6,7,8,9];
var f=function(x){
	if(x>4)
	return true;
}

var b=a.filter(f);	//调用数组元素过滤方法
alert(b);

使用数组维度

在JavaScript中，数组在默认状态下是不会初始化。如果使用[]运算符创建一个新数组，那么此数组将是空的。如果访问的是数组中不存在的元素，则会得到的值将是undefined。因此，在JavaScript程序设计中，在读取每个元素之前，都应该预先设置它的值。

• 自定义一个静态函数。创建一个包含100个0的数组。

Array.dim=function(dimension,initial){
	var a=[],i;
	for(i=0;i<dimension;i+=1){
		a[i]=initial;
	}
	return a;
}
var myArray=Array.dim(100,0);
alert(myArray);

• 定义一个矩阵数组定义函数。

Array.matrix=function(m,n,initial){
	var a,i,j,mat=[];
	for(i=0;i<m;i+=1){
		a=[];
		for(j=0;j<n;j+=1){
			a[j]=initial;
		}
		mat[i]=a;
	}
	return mat;
};
var myMatrix=Array.matrix(5,5,1);
alert(myMatrix[2][3]);