6.13心得
concat
concat() 方法用于连接两个或多个数组。
该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
语法
arrayObject.concat(arrayX,arrayX,......,arrayX)
arrayX 必需。该参数可以是具体的值，也可以是数组对象。可以是任意多个。
返回值
返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。
如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。
every
every() 方法测试数组的所有元素是否都通过了指定函数的测试。MDN array.every。
arr.every(callback) 会对每一个元素都执行 callback 方法，直到 callback 返回 false。
有时候 every 方法会和 forEach 方法相比较，因为 forEach 无法停止，而 every 方法返回 flase 时可以中途停止。
若全部通过测试，函数返回值 true，中途退出，返回 false；
不对原数组产生影响。
代码
function isBigEnough(element, index, array) {
console.log(index);
return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// 0
// 1
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// 0 1 2 3 4
// passed is true
代码
filter
filter() 方法使用指定的函数测试所有元素，并创建一个包含所有通过测试的元素的新数组。MDN array.filter。
其实这个方法就是一个过滤方法，前面那个 every 方法，只判断不过滤，filter 会过滤掉一些不符合条件的，并返回新数组。
返回一个满足过滤条件的新数组；
不会改变原数组。
代码
function isBigEnough(element, index, array) {
return (element >= 10);
}
var a1 = [19, 22, 6, 2, 44];
var a2 = a1.filter(isBigEnough);
a1 //[19, 22, 6, 2, 44]
a2 //[19, 22, 44]
代码
forEach
forEach() 方法对数组的每个元素执行一次提供的函数(回调函数)。MDN array.forEach。
函数没有返回值，即 underfined；
不对原数组产生影响。
代码
function logArrayElements(element, index, array) {
console.log("a[" + index + "] = " + element);
}
// 注意索引2被跳过了，因为在数组的这个位置没有项
var result = [2, 5, 9].forEach(logArrayElements);
// a[0] = 2
// a[1] = 5
// a[2] = 9
result //underfined
代码
indexOf
indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
searchvalue 必需。规定需检索的字符串值。
fromindex 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值
是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。
<script type="text/javascript">
var str="Hello world!"
document.write(str.indexOf("Hello") + "<br />")
document.write(str.indexOf("World") + "<br />")
document.write(str.indexOf("world"))
</script>
reverse
reverse() 方法用于颠倒数组中元素的顺序。
注释：该方法会改变原来的数组，而不会创建新的数组。
<script type="text/javascript">
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr + "<br />")
document.write(arr.reverse())
</script>
join
join() 方法用于把数组中的所有元素放入一个字符串。
元素是通过指定的分隔符进行分隔的。
返回值
返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把
这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。
<script type="text/javascript">
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr.join())
</script>
pop
pop() 方法用于删除并返回数组的最后一个元素。
返回值
arrayObject 的最后一个元素。
说明
pop() 方法将删除 arrayObject 的最后一个元素，把数组长度减 1，并且返回它删除的
元素的值。如果数组已经为空，则 pop() 不改变数组，并返回 undefined 值。
<script type="text/javascript">
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr)
document.write("<br />")
document.write(arr.pop())
document.write("<br />")
document.write(arr)
</script>
push
push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
返回值
把指定的值添加到数组后的新长度。
说明
push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject，
而不是创建一个新的数组。push() 方法和 pop() 方法使用数组提供的先进后出栈的功能。
提示和注释
注释：该方法会改变数组的长度。
提示：要想数组的开头添加一个或多个元素，请使用 unshift() 方法。
<script type="text/javascript">
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr + "<br />")
document.write(arr.push("James") + "<br />")
document.write(arr)
</script>
shift
shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。
返回值
数组原来的第一个元素的值。
说明
如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。
请注意，该方法不创建新数组，而是直接修改原有的 arrayObject。
提示和注释
注释：该方法会改变数组的长度。
提示：要删除并返回数组的最后一个元素，请使用 pop() 方法。
<script type="text/javascript">
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr + "<br />")
document.write(arr.shift() + "<br />")
document.write(arr)
</script>
slice
slice() 方法可从已有的数组中返回选定的元素。
返回值
返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。
说明
请注意，该方法并不会修改数组，而是返回一个子数组。如果想删除数组中的一
段元素，应该使用方法 Array.splice()。
提示和注释
注释：您可使用负值从数组的尾部选取元素。
注释：如果 end 未被规定，那么 slice() 方法会选取从 start 到数组结尾的所有元素。
<script type="text/javascript">
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr + "<br />")
document.write(arr.slice(1) + "<br />")
document.write(arr)
</script>
toLocaleString
把数组转换为本地字符串。
语法
arrayObject.toLocaleString()
返回值
arrayObject 的本地字符串表示。
说明
首先调用每个数组元素的 toLocaleString() 方法，
然后使用地区特定的分隔符把生成的字符串连接起来，形成一个字符串。
<script type="text/javascript">
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr.toLocaleString())
</script>
splice
splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
注释：该方法会改变原始数组。
说明
splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数
列表中声明的一个或多个值来替换那些被删除的元素。
如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。
浏览器支持
所有主流浏览器都支持 splice() 方法。
提示和注释
注释：请注意，splice() 方法与 slice() 方法的作用是不同的，splice() 方法会直接对数组进行修改。
<script type="text/javascript">
var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"
document.write(arr + "<br />")
arr.splice(2,0,"William")
document.write(arr + "<br />")
</script>
unshift
unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
返回值
arrayObject 的新长度。
说明
unshift() 方法将把它的参数插入 arrayObject 的头部，并将已经存在的
元素顺次地移到较高的下标处，以便留出空间。该方法的第一个参数
将成为数组的新元素 0，如果还有第二个参数，它将成为新的元素 1，以此类推。
请注意，unshift() 方法不创建新的创建，而是直接修改原有的数组。
提示和注释
注释：该方法会改变数组的长度。
注释：unshift() 方法无法在 Internet Explorer 中正确地工作！
提示：要把一个或多个元素添加到数组的尾部，请使用 push() 方法。
<script type="text/javascript">
var arr = new Array()
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr + "<br />")
document.write(arr.unshift("William") + "<br />")
document.write(arr)
</script>
map
map() 方法返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。MDN array.map。
map reduce 这两个函数在处理数组上一直都是一把手，带来很大的便捷性。
返回一个经过回掉函数处理的新数组；
不对原数组产生影响。
var a1 = [1, 4, 9];
var a2 = a1.map(Math.sqrt);
a1 //[1, 4, 9]
a2 //[1, 2, 3]
reduce
reduce() 方法接收一个函数作为累加器（accumulator），
数组中的每个值（从左到右）开始合并，最终为一个值。MDN array.reduce。
reduce 是一个合并的过程，从左到右，直到把所有元素合并到一起，
并返回最终的结果。它接受两个参数，第一个参数是一个回掉函数，
第二个参数是一个初始值，表示处理第一个元素时的前一个值。这个
回掉函数接受四个参数，依次是 accumulator（上次处理的结果），
currentValue（当前元素的值），index（当前元素索引），array（调用 reduce 的数组）。
返回最终合并的结果，即回掉函数的输出，可以为字符串，对象，数组等任意结果；
不对原数组产生影响。
var getAdd = (pre, cur) => pre + cur;
var a1 = [1, 2, 3];
var a2 = a1.reduce(getAdd, 0);
a1 //[1, 2, 3]
a2 //6
reduceRight
reduceRight() 方法接受一个函数作为累加器（accumulator），让每个值
（从右到左，亦即从尾到头）缩减为一个值。（与 reduce() 的执行方向相反）MDN array.reduceRight。
var toStr = (pre, cur) => '' + pre + cur;
var a1 = [1, 2, 3];
var a2 = a1.reduce(toStr, '');
a2 //"123"
a2 = a1.reduceRight(toStr, '');
a2 //"321"
some
some() 方法测试数组中的某些元素是否通过了指定函数的测试。MDN array.some。
sort
sort() 方法对数组的元素做原地的排序，并返回这个数组。 sort 排序可能是不稳定的。
默认按照字符串的Unicode码位点（code point）排序。MDN array.sort。
sort 函数用于排序，比较常用，若没有制定排序函数，则按照 unicode 位点进行排序，
而且数字会被转成字符串，所以 ‘123’ 要排在 ‘11’ 的后面。
我们会用 sort 做一些有意思的排序，比如汉字按照拼音排序。
返回排序后的原数组；
会对数组进行修改。
复制代码
var big = function(a, b){
return a - b;
}
var a1 = [2, 4, 77, 1];
var a2 = a1.sort(big);
a1 //[1, 2, 4, 77]
a1 === a2; //true
复制代码
localeCompare 可以对汉字进行排序，当同时出现汉字和字母的时候会有 bug：
var sort_py = function(a, b){
return a.localeCompare(b);
}
var a1 = ["北京", "上海", "南京", "合肥"];
a1.sort(sort_py);
//["北京", "合肥", "南京", "上海"]
toString
toString() 返回一个字符串，表示指定的数组及其元素。MDN array.toString。
显然，这个方法和 join 方法比较一下。
返回拼接的字符串；
不会改变原数组。
var a1 = [1, 2, 3];
var a2 = a1.toString();
a2 //"1,2,3"
ES6 中新添的数组方法
上面的这些方法都是 ES5 的，来看看 ES6 添加了哪些新方法。
copyWithin
copyWithin() 方法会浅拷贝数组的部分元素到同一数组的不同位置，
且不改变数组的大小，返回该数组。MDN array.copyWithin。
接受三个参数，分别是要拷贝到的位置 target，拷贝开始位置 start 和结束位置 end。
返回修改了的原数组；
会对数组进行修改，且是浅拷贝；
参数可负，负值时倒推，且 end 为空表示数组长度。
var a1 = [1, 2, 3, 4, 5];
var a2 = a1.copyWithin(0, 2, 4);
a1 //[3, 4, 3, 4, 5]
a2 //[3, 4, 3, 4, 5]
a1 === a2; //true
find
如果数组中某个元素满足测试条件，find() 方法就会
返回满足条件的第一个元素，如果没有满足条件的元素，则返回 undefined。MDN array.find。
返回找到的那个元素，若未找到，返回 underfined
不对原数组产生影响。
function isBigEnough(element, index, array) {
return (element >= 10);
}
var a1 = [8, 18, 14];
var num = a1.find(isBigEnough); //18
fill
使用 fill() 方法，可以将一个数组中指定区间的所有元素的值, 都替换成或者说填充成为某个固定的值。MDN array.fill。
fill 方法接受三个参数，第一个参数 value 表示要填充到值，后面两个 start 和 end 表示开始和结束位置，可选，且左闭右开。
函数返回值是修改了的原数组；
可对数组产生影响。
var a1 = [1, 2, 3, 4, 5];
var a2 = a1.fill(6, 1, 4);
a1 //[1, 6, 6, 6, 5]
a2 //[1, 6, 6, 6, 5]
a1 === a2; //true
keys
数组的 keys() 方法返回一个数组索引的迭代器。MDN array.keys。
这个方法会返回一个数组索引的迭代器，迭代器在 ES6 中有特殊的用途。
函数返回一个迭代器对象；
不会改变原数组。
复制代码
var arr = ["a", "b", "c"];
var iterator = arr.keys();
console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
复制代码
entries
entries() 方法返回一个 Array Iterator 对象，该对象包含数组中每一个索引的键值对。MDN array.entries。
var arr = ["a", "b", "c"];
var eArr = arr.entries();
console.log(eArr.next().value); // [0, "a"]
console.log(eArr.next().value); // [1, "b"]
console.log(eArr.next().value); // [2, "c"]
includes
includes() 方法用来判断当前数组是否包含某指定的值，如果是，则返回 true，
否则返回 false。MDN array.includes。
该函数接受两个参数，第二个参数表示开始查找位置，起始位置为 0。这个
方法与 indexOf 方法最大的区别不仅在于返回值一个是索引，一个是布尔值，
indexOf 方法使用的是 === 来判断，无法判断 NaN 情况，而 includes 可以判断。
返回 true 或 false；
不会改变原数组。
var a1 = [1, NaN];
a1.indexOf(NaN);//-1
a1.includes(NaN);//true
什么叫原型
原型是指原来的类型或模型，特指文学艺术作品中塑造人物形象所依据的现实生活中的人。
原型是指一个词语或一个类型意义的所有典型模型或原形象，是一个类型的组典型特征。
比如，鸟的原型可以是任何一只麻雀但企鹅就不是，因为它不具备某些典型的特征。特征本身可
能或多或少是典型的。
原型具有归纳性。原型的归纳性体现在通过归纳出相互排斥的少量类型，简化类型的多样性。
类型的划分依赖于对区分性特性的判断。
原型具有经验性。因为“在新情景下使用词的过程就是将现在经验和过去经验进行比较，判断
它们是否在相同的语言编码中足以相同的过程。
原型具有规约性。原型的[3] 规约性主要体现在约定俗成性。例如，”男性“和”女性“主要是由
遗传决定的，但在判断某人是”男性“或”女性“时，我们主要依据头发的长短、身高、穿着和有
无胡须等次要的综合性别特征和文化规约做出判断。
原型具有动态必。原型文本与具体文本的相互依存是文本赖以存在的社会环境变化的产物，
原型的稳定性和文本环境的变化是相互影响的。”原型和社会情景不存在完美的平衡；具体
文本只不过是文本的稳定性与交际情景的特殊需要在磨合过程中的一种折衷。
1. 创建obj对象：obj=new Object();
2. 将obj的内部__proto__指向构造他的函数A的prototype，同时，obj.constructor===A.prototype
.constructor(这个是永远成立的，即使A.prototype不再指向原来的A原型，也就是说：类的实例对
象的constructor属性永远指向"构造函数"的prototype.constructor)，从而使得obj.constructor.prototype
指向A.prototype（obj.constructor.prototype===A.prototype，当A.prototype改变时则不成立，下文有
遇到）。obj.constructor.prototype与的内部_proto_是两码事，实例化对象时用的是_proto_，obj是
没有prototype属性的，但是有内部的__proto__，通过__proto__来取得原型链上的原型属性和原型
方法，FireFox公开了__proto__，可以在FireFox中alert（obj.__proto__）；
3. 将obj作为this去调用构造函数A，从而设置成员（即对象属性和对象方法）并初始化。
当这3步完成，这个obj对象就与构造函数A再无联系，这个时候即使构造函数A再加任何成员，
都不再影响已经实例化的obj对象了。此时，obj对象具有了x属性，同时具有了构造函数A的原型
对象的所有成员，当然，此时该原型对象是没有成员的。
原型对象初始是空的，也就是没有一个成员（即原型属性和原型方法）。可以通过如下方法
验证原型对象具有多少成员。
var num=0;
for(o in A.prototype) {
alert(o);//alert出原型属性名字
num++;
}
alert("member: " + num);//alert出原型所有成员个数。
