1.var person =new Object(); //var person={};意思相同
person.name="Ni";   
person.age=20;   
//person["name"] (这是js特有语法，上同)
//[]由于内部是String类型，但是属性名是不可以为非字母非数字的
2.var person ={
    name:"Ni",
    age:20
};

//上面三种都可以省略new
1.var colors=new Array();
2.var colors=new Array(20); //长度为20的数组
3.var colors=new Array("green");//包含一项为green的colors数组

4.var colors=["red","blue","green"];//包含了red、blue、green的colors数组
5.var colors=[];//空数组
//访问数组可以通过index => arr[index]

//通过更改已有数组的length，可以将之后访问会变为undefined
var p=["n","m","l"];

p.length=4;
p[3] //第四个元素为undefined

p.length=2;
p[2] //原有的p[2]也变为undefined

//ES3
//用于检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上。
if(value instanceof Array){
    //对数组执行某些操作
}
//全局环境下多种框架的构造Array函数不同而受影响

//ES5(为了解决上方问题)
if(Array.isArray(value)){
    //对数组执行某些操作
}
//目的是确认是否为数组

//toLocaleString(), toString(),valueOf()  所有对象都有这个方法

var colors=["red","green","blue"];
colors.jion(","); //red,green,blue
colors.jion("||"); //red||green||blue

//push(),pop()
var colors=[];
var count=colors.push("red","green","blue"); //3
colors.length; //3

colors.pop(); //blue(最后一项)

// shift(),pop()
//与其相反的是unshift()
var colors=[];

var count=colors.shift("red","green","blue");
colors.pop();//red(第一项)

var count=colors.unshift("red","green","blue");
colors.pop();//red(最后一项)

//这两种都会直接改变原有数组
reverser()  //直接反转数组
sort()  //排序，会调用每个数组项的toString()所以进行的是String的比较方法

//可以调用其他函数的方式完成排序
let c=[0,1,2,13,8,-1];
        c.sort();
        c.sort((value1,value2)=>{
            if(value1<value2){
                return -1;
            }else if(value1>value2){
                return 1;
            }else{
                return 0;
            }
        })
//[-1, 0, 1, 2, 8, 13]

//不会改变原有函数
var colors=["red","green"]; 
var colors2=colors.concat("yello",["black","brown"]); //red,green,yello,black,brown

var colors=["red","green","yello","black"];
var colors2=colors.slice(2); //[yello,black]，从index为2的开始到结束
var colors3=colors.slice(1,2); //[green,yello]

//可以进行输入负数
//原数组长度为5
slice(-2,-1) == slice(5-2，5-1) == slice(3,4)

//删除
splice(0,2) //删除从第0位置的开始删除两个，他返回的是一个数组
//插入
splice(2,0,"red","green") // 从第2位置的开始插入"red""green"
//替换
splice(2,1，"red","green") // 从第2位置的开始,删除一个元素,插入"red""green"

var numbers=[1,2,3,4,5];

//五种迭代方法基本用法拿个every()打比方
number.every(function(item,index,array){
    return (item>2)
})
//上同
number.every((item,index,array)=>{
	return (item>2);
});

let values=[1,2,3,4,5];
//第一次运行数组的前两个值，之后prev都是return结果
let sum=values.reduce(funtion(prev,cur,index,array){
                      return prev+cur;
                      })
console.log(sum);//15
//reduceRight就是从数组的尾部开始取值与reduce相反

var date=new Date();//没接受参数就返回当前系统时间

//在传参数的情况，提供两种:Date.parse() <默认的>和Date.UTC()

//Date.parse() 接受参数:一个日期格式的字符串
//ES5新增YYYY-MM-DDTHH:mm:ss.sssZ(如2004-5-25T00:00:00)
var date=new Date("May 25,2004"); ==  var date=new Date(Date.parse("May 25,2004"));

//Date.parse() 接受参数（至少参数年月）：年，月（0-11），日（1-31），小时，分钟，秒，毫秒(基于系统时间的本地去创建而不是GMT来创建)
var date=new Date(Date.UTC(2005,4,5,17,55,55));
//对应时间：2005年5月5日17：55：55

var start =Date.now();
//调用函数
doSomething();
var stop =Date.now(),result=stop-start;

var exp= /pattern/flags;
//pattern 任意的正则表达式
//flags 可以存在一个或者多个，标明正则表达式的行为

/at/g;
//找到所有为at的实例

/[bc]at/i;
//找到第一个bat或者是cat的，不区分大小写

var parttern=/\[bc\]at/i;

//第一个参数的是/.../之间经过转义的原正则表达式，第二个参数是i,g,m模式
var parttern=new RegExp("\\[bc\\]at","i");

let text="mom and da and bady";
//?是捕获组的
let pattern=/mom(and dad(and bady)?)?/gi;

//现在match是一个数组array实例,而现在match现在有两个属性：index和input
//index：匹配项的在字符中的位置
//input: 原正则表达式
let match=pattern.exec(text);
match.index==0 //因为这个字符串本身与这个字符串匹配

//上面运行过程：第一项匹配整个字符串 > 在第一项的基础上匹配第二项 > 在第二项的基础上找第三项

var text="this has been a short summer";
var pattern=/(..)or(.)/g;

//构造函数属性会x被匹配相应捕获组的字符串进行自动填充
if (pattern.test(text)){
	alert(RegExp.$1); //sh
    alert(RegExp.$2); //t
}

//没有new,而且唯一
let sym=Symbol("sym"); //非全局

console.log(typeof sym);//symbol

let sym1=Symbol.for("sym1"); //全局，第一次寻找有没有定义的sym1标志，没有就会创建，如果有会返回之前创建的那个实例
Symbol.keyFor(sym1); //sym1 ,查询全局注册表，如果不是全局的会返回undefined

let s1=Symbol.keyFor("foo");
let	o={
	[s1]:'foo val';
}

let s2=Symbol.keyFor("bar");
let o={};
Object.defineProperty(o，s2,{value:"bar val"});

let s3=Symbol.keyFor("baz");
let s4=Symbol.keyFor("qux");
let o={};
Object.denfineProperties(o,{
    [s3]:{value:"baz val"},
    [s4]:{value："qux val"}
});

z//自定义的instanceof
class MyArray {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}
console.log([] instanceof MyArray); // true