Array
var arr = new Array();
var arr = new Array([size]);
var arr = new Array([element0[, element1[, …[, elementN]]]]);
size: 数组大小，建立的元素索引为0~size-1
element: 放置在数组中的元素，length为N+1
var arr = [1,2,3];
var newArr = new Array(arr);
console.log(JSON.stringify(newArr)); //[[1,2,3]]
arr[arr.length -1] = 0;
console.log(arr); //[1,2,0]
console.log(newArr); //[[1, 2, 0]]
| 属性 | 介绍 |
| length | 可以改变length值来拓展或阶段数组 |
| constructor | 可以用来判断是否为Array数组 |
| prototype | 不能改变原有的属性和方法，但可以扩展对象的属性和方法 |
Array.isArray(arr); //返回boolean值，判断是否为数组
| 方法 | 返回值 | 介绍 |
| concat([item1[, item2[, ……[, itemN]]]]) | 新的数组 | 将item或传入的数组中的元素放入数组的末尾 |
|
|
|
|
| every(callbackfn[, thisArg]) | 修改后的 | 对数组中元素呼叫callbackfn(value,index,arr), 直到返回false或到数组末尾 |
| some(callbackfn[, thisArg]) | 修改后的 | 对数组中元素呼叫callbackfn(value,index,arr), 直到返回true或到数组末尾 |
| forEach(callbackfn[, thisArg]) | 修改后的 | 对数组中的所有元素呼叫callbackfn |
| map(callbackfn[, thisArg]) | 新数组 | 对数组中的所有元素，呼叫callbackfn |
| filter(callback[, thisArg]) | 新数组 | 对数组中的所有元素呼叫callbackfn，将callback返回值为 true的元素放入新的数组 |
| reduce(callbackfn[, initialValue]) | 值 | 递增顺序对数组中的所有元素呼叫callback(previousValue, currentValue, currentIndex, arr), 前一个callbackfn的返回值作为下一个callbackfn的previousValue |
| reduceRight(callbackfn[, initialValue]) | 值 | 以递减顺序，其他同上 |
| shift() | 第一个值 | 移除数组的第一个元素 |
| unshift([item1[, item2[, ……[, itemN]]]]) | 数组长度 | 将参数放置到数组的开始位置 |
| join([seperator]) | string | 默认使用’,’分隔数组中的元素，传入参数spector的话，则使用参数分隔元素，undefined和null会被空字串代替 |
| slice(start[,end]) | 新的数组 | 返回[start, end]之间的元素组成的新数组 |
| splice(start, deleteCount[, item1… itemN]) | 新数组 | 从start开始，删除deleteCount个元素，加入并在start位置加入N个元素，返回从数组中删除的元素组成的新的数组 |
| sort(sortFn) | 排序后的原有数组 | 对数组每个元素呼叫sortFn(first, second) |
| reverse() | 修改后的原由数组 | 将数组中的元素的index掉转 |
| hasOwnProperty(propName) | bool | 检查数组有没有这个属性 |
属性
arr.constructor == Array
constructor是JS每个具有原型对象的原型成员，包括所有内建的JS对象（Math, Global除外）
arr.length
数组是疏松的，数组元素可以不必连续，length不一定是数组的元素个数.
如果length属性小于真正值，则会截断数组。
如果length大于真正值，会自动填充undefined，扩充数组到新的长度。
var arr = []; arr[0] = 'zero'; arr[6] = 'six';
console.log(arr.length); //7
console.log(arr); //["zero", undefined, undefined, undefined, undefined, undefined, "six"]
arr.length = 3;
console.log(arr); //["zero", undefined, undefined]
arr.prototype
使用prototype后，将向对象类别加入新的基本功能，该对象的实例都会继承该原型行为
所有JS对象都有prototype只读的prototype属性，可以为原型添加属性和方法，但是不可以为该内建对象指派不同的原型。但可以为使用者定义的对象指派新的原型。
var arr = [1, 23, 4, -1, 7];
Array.prototype.maxValue = function()
{
var result = this[0];
for(var i = 0; i < this.length; i++)
{
if(this[i] > result) result = this[i];
}
return result;
}
console.log(arr.maxValue());//23
Array.prototype = null;
console.log(arr.maxValue());//23
var newObj = new Object();
newObj[0] = 1;
newObj[6] = 25;
newObj.prototype = Array.prototype;
console.log(newObj.maxValue());//TypeError: newObj.maxValue is not a function
newObj.prototype.maxValue = Array.prototype.maxValue;
console.log(newObj.maxValue());//TypeError: newObj.maxValue is not a function
Array.isArray(arr)
返回值boolean判断是否为数组
方法
concat
arr1.concat ([item1[, item2[, . . . [, itemN]]]])
将item加入数组末尾，并返回新的数组
Note：如果参数是一个数组，那么item里的内容被加入arr1的末尾.
如果item是一个object，那么它会直接被加入新的数组，改变他的值，会造成新数组中该元素值的改变。
var arr1 = [1,2,3];
var arr2 = ['one', 'two', 'three'];
var newArr = arr2.concat(arr1);
console.log(newArr); //["one", "two", "three", 1, 2, 3]
arr[0] = 0;
console.log(newArr); //["one", "two", "three", 1, 2, 3]
var o = {"one":1};
var newArr = arr2.concat(o);
console.log(newArr); //["one", "two", "three", Object { one=1}]
o.one = 2;
console.log(newArr); // ["one", "two", "three", Object { one=2}]
every / some
array1.every(callbackfn[, thisArg])
最多接受3个callbackfn，every方法针对array1中的每个元素呼叫callbackfn函数，知道callbackfn返回false，或者到阵列结尾
callbackfn(value, index, array1)
thisArg， this关键字在callbackfn中绑定的对象，如果省略，则，this的值为undefined(在firefox中测试，该值为window)
some是callbackfn返回true
forEach / map
arr.forEach(callbackfn[, thisArg]);
callbackfn(value, index, arr)
最多接受3个callbackfn，会针对数组中的每个元素（按索引次序）调用一次callbackfn
如果callbackfn不是函数，会报错TypeError
thisArg默认为this，可以传入新的object用于绑定函数中的this关键字
不返回新数组
任何具有length属性且具有数值索引性名称的对象都可以使用forEach方法
callback方法启动后（这个有点奇怪，因为是单线程的，模拟不出来，这里有问题）
1. 在超出数组原始长度的位置加入新元素，该元素不会被callbackfn处理
2. 删除数组中的某个值，则如果该值还没有被callbackfn处理，则不会传递至callbackfn.
3. 更改元素，在该元素没有被callbackfn前，会传递给callbackfn处理
var arr = [0, 1];
var callbackfn = function(value, index, arr){
console.log(this);
return value;
}
var newArr1 = arr.forEach(callbackfn);
console.log(newArr1);
var newArr2 = arr.map(callbackfn);
console.log(newArr2);
var newArr3 = [];
var addItem = function(value, index, arr){
this.push(value);
}
arr.forEach(addItem, newArr3);
console.log(newArr3);
/*
Window about:newtab
Window about:newtab
undefined
Window about:newtab
Window about:newtab
[0, 1]
[0, 1]
*/
map返回新的数组
var arr = [1, 'one', {'one':1}];
var newArr = arr.map(function(value, index, arr){
if(typeof value == 'string') value = value.toUpperCase();
return value;
});
console.log(newArr);//[1, "ONE", Object { one=1}]
arr[2].one = 2;
console.log(newArr); //[1, "ONE", Object { one=2}]
filter
arr.filter(callbackfn[, thisArg])
callbackfn最多只能有3个 callbackfn(value, index, array1)
返回新数组，其中元素为对arr中数组元素调用callbackfn返回值为true的，如果callbackfn针对arr的所有元素都传回false，那么新阵列长度就是0
任何具有length属性并具有数值索引名称的对象都可以使用filter方法（string也可以）
filter方法不会直接修改arr，但callbackfn会修改
thisArg可以绑定this属性
//对String使用filter方法
var sentence = 'this is a beautiful world, we should protect it from harm';
var filterFirstWord = function(value,index,arr)
{
if(index == 0)
{
return true;
}
else
{
return arr[index-1] === " ";
}
}
var result = [].filter.call(sentence, filterFirstWord);
console.log(result);//["t", "i", "a", "b", "w", "w", "s", "p", "i", "f", "h"]
//绑定thisArg
var obj = {
"max": 20,
"min": 10
};
var arr = [11, 0, 19, 24, 'one', {'two' : 2}];
var filterRangeNumber = function(value,index,arr)
{
if(typeof value != 'number') return false;
return value >= this.min && value <= this.max;
}
var result = arr.filter(filterRangeNumber, obj);
console.log(result);//[11, 19]
//获取window对象中css开头的属性
var isCssStart = function(value, index, arr)
{
var firstValue = value.substr(0,3);
if(firstValue.toUpperCase() === 'CSS') return true;
return false;
}
var filteredName = Object.getOwnPropertyNames(window).filter(isCssStart);
console.log(filteredName);/*["CSSStyleDeclaration", "CSS2Properties", "CSSRule", "CSSStyleRule", "CSSFontFaceRule",
"CSSValue", "CSSPrimitiveValue", "CSSStyleSheet", "CSSPageRule", "CSSNameSpaceRule",
"CSSCharsetRule", "CSSGroupingRule", "CSSConditionRule", "CSSSupportsRule", "CSSMozDocumentRule",
"CSSRuleList", "CSSMediaRule", "CSSCounterStyleRule", "CSSImportRule", "CSS", "CSSValueList"]*/
reduceRight / reduce
arr.reduce(callbackfn[, initialValue])
返回结果是最后一次呼叫callbackfn所传回的累加结果
callbacnfn(previousValue, currentValue, currentIndex, arr)
对数组的所有元素呼叫callbackfn，累加单一结果，将呼叫函数的传回值是累加结果，作为下个呼叫的引数提供给callbackfn
reduceRight是以递减的顺序对数组中的元素呼叫
// Define the callback function.
function AppendToArray(previousValue, currentValue) {
return previousValue + currentValue;
}
var word = "retupmoc";
// Create a string that reverses the characters of another string.
// The commented-out statement shows an alternative syntax.
var result = [].reduceRight.call(word, AppendToArray, "the ");
// var result = Array.prototype.reduceRight.call(word, AppendToArray, "the ");
document.write(result);
// Output:
// the computer
shift / unshift
arr.shift();
移除数组的第一个数，然后返回这个元素。
arr.unshift([item1[, item2[, …[, itemN]]]]);
unshift方法将元素插入数组的开头。返回数组arr的长度
var arr = [1, 'two'];
var result = arr.shift();
console.log(result, arr);//1 ["two"]
var arr = [1, 'two'];
var result = arr.unshift(2, 3);
console.log(result, arr);//4 [2, 3, 1, "two"]
slice / splice
arr.splice(start, deleteCount, [item1[, item2[, ….[, itemN]]]])
在Start开始的Index开始删除deleteCount个元素，然后插入N个item, 返回值为被删除的数据组成的新Array
arr.slice(start, [end]);
返回arr数组中[start, end]之间的元素，组成Array新数组返回
如果start/end是负值，那么该值将被视为length+start/end
如果end < start，则不会返回数据
如果end被省略，那么复制start~length-1的元素组成新数组返回
var arr = [1, [2, 3], 3, 4, 5];
var result = arr.splice(1, 2, [2]);
console.log(arr, result);// [1, [2], 4, 5] [[2, 3], 3]
var arr = [1,2,3,4,5,6,7];
var result1 = arr.slice(0,1);
console.log(result1);//[1]
var result2 = arr.slice(0);
console.log(arr, result2);//[1, 2, 3, 4, 5, 6, 7] [1, 2, 3, 4, 5, 6, 7]
var result3 = arr.slice(-6, 2);
console.log(result3);//[2]
sort
arr.sort(sortFn)
如果sortFn省略，使用ASCII字元递增排序
sortFn（first, second）
返回值为排序后的数组，执行时并不创建新的Array对象
sortFn中，如果第一个小于第二个，返回负值；否则，返回正值；如果相等，返回0
var arr = [2,1,6,18,-1,10];
var bubbleSort = function(first, second){
if(first < second) return -1;
if(first > second) return 1;
return 0;
};
var result = arr.sort();
console.log(result);//[-1, 1, 10, 18, 2, 6]
var result1 = arr.sort(bubbleSort);
console.log(result1);//[-1, 1, 2, 6, 10, 18]
reverse
arr.reverse()
反转数组, 直接反转arr中的元素，并不会建立新的Array对象
var arr = [1,2,[3,4]];
var result = arr.reverse();
console.log(result, arr);//[[3, 4], 2, 1] [[3, 4], 2, 1]
join
arr1.join([separator])
sperator是在要产生的string中，用来分隔数组各个元素的字串，如果省略，将使用逗号。数组中的undefined, null，会被视为空字符串
var arr1 = [1,'one', {"key":"value"}, undefined, null, NaN, Infinity];
console.log(arr1.join()); //1,one,[object Object],,,NaN,Infinity
console.log(arr1.join('*'));//1*one*[object Object]***NaN*Infinity
hasOwnProperty
obj.hasOwnProperty(proName)
返回boolean，obj中是否有指定名称的属性，不会检查原型中有哪些属性，因此该属性必须是对象本身的成员
toLocalString / toString
arr.toString();
将arr中的元素转换为字符串，产生的字符串使用逗号分隔。
dateObj.toLocalString()
dateObj是Date的对象，返回值为String对象，其中包含目前地区设定的预设长格式所写入的日期
如果日期介于1601年到1999年，则使用使用者电脑控制台中地区设定而定
如果日期超出，则使用toString方法的预设格式
注意，toLocalString应该只是用于显示结果给使用者查看，不能用于计算，因为传回的结果可能以为电脑的不同而有差异。
var arr = [1, 'two', [3,4], {'five': 5}];
var result = arr.toString();
console.log(result);//1,two,3,4,[object Object]
var current = new Date();
var result = current.toLocaleString();
console.log(result);//2015/1/14 下午2:29:56
valueOf, indexOf, lastIndexOf
isPrototypeOf
prototyIsEnumerable
pop/push
链式使用
662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
