类数组对象：（看例子）           
var a = {};       
var i =10;
while(i<10){
 a[i] = i*i;
i++;
}
数组对象：
var b = [];
var i =0;
while(i<10){
b[i] = i*i;
i++;
}
其实你从源代码上面去看也没有什么大的区别：
但是js中是支持  1: 类名【属性名称】 = 值  相当于 2:类名.属性名称 = 值 
要是你想在类中使用动态的属性  就必须用第一个   
下面看下下区别吧：
类数组对象：
console.log(typeof a);//object 注意：数组也是对象哦
console.log(a); //  Object {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81} 很明显对象啊
console.log(a.length); //undefined  区别就在这了  类数组对象没有长度的属性和数组的方法
console.log(Object.prototype.toString.call(a));//[object Object] 
数组对象：
console.log(typeof b);//object
console.log(b);//  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  很明显数组啊 
console.log(b.length); //8
console.log(Object.prototype.toString.call(b));//[object Array]
 
 
在上一个判断是对象还是数组的方法
 
var isArray = Function.isArray || function(o){
 return typeof o === "object" && Object.prototype.toString.call(o) == "[object Array]";
}
​

 

有很多初学者可能会觉得这两个是一样的，以前我也是这么认为的。但是它们是不一样的，虽然他们都是数组。数组只是一个值得集合，而数组对象是一个对象的集合；数组对象的范围更大。

数组是一个值得集合，每一个值都有一个索引号，索引从0开始而每个索引都有一个相应的值，根据需要添加更多的值。数组有一维数组、二维数组等。

我们知道变量用来存储数据，一个变量只能存储一个内容。如果需要存储更多的数据一个变量是不能够满足的。例如：有一个班的学生成绩需要存储，如果用变量来一个一个的存储就会变得比较麻烦。这时候就会用到数组了，把一个班的学生成绩都放到一个数组里面。

如下图：



要使用数组之前则需要创建一个数组，那么该如何创建数组呢？

首先把数组本身赋值给一个变量，然后再给这个数组赋值。创建数组的同时还可以为这个数组指定长度，长度可以任意指定。虽然在创建数组的同时还指定了长度，但实际上数组都是会变长的。也就是说即使指定了长度，仍然可以将元素存储在规定长度之外。

刚创建好的数组是一个空数组，没有值，如果输出，就会显示为undefined。所以要给数组赋值。赋值有两种方法：一种是在创建数组的同时赋值；还有一种是直接输入一个数组（也叫字面量数组）。如下图：



在使用数组的时候需要用到索引号，要得到一个数组元素的值，就需要引用数组变量并提供一个索引。特别需要注意的是索引从0开始。

数组对象是一个对象的集合，里面的集合可以是不同类型的。数组的每一个成员对象都有一个下标，用来表示他在数组中的位置，从0开始。虽然定义数组时，这个数组也是空的，但是它定义时会指定n个空元素的数组，而且在定义数组的时候直接初始化数据；例如：var数组名 = [<元素一>、<元素二>、<元素三>…];在使用数组的时候需要用到元素的下标，下目标要用括号括起来，从零开始。

数组对象有一个的属性：length；用法：<数组对象>.length；返回的是数组的长度，即数组里有多少个元素，它等于数字里最后一个元素的下标加一。这个属性再用构造函数Array()创建数组时会初始化；在给数组添加新元素时（如果必要）将更新length的值。设置length属性得知可以改变数组的大小。如果设置的值比它当前的值小，数组将被截断，其不在length值内的元素将丢失。如果设置的值比它的当前值大，数组将增大，新元素将被添加到数组尾部，它们的值为undefined。

对象数组有很多方法，这里就不全部列举，只是简单地说几个。

数组链接的方法：contact()；contact()方法用于连接两个或者多个数组，会返回一个新的数组，不改变原来的数组。如果进行contact()操作的参数是一个数组，那么添加的是数组中的元素，而不是数组。



指定分隔符连接数组元素的方法：join()；join()方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。他有一个参数：separator；在返回的字符串中用于分隔数组元素的字符或字符串，它是可选的。如果省略了这个参数，将会用逗号作为分隔符。它的返回值是一个字符串，通过把数组中的每一个元素转换成字符串，然后把这些字符串连接起来，在两个元素之间插入指定的separator字符串。返回生成的字符串。这个方法不影响数组原来的内容。



将数组进行排序的方法：sort()；sort()方法是数组中的元素按照一定的排序顺序排列。排序是在原数组上进行排序，不制作副本。它也有个参数：orderfunc()；可选。如果调用方法sort()是没有使用参数，将按照字母顺序（更为精准的说，是按照Unicode码的顺序）对数组中的元素进行排序。要实现这一点，首先把数组的元素都转化成字符串（如果有必要的话），以便进行比较。如果想按照别的排序进行排序，就必须提供函数，该函数要比较两个值，然后返回一个用于说明这两只的相对顺序的数字。比较函数应该具有连个参数a和b，返回值如下：

如果返回值<=-1，则表示A在排序后的序列中出现在B之前。

如果返回值>-1&&<1，则表示A和B具有相同的排序顺序。

如果返回值>=1，则表示A在排序的序列中出现在B之后。



按照升序来排序。输出之后如下图：



需要注意的是，数组中undefined的元素都排列在数组末尾。即使你提供了自定义的排序函数也是这样，因为undefined值不会被传递给你提供的orderfunc。

数组较为简单一点，数组对象有属性和一些方法，更为复杂。

如果以上有什么错误请联系我，我会及时更改的。

  //两个数组对象中查看 其中一个数组对象是否包含另一个数组对象中的值
      let arr = [
        {key:1,val:"张胜男"},
        {key:2,val:"王五"},
        {key:3,val:"李四"},
        {key:4,val:"刘超"},
        {key:5,val:"赵四"}
      ]
      let arr2 = [
        {key:1,val:"张胜男"},
        {key:2,val:"王五"},
       {key:6,val:"666"},
       {key:7,val:"777"},
       {key:8,val:"888"},
       {key:9,val:"999"},
      ]
      //如果能找到就返回对应的下标，如果找不到，就返回-1
      for(let i=0;i<arr.length;i++){
        const Index = arr2.findIndex((item) => {return item.key === arr[i].key})
        console.log(Index);  // 0、1、-1、-1、-1
        // 前两个数据的key值相同，打印出对应的下标 ，后面找不相同的key  输出-1
      }

  //两个数组对象中查看 其中一个数组对象是否包含另一个数组对象中的值
      let arr = [
        {key:1,val:"张胜男"},
        {key:2,val:"王五"},
        {key:3,val:"李四"},
        {key:4,val:"刘超"},
        {key:5,val:"赵四"}
      ]
      let arr2 = [
        {key:1,val:"张胜男"},
        {key:2,val:"王五"},
       {key:6,val:"666"},
       {key:7,val:"777"},
       {key:8,val:"888"},
       {key:9,val:"999"},
      ]
      
      for(let task of arr){
        const itemJson = arr2.find((item)=>{return item.key === task.key});
        console.log(itemJson)
        //{key: 1, val: "张胜男"}
        //{key: 2, val: "王五"}
        // 3 undefined
       // 如果有相同的值那么就返回对应的对象 如果没有则返回 undefined
       }

上述两种方法都能找出 一个数组对象中是否包含另一个数组对象中的元素，两种方法返回的结果不同，一个是返回下标，另外返回对应的对象，在实际应用场景中可根据不同需要选择不同的使用方式。

需求：后台将一个带有日期格式（不是时间戳）的数组对象给到前端，前端打印这个数组对象的日期时需要按时间降序排列
思路：
1.先将对象中的日期字段变成时间戳，然后通过sort()来排序，接着将对象中的时间戳变成日期； 2.先给对象增加一个字段publishTimeNew，用来保存时间戳；然后通过sort()来排序publishTimeNew
虽然第二种思路多增加了一个publishTimeNew字段占用空间，但是减少了最后将时间戳变成日期的操作，所以我选择了第二个思路，下面是我的实现：
<script>
    var data = [
    {
        id: 1,
        publishTime: "2018-07-02 10:39:43"
    },
    {
        id: 2,
        publishTime: "2018-07-14 10:39:43"
    },
    {
        id: 3,
        publishTime: "2018-07-15 10:39:43"
    },
    {
        id: 4,
        publishTime: "2018-07-13 10:39:43"
    }]
    var dateToTime = function(str){
		return (new Date(str.replace(/-/g,'/'))).getTime(); //用/替换日期中的-是为了解决Safari的兼容
    }
    for(var i=0; i < data.length; i++){
        data[i].publishTimeNew = dateToTime(data[i].publishTime);
    }
    data.sort(function(a, b) {
                    return b.publishTimeNew> a.publishTimeNew ? 1 : -1;
    });
    console.log(data);
</script>