1.模拟数据结构栈

pop()从数组尾部弹出一个元素并返回弹出的元素。尾部是指索引最大的元素。数组的长度会减 1；
push(); //从数组的尾部压入一个元素，并返回数组的新长度 ，数组长度+1
// 栈方法：可以对比弹夹
// 数组可以通过 push 和 pop 两个方法形成栈数据结构。
var t = ['a', 'b', 'c', 'd', 'e', 'f'];
console.log(t.length)
console.log(t);
t.pop();
console.log(t);
// 从数组的末尾弹出一个元素。并返回弹出的数组元素。数组的长度-1
t.pop();
console.log(t);
// 压入一个元素。
var r = t.push(3);
console.log(r);
console.log(t);
栈是一种数据结构，特点就是 后入先出。

2.数组模拟队列

shift();//从数组的头部弹出一个元素，并返回此元素
unshift()//从数组的头部压入一个元素，并返回 length

数组模拟队列.png

用 push 和 shift 方法可以将数组模拟成队列的数据结构。
// 用数组模拟队列数据结构
var t = [];
// 往队列里面放入 1， 2， 3 三个元素。
t.push(1);
t.push(2);
t.push(3);
console.log(t);
// 出队一个元素。 1
console.log(t.shift());
console.log(t);
// 再出队一个元素。
console.log(t.shift()); //2
console.log(t);
// 队列的特点就是先进先出。
栈和队列的数据结构总结：
栈数据结构： 先进后出。
队列数据结构： 先进先出。

3.排序方法

reverse();//对原数组进行逆序
Reverse 方法可以对原数组的数据进行逆序，原来的数组会收到影响。
var t = ["a", "b", "c", "d", "e"];
t.reverse();
console.log(t);
// ["e", "d", "c", "b", "a"]
sort()；//转成字符串排序
sort 方法对原数组进行排序，会对原数组有影响，默认从升序（从小到大）进行排序。
排序比较的算法是利用字符串比较的算法，如果是其他类型的元素，会先转成字符串再进行比较。
// 对数组进行排序
var t = ['c', 'b', 'd', 'e', 'a'];
console.log(t);
t.sort(); // 对数组中的元素进行排序
console.log(t);
// => ["a", "b", "c", "d", "e"]
// 如果是数字进行排序
var arr = [33, 10, 1, 22, 12, 222, 30];
console.log(arr);
// sort 方法是按照字符串进行比较大小规则计算排序的。
// 如果数组中的元素不是字符串类型会转成字符串后进行比较。
arr.sort();
console.log(arr);
// => [1, 10, 12, 22, 222, 30, 33]

4. sort 排序高级应用

函数可以作为参数传递给其他函数进行使用。函数本身也是很一个对象。这就是函数式编程的要诀。
数组的 sort 方法可以接收一个类型为函数的参数，此函数接收两个参数，要求返回值为：负数， 0，
正数。如果返回负数代表第一个参数小于第二个参数，0 为相等，正数则大于
[1, 3, 20, 11, 9].sort(function (a, b) {
    if( a > b) {
        return 1;
    } else if( a == b) {
        return 0;
    } else {
        return -1;
    }
});
// 此函数接收两个参数，要求返回值为：负数， 0， 正数。如果返回负数代表第一个参数小于第二个参
   数，0 为相等，正数则大于
// 定义一个变量，变量的类型的是 function
var compareFun = function (a, b) {
    return a - b; // a ==b, a-b =0 a<b, a-b =负数
};
var m = [ 3, 20, 10 , 9, 11, 12];
console.log(m);
// 默认是转成字符串后比较大小。
// m.sort();
// console.log(m);
// 利用函数式编程，sort 方法可以接受一个比较大小的函数，例如数值比较大小的方法进行排序。
// m.sort(compareFun);
// console.log(m);
// 进一步优化。由于匿名函数只用一次，没有必要创建一个变量。直接可以吧匿名函数的表达式传递到 
   sort 函数里去就行。
m.sort(function(a, b) {
    return a-b;
});
console.log(m);

5 数组的连接方法

concat()；
连接原数组的元素和传递的参数形成一个新数组并返回，不影响原来的数组。
如果传入的参数是数组，会把数组中的元素跟原数组的元素进行合并成一新数组。
[1, 2,3].concat(9,1,4); // => [1, 2, 3, 9, 1, 4]
[1, 2,3].concat([9,true]); // => [1, 2, 3, 9, true]
[1, 2,3].concat([9,true, ['22',4, 9], 33])
//=> [1, 2, 3, 9, true, Array(3), 33]
var t = [1, 2, 3];
console.log(t);
// 调用数组的链接方法,不会影响原来的数字，函数会返回一个新的拼接的数组。
var newArr = t.concat('ss', true, 222);
console.log(t); // => [1, 2, 3]
console.log(newArr);
var newArr2 = t.concat(['laoma', 'beijing', 999]);
console.log(newArr2);
join();
可以把数组的元素（项）连接成字符串，接收一个参数为连接符号,默认是逗号,返回的结果为字符串。
[1, 2, 3].join(); //=> 1,2,3
[4,true, 3].join(“-”) ; // => 4-true-3
var t = [1, 2, 3];
// toString 方法会把数组转成字符，重写了原型的方法。
// 把数组中的元素都转成字符串然后用逗号分隔不同的元素。
console.log(t.toString());
// join 方法也可以将数组转成字符串，默认跟 toString 一样。
console.log(t.join());
// join 发方法可以传一个参数，用来分隔数组中的元素
console.log(t.join('-'));
console.log(t.join('|'));

6.slice 方法

slice()；//复制数组的一部分
截取数组的一个片段或者子数组
接收 1 个到 2 个参数。参数：截取数组起始索引和结束索引
如果只指定一个参数代表：从索引位置到数组结尾。
参数如果是负数代表从数组末尾计算索引位置。
此方法只能从数组前面往后面截取，如果第二个参数在第一个参数的前面则返回空数组[];
数组只能往后截取，不能向前截取，如果向前截取返回[]
此方法对原数组没有影响。
m = [1,2,3,4,5];
m.slice(2); //=>[3, 4, 5]
m.slice(-3); //=>[3, 4, 5]
m.slice(3, 4);//=> [4]
m.slice(-3, -1);//=>[3, 4]
var t = [0,1,2,3,4,5];
console.log( t );
// slice：复制数组的一部分。
// 传一个参数时候，是从参数的索引位置开始截取到数组的最后。
var a1 = t.slice(2); //从索引位置 2 开始截取到数组的最后。
// a1= [2, 3, 4, 5]
console.log( a1 );
// 传两个参数：从第一个参数作为索引位置开始，到第二个参数作为索引前面的那个元素结束，截取数组
   切片。对原数组没有任何影响。
var a2 = t.slice(2, 5); // a2=> [2,3,4]
console.log(a2);
console.log(t); // [0, 1, 2, 3, 4, 5] 对原数组没有影响
// 如果传递 的是负数，那么从数组结尾开始计算。 但是不要用。
// slice 方法只能往后截取，如果往前截取返回[];
var a3 = t.slice(-3, -1); // a3 => [3,4]
console.log(a3);

7.splice 方法

在原数组上进行插入或者删除数组元素，会影响原来数组。
返回的结果是删除的元素组成的数组。
参数：可以接受 1 个参数，2 个参数或者 2 个以上的参数。
第一个参数是删除数据的索引位置
第二个参数是要删除数组元素的个数
第三个参数开始是要插入到原数组中的元素，插入的位置从第一个参数所在的索引开始。
//删除数据
[1, 2, 3, 4, 5].splice(2);//=> [3, 4, 5] 原数组：[1,2]
[1, 2, 3, 4, 5].splice(3,2);// =>[4, 5] 原数组：[1,2,3]
[1, 2, 3, 4, 5].splice(-2); // =>[4, 5] 原数组：[1,2,3]
a = [1,2,3,4,5];
a.splice(3,2,33,'222',[99,98]);//=>[4,5]
//a=>[1, 2, 3, 33, "222", Array(2)]
//插入数据：
a=[1,2,3]; a.splice(1,0,5,6);//=>[] a=[1,5,6,23]
//替换数据：
a=[1,2,3];a.splice(1,1,4);//=>[2] a=[1,4,3]

8.数组继承的方法

• toString()方法
• 它会将数组中的每个元素转成字符串并用逗号连接起来。
• 类似join()方法的默认情况。
• [1, 3, 5].toString();//=> “1,3,5”
• toLocalString()方法
• valueOf()方法

9.数组案例

数组数据：[90, 8, 34, 2, 39, 87, 22, 10]
1.将数组内容进行反序
2.求一个数据数组中的最小值及它的索引
3.求一个数组中的数据的平均值与和。
4.数组的数据进行排序
5.给定一个数组，请去掉数组中的重复数据。
6.冒泡排序算法