ES5新增的数组方法
1、map()
语法：arr.map(funcation (item,index){
return item*3；
})
含义：(1)遍历数组，(2)映射数组 (item代表每一个元素，index代表下标)
返回值：映射出来的新数组(扩大或缩小多少倍或减小增大等的新数组)
<script>
var arr=[23,54,34,56,54]
var res=arr.map(function (item,i) {
return item*3;
})
console.log(res);
</script>
2、forEach()
语法：arr.forEach(funcation(item,index){
console.log(index);
//没有return
})
含义：遍历数组
返回值：无
<script>
var arr=[23,54,34,56,54]
var res=arr.forEach(function (item,index) {
console.log(index);
})
</script>
3、filter()
语法：arr.filter(funcation(item,index){
return item>3；
})
含义：过滤满足条件的元素
返回值：数组形式大于3的值
<script>
var arr=[23,54,34,56,54]
var res=arr.filter(function (item,i) {
return item>30;
})
console.log(res);
</script>
4、some()
语法：arr.some(funcation(item,index){
return item>3;
})
含义：数组中有一个满足条件的大于3，返回的就是true 都不满足才返回false
返回值：true 或false
<script>
var arr=[23,54,34,56,54]
var res=arr.some(function (item,i) {
return item>55;
})
console.log(res);
</script>
5、every()
语法：arr.every(funcation(item,index){
return item>3;
})
含义：数组中必须每一个都满足条件的大于3，返回的就是true 都不满足才返回false
返回值：true 或false
<script>
var arr=[23,54,34,56,54]
var res=arr.every(function (item,i) {
return item>30;
})
console.log(res);
</script>
数组的排序方法
排序，就是把一个乱序的数组，通过我们的处理，让他变成一个有序的数组
1、冒泡排序
排序思路：相邻两个元素进行比较，大的往后排
先遍历数组，让挨着的两个进行比较，如果前一个比后一个大，那么就把两个换个位置
数组遍历一遍以后，那么最后一个数字就是最大的那个了
然后进行第二遍的遍历，还是按照之前的规则，第二大的数字就会跑到倒数第二的位置
以此类推，最后就会按照顺序把数组排好了
示例：
<script>
var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8];
//接下来我们就会用代码让数组排序
// 假定我现在要让数组中的第 0 项和第 1 项换个位置
// 需要借助第三个变量
var temp = arr[0]
arr[0] = arr[1]
arr[1] = temp
//第一次遍历数组，把最大的放到最后面去
for (var i = 0; i < arr.length; i++) {
// 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
var temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
}
}
// 遍历完毕以后，数组就会变成 [3, 1, 5, 6, 4, 7, 2, 8, 9]
// 第一次结束以后，数组中的最后一个，就会是最大的那个数字
// 然后我们把上面的这段代码执行多次。数组有多少项就执行多少次
for (var j = 0; j < arr.length; j++) {
for (var i = 0; i < arr.length; i++) {
// 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
var temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
}
}
}
// 结束以后，数组就排序好了
</script>
优化代码：
想象一个问题，假设数组长度是 9，第八次排完以后
后面八个数字已经按照顺序排列好了，剩下的那个最小的一定是在最前面
那么第九次就已经没有意义了，因为最小的已经在最前面了，不会再有任何换位置出现
了
那么我们第九次遍历就不需要了，所以我们可以减少一次
<script>
for (var j = 0; j < arr.length - 1; j++) {
for (var i = 0; i < arr.length; i++) {
// 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
var temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
}
}
}
</script>
第二个问题，第一次的时候，已经把最大的数字放在最后面了
那么第二次的时候，其实倒数第二个和最后一个就不用比了
因为我们就是要把倒数第二大的放在倒数第二的位置，即使比较了，也不会换位置
第三次就要倒数第三个数字就不用再和后两个比较了
以此类推，那么其实每次遍历的时候，就遍历 当前次数 - 1 次
<script>
for (var j = 0; j < arr.length - 1; j++) {
for (var i = 0; i < arr.length - 1 - j; i++) {
// 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
var temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
}
}
}
console.log(arr)//排序后的数组
</script>
至此，一个冒泡排序就完成了
2、选择排序
排序思路：假设第一个元素是最小值，拿第一个元素和后面的元素依次进行比较，如果发现有比第一个元素还小的，就进行交换
先假定数组中的第 0 个就是最小的数字的索引
然后遍历数组，只要有一个数字比我小，那么就替换之前记录的索引
直到数组遍历结束后，就能找到最小的那个索引，然后让最小的索引换到第 0 个的位置
再来第二趟遍历，假定第 1 个是最小的数字的索引
在遍历一次数组，找到比我小的那个数字的索引
遍历结束后换个位置
依次类推，也可以把数组排序好
交换变量之前，可以判断一下，如果我们遍历后得到的索引和当前的索引一直
那么就证明当前这个就是目前最小的，那么就没有必要交换
所有我们要判断，最小索引和当前索引不一样的时候，才交换
<script>
for (var j = 0; j < arr.length-1; j++) {
for (var i = j + 1; i < arr.length; i++) {
if (arr[i] < arr[j]) {
var temp=arr[i];
arr[i]=arr[j];
arr[j]=temp
}
}
}
</script>
至此，选择排序完成
函数参数传递基本数据类型和复杂数据类型的区别
之前我们知道了，基本数据类型和复杂数据类型在存储上是有区别的
那么他们在赋值之间也是有区别的
基本数据类型之间的赋值
基本数据类型：1、基本数据类型变量存储的是值，
2、基本数据类的变量存储在栈内存中，
3、基本数据类型的变量和变量之间互不影响，
<script>
var num = 10
var num2 = num
num2 = 200
console.log(num) // 100
console.log(num2) // 200
</script>
解释：相当于是把 num 的值复制了一份一摸一样的给了 num2 变量，赋值以后两个在没有关系
复杂数据类型(引用数据类型)之间的赋值
<script>
var obj = {
name: 'Jack'
}
var obj2 = obj
obj2.name = 'Rose'
console.log(obj.name) // Rose
console.log(obj2.name) // Rose
</script>
1、引用数据类型的变量存储的是地址值，
2、复杂数据类型存储在 堆内存中
3、引用数据类型的变量如果和另外一个引用数据类型的变量共用一个地址值，其中一个变化，另外一个也会受到影响
解释：所以就是赋值的时候相当于把 obj 存储的那个地址复制了一份给到了 obj2 变量；现在 obj 和 obj2 两个变量存储的地址一样，指向一个内存空间；所以使用 obj2 这个变量修改空间内的内容， obj 指向的空间也会跟着改变了
函数的参数
函数的参数也是赋值的之中，在函数调用的时候，实参给行参赋值
和之前变量赋值的规则是一样的
函数传递基本数据类型
<script>
//例题1
function fn(n) {
n = 200
console.log(n) // 200
}
var num = 100
fn(num)
console.log(num) // 100
//例题2
function fn(a) {
return a=10;
}
var a=20;
fn(a);
console.log(a);//20
console.log(fn());//10
</script>
和之前变量赋值的时候一样，在把 num 的值复制了一份一摸一样的给到了函数内部的行参 n
两个之间在没有任何关系了
函数传递复杂数据类型
<script>
//例题1
function fn(o) {
o.name = 'Rose'
console.log(o.name) // Rose
}
var obj = {
name: 'Jack'
}
fn(obj)
console.log(obj.name) // Rose
//例题2
function fn(arr) {
arr[0]=10;
}
var arr=[12,43,1]
fn(arr);
console.log(arr);
</script>
和之前变量赋值的时候一样，把 obj 内存储的地址复制了一份一样的给到函数内部的行
参 o
函数外部的 obj 和函数内部的行参 o ，存储的是一个地址，指向的是一个存储空间
所以两个变量操作的是一个存储空间
在函数内部改变了空间内的数据
obj 看到的也是改变以后的内容