javascript中数组、对象

javascript数组操作大全：

//shift：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 
var a = [1,2,3,4,5]; 
var b = a.shift(); //a：[2,3,4,5] b：1

//unshift：将参数添加到原数组开头，并返回数组的长度 
var a = [1,2,3,4,5]; 
var b = a.unshift(-2,-1); //a：[-2,-1,1,2,3,4,5] b：7 
注：在IE6.0下测试返回值总为undefined，FF2.0下测试返回值为7，所以这个方法的返回值不可靠，需要用返回值时可用splice代替本方法来使用

//pop：删除原数组最后一项，并返回删除元素的值；如果数组为空则返回undefined 
var a = [1,2,3,4,5]; 
var b = a.pop(); //a：[1,2,3,4] b：5

//push：将参数添加到原数组末尾，并返回数组的长度 
var a = [1,2,3,4,5]; 
var b = a.push(6,7); //a：[1,2,3,4,5,6,7] b：7

//concat：返回一个新数组，是将参数添加到原数组中构成的 
var a = [1,2,3,4,5]; 
var b = a.concat(6,7); //a：[1,2,3,4,5] b：[1,2,3,4,5,6,7]

//splice(start,deleteCount,val1,val2,...)：从start位置开始删除deleteCount项，并从该位置起插入val1,val2,... 
var a = [1,2,3,4,5]; 
var b = a.splice(2,2,7,8,9); //a：[1,2,7,8,9,5] b：[3,4] 
var b = a.splice(0,1); //同shift 
a.splice(0,0,-2,-1); var b = a.length; //同unshift 
var b = a.splice(a.length-1,1); //同pop 
a.splice(a.length,0,6,7); var b = a.length; //同push

//reverse：将数组反序 
var a = [1,2,3,4,5]; 
var b = a.reverse(); //a：[5,4,3,2,1] b：[5,4,3,2,1]

//sort(orderfunction)：按指定的参数对数组进行排序,sort将数组按字母顺序排序，排序过程会影响源数组
var a = [1,2,3,4,5]; 
var b = a.sort(); //a：[1,2,3,4,5] b：[1,2,3,4,5]

//slice(start,end)：返回从原数组中指定开始下标到结束下标之间的项组成的新数组 
var a = [1,2,3,4,5]; 
var b = a.slice(2,5); //a：[1,2,3,4,5] b：[3,4,5]

//join(separator)：将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符 
var a = [1,2,3,4,5]; 
var b = a.join("|"); //a：[1,2,3,4,5] b："1|2|3|4|5"

在JavaScript的数组中，数字下标最终会被解释器转化为字符串，也就是说，所谓的数字下标只不过是看着是数字而实际上是字符的属性名。在JavaScript里，数字下标和字符串下标都是“JavaScript数组”这种特殊对象的属性，比如：
var array = ["first", "second", "third"];  
print(array["0"]);//以字符串0为下标  
print(array[0]);//以数字0为下标  
它们会得到相同的结果：都为first。

JavaScript数组其实是将下标的数字转化成字符串，然后将这个字符串作为“数组”对象的属性来进行存取的。说白了，在存取属性上，它跟其他的对象并无二致。Array作为Object，接受key-value序列赋值时，只有当key可转为正整数，才有可能对length进行修改。用一个for..in就可以看到了。JavaScript的数组本质上还是键-值这样的形式(本质上就是一个对象)，而不是一个连续的内存块(C/Java中都是连续的)，而是一个散列表。
以下是两种实现数组删除元素的方式:

//法一：
Array.prototype.remove = function(from, to) {   
    var rest = this.slice((to || from) + 1 || this.length);   
    this.length = from < 0 ? this.length + from : from;   
    return this.push.apply(this, rest);   
};
var array = ["one", "two", "three", "four", "five", "six"];    
array.remove(0);//删除第一个元素  此时two,three,four,five,six   
array.remove(-1);//删除倒数第一个元素  此时two,three,four,five   
array.remove(0,2);//删除数组中下标为0-2的元素(3个)  此时five
//法二：
Array.remove = function(array, from, to) {   
    var rest = array.slice((to || from) + 1 || array.length);   
    array.length = from < 0 ? array.length + from : from;   
    return array.push.apply(array, rest);   
};
var array = ["one", "two", "three", "four", "five", "six"];   
Array.remove(array, 0, 2);//删除0, 1, 2三个元素   
Array.prototype.remove是对原型链做修改，这样的话，以后所有声明的Array对象就会带上remove方法(隐式的)，而Array.remove相当于Array的一个静态方法，这种形式不修改原型链。

数组去重复：

//Array类型并没有提供去重复的方法，如果要把数组的重复元素干掉，那得自己想办法：
function unique(arr) {
    var result = [], isRepeated;
    for (var i = 0, len = arr.length; i < len; i++) {
        isRepeated = false;
        for (var j = 0, len1 = result.length; j < len1; j++) {
            if (arr[i] == result[j]) {   
                isRepeated = true;
                break;
            }
        }
        if (!isRepeated) {
            result.push(arr[i]);
        }
    }
    return result;
}
//总体思路是把数组元素逐个搬运到另一个数组，搬运的过程中检查这个元素是否有重复，如果有就直接丢掉。从嵌套循环就可以看出，这种方法效率极低。我们可以用一个hashtable的结构记录已有的元素，这样就可以避免内层循环。恰好，在Javascript中实现hashtable是极为简单的，改进如下：
function unique(arr) {
    var result = [], hash = {};
    for (var i = 0, elem; (elem = arr[i]) != null; i++) {
        if (!hash[elem]) {
            result.push(elem);
            hash[elem] = true;
        }
    }
    return result;
}

数组是JavaScript提供的一个内部对象，它是一个标准的集合，我们可以添加(push)、删除(shift)里面元素，我们还可以通过for循环遍历里面的元素，那么除了数组我们在JavaScript里还可以有别的集合吗?

对象
由于JavaScript的语言特性，我们可以向通用对象动态添加和删除属性。所以Object也可以看成是JS的一种特殊的集合。
对象可以有属性，对象的属性可以是另外的对象；JavaScript对象的本身就是一个字典(dictionary)，或者Java语言中的Map，或者称为关联数组，即通过键来关联一个对象，这个对象本身又可以是一个对象，根据此定义，我们可以知道JavaScript对象可以表示任意复杂的数据结构。属性是由键值对组成的，即属性的名字和属性的值。属性的名字是一个字符串，而值可以为任意的JavaScript对象(JavaScript中的一切皆对象，包括函数)。比如，声明一个对象：

var object = {   
    field : "self",   
    getField : function(){   
       return this.field;   
    },   
    outter:{   
       inner : "inner text",
       field : "inner field",   
       getInfo : function(){   
           return this.inner + " and " +  this.field;   
       }   
    }   
}   
alert(object.getField());  //打印self
alert(object.outter.getInfo()); //打印inner text and inner field

下面比较一下Array和Object的特性:
Array:
新建:var ary = new Array(); 或 var ary = [];
增加:ary.push(value);
删除:delete ary[n]; //并不是真正意义上的删除，而是将第n项操作为了undefined，数组的长度并没有发生变化
遍历:for (var i=0 ; i<ary.length ;i++ ) ary[i];//或者for (var item in obj ) obj[item];（不建议使用for in）因为for in会把数组的所有的属性都会遍历出来，用length只访问数组有效项（属性可以转化为数字的），而不会访问哪些下标不是数字的元素
Object:
新建:var obj = new Object(); 或 var obj = {};
增加:obj[key] = value; (key为string)
删除:delete obj[key]; 或者 delete obj.name;
遍历:for (var key in obj ) obj[key];

对象操作：

/**
 * 新建对象
*/
//第一种方式：新建一个空对象
var obj = new Object();
//第二种方式：新建一个空对象
var obj1 = {};
//第三种方式：新建对象的同时，为对象赋属性值
var obj2 = {
  name:"JACK",
  age:23
};
 
/**
 * 为对象赋属性值
*/
//第一种方式：直接用.操作符
obj.name = "Jack";
obj.age = 23;
//第二种：使用[]
obj["sex"] = "F";
var k = "aaa";obj[k] = "p";//属性名使用变量
//第三种：循环赋值，带自变量的
for(var i=0; i<10; i++){
  obj["kind"+i] = i;
}
//第四种：运用eval()函数
var hello = "heihei";eval("obj.no="+"hello");
eval("obj.no2=3");
 
/**
 * 读取对象属性值
*/
//第一种方式：直接读取
var name = obj.name;
var age = obj.age;
//第二种方式：直接读取
var sex = obj["sex"];
var k = "aaa";var aaa = obj[k];//属性名使用变量
//第三种方式:循环取值，带自变量的
for(var i=0; i<10; i++){
  var ii = obj["kind"+i];alert(ii);
}
//第四种方式：运用eval()函数
var no = eval("obj.no");
var k = "no";var no2 = eval("obj." + k + 2);
var kind2 = eval("obj.kind"+2);
var k = "kind";var kind3 = eval("obj."+k+3);
 
alert("name=="+name);
alert("age=="+age);
alert("sex=="+sex);
alert("aaa=="+aaa);
alert("no=="+no);
alert("no2=="+no2);
alert("kind2=="+kind2);
alert("kind3=="+kind3);
 
/**
 * 删除对象的某个属性
*/
delete obj["name"];
 
/**
 * 遍历对象的所有属性
*/
for(var key in obj){
  alert("属性名：" + key + "   属性值：" + obj[key]);
}

/**
* 总结：其实为对象赋属性值与读取对象的属性值是同样的操作，
* 关键是：如何灵活多变的访问对象的属性
*/