8、日期和数组

上一章我们简单了解了一下对象的原理和基本属性，现在让我们来详细的了解一下JS中的对象：
其它对象：

• new Boolean();
• new Number();
• new String();
• new Function();
• new Date();
• new Array();
  ......
  没错，我们所学过的所有数据类型其实也都是构造函数对象
  其中，Date()是事件函数，Array()是数组函数

日期对象Date：

创建Date对象的语法：var date = new Date();

注意： Date 对象会自动把当前日期和时间保存为其初始值。

//创建一个日期对象
var date = new Date();
//输出一下试试
console.log(date);
//输出结果为当前的日期时间

说到时间，我们不得不了解一下计算机保存时间的方法：时间戳
时间戳的定义：

• 时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。
• 它在计算机内部以毫秒为基本单位进行计时，使用getTime()方法可以获得自1970年1月1日以来的毫秒数，也就是到现在的时间戳
  我们可以试一下：

//创建一个日期对象
var date = new Date();
console.log(date.getTime());
//输出时间戳：1564564641792

函数内还可以传参：

//创建一个日期对象
var date = new Date(1000);
//向里面传入参数1000并输出
console.log(date);
//得到的结果是：Thu Jan 01 1970 08:00:01 GMT+0800 (中国标准时间)

发现了没有，显示的时间是格林威治时间后的1秒

• 它除了可以获取现在的时间外，我们还可以自定义时间

//创建一个日期对象
var date = new Date("2000/01/01 00:00:01");
//直接向里面传入日期和时间，当然我们也可以这样写
var date = new Date("2000-01-01 00:00:01");
//也可以这样写
var date = new Date(2019, 11, 24, 10, 33, 30, 0);

注意： 最后一种传入参数的时候从左往右分别是：年、月、日、小时、分钟和秒，如果只提供一个参数则会被当成毫秒来计算，还有一点 ，在JS中，月份从0开始到11结束

Date 对象方法

数组对象Array：

Array 对象用于在单个的变量中存储多个值。

创建 Array 对象的语法：

//以构造函数方法创建：
var arr = new Array(10,"数组",{},[1,2],function(){},null,undefined,true);
//没错，数组中可以储存任何值，包括对象、数组和函数
var arr1 = [10,"数组",{},[1,2],function(){},null,undefined,true];
//这种方法也可以创建数组，而且更加方便
console.log(arr);//打印整个数组
console.log(arr1[0]);//打印数组中索引为0的值，也就是第一个值
//获取数组中的一个值 ：数组名[值的位置]；
//数组中值的位置从0开始计算

我们现在来小小的总结一下：

• 数组的创建： 数组可以用构造函数方法创建，也可以用简化方法创建，简化方法：var 变量名 = [ ];
  注意： 在使用构造函数方法创建时，如果只传入一个数字，则会被当做定义数组长度，并不会被作为数组的值保存
• 数组的索引： 我们将值存进数组的时候，数组会给值一个索引(又叫做下标)，也就是它在数组中的位置
  注意： 索引从0开始计数，索引为0就是第一个值，索引为1就是第二个值，第n个值的索引就是n-1
• 数组的访问与修改： 我们可以通过引用数组名来访问整个数组，也可以通过引用数组名+索引来获取数组内某一个值
  注意： 索引号需用方括号 [] 包裹，且只能是整数，修改数组的某个值的方法和访问方法一样,只需要重新赋值即可：arr[0] = 20;
• length属性：设置或返回数组中元素的数目，也就是数组的长度，一般常用来获取数组长度

数组的方法：

和其他对象一样，数组作为JS中的一个重点，同样拥有很多操作方法，他们非常重要：

1、数组的添加与删除：

• unshift()向数组的开头添加一个或更多元素，并返回新的长度。
  1、 格式：数组变量.unshift(值，值。。)
  2、 返回值：添加之后的数组长度
• shift()删除并返回数组的第一个元素
  1、格式：数组变量.shift()
  2、返回值：删除的第一个值

//创建一个数组
var arr = [10,20,30,"字符串",true];
//向数组开头添加一个元素并创建一个变量用来接收新的长度
var a = arr.unshift(10);
console.log(arr);
console.log(a);
//输出数组和接收的长度可知：arr = [10,10,20,30,"字符串",true]    6
var arr1 = [10,20,30];
//删除并返回数组的第一个元素
var b = arr1.shift();
console.log(arr1);
consloe.log(b);
//输出数组和接收到的元素：arr1 = [20,30]    10

• push()向数组的末尾添加一个或更多元素，并返回新的长度。
  1、格式：数组变量.push(值，值。。)
  2、返回值：添加之后的数组长度
• pop()删除并返回数组的最后一个元素
  1、格式：数组变量.pop()
  2、返回值：删除的最后一个元素
  使用方法和上面一样，只是把修改的位置变为了最后一个

//创建一个数组
var arr = [10,20,30,"字符串",true];
//向数组末尾添加一个元素并创建一个变量用来接收新的长度
var a = arr.push(10);
console.log(arr);
console.log(a);
//输出数组和接收的长度可知：arr = [10,20,30,"字符串",true,10]    6
var arr1 = [10,20,30];
//删除并返回数组的最后一个元素
var b = arr1.pop();
console.log(arr1);
consloe.log(b);
//输出数组和接收到的元素：arr1 = [10,20]    30

注意： 以上使用添加和删除都在原数组做操作，会改变原数组

2、数组的拼接：

• concat()连接两个或更多的数组，并返回结果。
  1、格式：数组变量.concat(值，值。。。);
  2、返回值：新数组值可以是数组也可以是数据。
  注意: concat()方法不会改变原数组

//分别创建两个数组
var arr1 = [10,20,30];
var arr2 = [40,50,60];
//将用concat()方法将两个数组拼接到一起
var arr3 = arr1.concat(arr2);
console.log(arr3);//arr3 = [10,20,30,40,50,60];
//我们在来看一下arr1和arr2是否改变
console.log(arr1);
console.log(arr2);
//输出结果和初始数组相同，并未改变

所以： concat()方法是将作为参数传进去的数组拼接到了绑定的数组后面，它会产生一个新的数组，但并不会对原来的数组产生影响

3、将数组的所有元素放进一个字符串：

• join()把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
  1、 格式：数组变量名.join(指定字符)
  2、 返回值：字符串
  注意: join()方法不会改变原来的数组

//创建一个数组
var arr = ["字符串",10,true];
//创建一个变量用来保存返回的字符串
var a = arr.join();
//输出获得的字符串和原数组
console.log(a);//获得的字符串是"字符串,10,true"
console.log(arr);//获得原数组,显然,它不会改变原来的数组

在默认情况下,join()是以分号为分隔符,但是我们也可以自定义分隔符,只需要将我们想要的分隔符作为参数传进去,注意,必须以字符串的形式传入，如：arr.join("-----");

4、数组排序：

• sort()对数组的元素进行排序
  1、格式：数组变量.sort()
  2、返回值：排序后的新数组
  注意: sort()方法会改变原数组
• 数组排序有两种方法：
  1、默认排序，引用sort()方法而不传入任何值,即默认排序,它按照数组内每个值的相同位数的大小排序:

//创建一个数组
var arr=[10,12,1,5,43,7]
//创建一个变量用来获取返回值
var a = arr.sort();
//输出接收到的新数组和原数组
console.log(a);
console.log(arr);
//返回结果都为[1, 10, 12, 43, 5, 7],显然这个方法会改变原数组

默认排序:先比较数组成员个位数的大小,个位数越大,位置越靠后,个位相同,比较十位数的大小,百位、千位等等依次比较，若碰到非数字，则会比较其字符编码

如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。

2、我们也可以自定排序标准，我们需要向方法中传入一个回调函数：排序函数

//创建一个数组
var arr=[10,12,1,5,43,7]
//创建一个变量用来获取返回值
var a = arr.sort(function (a,b){
        return a - b;
});
//输出接收到的新数组和原数组
console.log(a);
//输出结果为:[1, 5, 7, 10, 12, 43]

回调函数内传入两个型参 a 和 b ,然后在函数内返回a - b ;这就是从小到大排序,同样非数字按照字符编码排序

//创建一个数组
var arr=[10,12,1,5,43,7]
//创建一个变量用来获取返回值
var a = arr.sort(function (a,b){
        return b - a;
});
//输出接收到的新数组和原数组
console.log(a);
//输出结果为:[43, 12, 10, 7, 5, 1]

在函数内返回 b - a ;这是从小到大排序，想知道他们的原理吗？我们来看看：

//创建一个数组
var arr=[4,5,2,34,7,3,7,345,567,1,476,24];
//创建一个变量用来接收新产生的数组
var newArr=arr.sort(numFunc);
//向sort()方法传入了一个回调函数用来判断大小
function numFunc(a,b){   
//这个回调函数由两个型参,分别是a和b
    if(a>b){       
    //判断a是否大于b
        return -1;   
        }else if(a==b){ 
        return 0;   
        }else{ 
        return 1;   
    }
}

通过上例我们得知:

如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：

• 若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
• 若 a 等于 b，则返回 0。
• 若 a 大于 b，则返回一个大于 0 的值。

数组反转：

• reverse() 方法用于颠倒数组中元素的顺序。
  1、格式：数组变量.reverse()
  2、返回值：新数组
  注意： reverse()方法会改变原数组

//创建一个数组
var arr=[10,12,1,5,43,7]
//创建一个变量用来获取返回值
var a = arr.reverse();
//输出接收的新数组和原数组
console.log(a);
console.log(arr);
//都输出: [7, 43, 5, 1, 12, 10],显然,reverse()方法会改变原数组

截取数组:

这个方法是比较重要的方法

• slice() 方法可从已有的数组中返回选定的元素。
  1、格式： 数组变量.slice(开始位置索引)
  -从指定的位置开始截取到数组的最后
  2、数组变量.slice(开始位置，结束位置)
  -从开始位置截取到结束位置之前的所有元素
  注意： 位置参数可以正，可以负，正数和0标识从前往后，负数标识从后向前数。
  注意： slice()方法不会对原函数造成影响

//创建一个数组
var arr=[10,12,1,5,43,7]
//创建一个变量用来获取返回值
var a = arr.slice(1,3);
//输出接收的新数组和原数组
console.log(a);//输出截取到的新数组:[12, 1]
console.log(arr);//输出被截取后的原数组:[10, 12, 1, 5, 43, 7]
//显然,slice()方法不会对原函数造成影响

截取可以让我们随意的删除数组中的某个或者某些元素,是不是比前面介绍的pop()和shift()方法更加强大?但是,数组方法中还有一个更加强大的方法:

增删改万能操作函数：

• splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
  1、完整格式：数组变量.splice(开始位置，删除数量，新增的元素，新增的元素);
  注意： splice()方法参数中的开始位置和删除数量是必填的，如果删除数量添0则是不删除。新增元素是可选的、可以不填，也可以填多个。
• 在指定位置添加元素： 在数组的指定位置添加元素数组变量.splice(开始位置，0，新增元素);

//创建一个数组
var arr=[10,12,1,5,43,7]
//创建一个变量用来获取返回值
var a = arr.splice(1,0,"新元素");
//输出接收的新数组和原数组
console.log(a);//[]输出空数组,因为原数组没有删除的元素
console.log(arr);//输出的原数组:[10, "新元素", 12, 1, 5, 43, 7]
//可以看到,原数组中有了"新元素",所以,splice是直接影响到原数组

3、在指定位置删除指定数量的元素： 在数组的指定位置删除元素数组变量.splice（开始位置，删除数量）;

//创建一个数组
var arr=[10,12,1,5,43,7]
//创建一个变量用来获取返回值
var a = arr.splice(1,3);
//输出接收的新数组和原数组
console.log(a);//输出:[12, 1, 5],这是截取到的元素
console.log(arr);//输出:[10, 43, 7],这是原数组,
//可以看到,被截取的元素以从原函数中剔除,从索引为 1 的位置开始截取,截取数量为3个

4、在指定位置替换指定数量的元素： 在数组的指定位置替换元素数组变量.splice(开始位置，删除个数，删除个数个新值。。。);

//创建一个数组
var arr=[10,12,1,5,43,7]
//创建一个变量用来获取返回值
var a = arr.splice(1,3,"第一个","第二个","第三个");
//输出接收的新数组和原数组
console.log(a);//输出的新数组为:[12, 1, 5]
console.log(arr);//输出的原数组为:[10, "第一个", "第二个", "第三个", 43, 7]
//替换元素的原理是将指定位置的元素删除,然后再添加相同数量的新元素

注： 作为数组最为强大的方法，splice()方便而又灵活,是非常常用的,此外,以上这些常用的方法建议牢牢记住,
以上只是列举了一些数组常用的操作，数组还有一些方法：

Array 对象方法

关于数组元素查询:

数组索引既可以从前向后查，也可以从后向前查。

- 从前向后查的时候，索引为正，从 0 开始，如第一个元素索引为 0 、第二个为1 ......

- 从后向前查的时候，索引为负，从 -1 开始，如最后一个元素索引为 -1 ，倒数第二个为 -2 ，倒数第三个为 -3 ......