js对象

Object对象

Object对象包含如下属性和方法，也就意味着一切对象（函数也是对象）都包含如下方法。 
每种方法和属性在不同的对象中有不同的作用，并不是每种对象都有使用每个方法的必要。

下面是Object对象的派生对象在使用这些方法和属性时的意义。Object对象只是定义了他们，并没有使用他们。 
__proto__属性是保存当前对象的原型对象。对象通过这个属性产生了原型链

Object对象的__proto__ 为空

constructor属性

constructor属性是保存当前对象的构造函数，js通过构造函数来实现对象的实例化。

下面的例子中，constructor保存的就是Object构造函数。

var obj1 = new Object();
obj1.id = "obj1";
var obj2 = {
  "id": "obj2"
};

console.log(obj1.constructor);//function Object(){}
console.log(obj2.constructor);//function Object(){}

hasOwnProperty(propertyName)方法

hasOwnProperty方法接收一个字符串参数，该参数表示属性名称，用来判断该属性是否在当前对象实例中，而不是在对象的原型链中。我们来看看下面这个例子：

var arr = [];    //实例化了一个Array对象
console.log(arr.hasOwnProperty("length"));//true
console.log(arr.hasOwnProperty("hasOwnProperty"));//false

在这个例子中，首先通过定义了一个数组对象的实例arr，我们知道数组对象实际是通过原型链继承了Object对象，然后拥有自己的一些属性，我们通过hasOwnProperty方法判断length是arr自己的属性，而hasOwnProperty是在原型链上的属性。

isPrototypeOf(Object)方法

isPrototype方法接收一个对象，用来判断当前对象是否在传入的参数对象的原型链上，说起来有点抽象，我们来看看代码。

function MyObject() {}
var obj = new MyObject();
console.log(Object.prototype.isPrototypeOf(obj));  //true

我们知道MyObject是继承自Object对象的，而在JS中，继承是通过prototype来实现的，所以Object的prototype必定在MyObject对象实例的原型链上。

propertyIsEnumerable(prototypeName)方法

prototypeIsEnumerable用来判断给定的属性是否可以被for..in语句给枚举出来。看下面代码：

var obj = {
    name: "objName"
} 
console.log(obj.propertyIsEnumerable("constructor"));//false

判断“constructor”是否可以被枚举，输出false说明无法被枚举出来。

toLocaleString()方法

toLocalString方法返回对象的字符串表示，和代码的执行环境有关。

var obj = {};
console.log(obj.toLocaleString());//[object Object] 

var date = new Date();
console.log(date.toLocaleString());//2016/2/28 下午1:39:27

toString()方法

toString用来返回对象的字符串表示。

var obj = {};
console.log(obj.toString());//[object Object]

var date = new Date();
console.log(date.toString());//Sun Feb 28 2016 13:40:36 GMT+0800 (中国标准时间

valueOf()方法

valueOf方法返回对象的原始值，可能是字符串、数值或bool值等，看具体的对象。

var obj = {
  name: "obj"
};
console.log(obj.valueOf());//Object {name: "obj"}

var arr = [1];
console.log(arr.valueOf());//[1]

var date = new Date();
console.log(date.valueOf());//1456638436303

String对象

Number对象

number.valueOf()：返回数学对象的原始值  
number.toExponential(fractionDigits)：将数字转换为指数表示形式字符串，fractionDigits指定指数的小数位的位数, 取值区间[0,20]. 
number.toFixed(fractionDigits)：将数字表示成10进制字符串, fractionDigits同上. 
number.toPrecision(precision)：与toFixed()类同, 只是precision指定的是数字的有效位数, 取值范围[0,21]. 
number.toString(radix)：将number转换为需要的进制字符串形式，radix默认是10.

Date对象

var date = new Date(); 
属性:  
constructor 所建立对象的函数参考  
prototype 能够为对象加入的属性和方法 

方法:  
getDay() 返回一周中的第几天(0-6)  
getYear() 返回年份.2000年以前为2位,2000(包含)以后为4位  
getFullYear() 返回完整的4位年份数  
getMonth() 返回月份数(0-11)  
getDate() 返回日(1-31)  
getHours() 返回小时数(0-23)  
getMinutes() 返回分钟(0-59)  
getSeconds() 返回秒数(0-59)  
getMilliseconds() 返回毫秒(0-999)  
getUTCDay() 依据国际时间来得到现在是星期几(0-6)  
getUTCFullYear() 依据国际时间来得到完整的年份  
getUTCMonth() 依据国际时间来得到月份(0-11)  
getUTCDate() 依据国际时间来得到日(1-31)  
getUTCHours() 依据国际时间来得到小时(0-23)  
getUTCMinutes() 依据国际时间来返回分钟(0-59)  
getUTCSeconds() 依据国际时间来返回秒(0-59)  
getUTCMilliseconds()依据国际时间来返回毫秒(0-999)  
getTime() 返回从1970年1月1号0:0:0到现在一共花去的毫秒数  
getTimezoneoffset() 返回时区偏差值,即格林威治平均时间(GMT)与运行脚本的计算机所处时区设置之间相差的分钟数)  
parse(dateString) 返回在Date字符串中自从1970年1月1日00:00:00以来的毫秒数  
setYear(yearInt) 设置年份.2位数或4位数  
setFullYear(yearInt)设置年份.4位数  
setMonth(monthInt) 设置月份(0-11)  
setDate(dateInt) 设置日(1-31)  
setHours(hourInt) 设置小时数(0-23)  
setMinutes(minInt) 设置分钟数(0-59)  
setSeconds(secInt) 设置秒数(0-59)  
setMilliseconds(milliInt) 设置毫秒(0-999)  
setUTCFullYear(yearInt) 依据国际时间来设置年份  
setUTCMonth(monthInt) 依据国际时间来设置月(0-11)  
setUTCDate(dateInt) 依据国际时间来设置日(1-31)  
setUTCHours(hourInt) 依据国际时间来设置小时  
setUTCMinutes(minInt) 依据国际时间来设置分钟  
setUTCSeconds(secInt) 依据国际时间来设置秒  
setUTCMilliseconds(milliInt)依据国际时间来设置毫秒  
setTime(timeInt) 设置从1970年1月1日开始的时间.毫秒数  
toGMTString() 根据格林威治时间将Date对象的日期(一个数值)转变成一个GMT时间字符串,如:Weds,15 June l997 14:02:02 GMT  
toUTCString() 根据通用时间将一个Date对象的日期转换为一个字符串  
toLocaleString() 把Date对象的日期(一个数值)转变成一个字符串,使用所在计算机上配置使用的特定日期格式  
toSource() 显示对象的源代码  
toString() 将日期对象转换为字符串  
UTC(yyyy, mm, dd, hh, mm, ss, msec)返回从格林威治标准时间到指定时间的差距,单位为毫秒  
valueOf() 返回日期对象的原始值 

RegExp对象

Math对象

属性: 
constructor 所建立对象的函数参考 
prototype 能够为对象加入的属性和方法

E 欧拉常量,自然对数的底(约等于2.718) 
LN2 2的自然对数(约等于0.693) 
LN10 10的自然对数(约等于2.302) 
LOG2E 以2为底的e的对数.(约等于1.442) 
LOG10E 以10为底的e的对数(约等于0.434) 
PI ∏的值(约等于3.14159) 
SQRT1_2 1/2(0.5)的平方根(即l除以2的平方根,约等于o.707) 
SQRT2 2的平方根(约等于1.414)

方法: 
abs(x) 返回数字的绝对值 
acos(x) 返回数字的反余弦值 
asin(x) 返回数字的反正弦值 
atan(x) 返回位于-PI/2 和 PI/2 的反正切值 
atan2(y,x) 返回（x,y）位于 -PI 到 PI 之间的角度 
ceil(x) ceil() 方法执行的是向上取整计算，它返回的是大于或等于x，并且与之最接近的整数。与floor是一对相反的函数 
cos(x) 返回一个数字的余弦值 
exp(x) 返回 E^x 值 
floor(x) floor() 方法执行的是向下取整计算，它返回的是小于或等于x，并且与之最接近的整数。

log(x) 返回底数为E的自然对数 
max(x,y) 返回 x 和 y 之间较大的数 
min(x,y) 返回 x 和 y 之间较小的数 
pow(x,y) y^x , 返回 x 的 y 次幂的值 
random() 返回位于 0 到 1 之间的随机函数 
round(x) 四舍五入后取整 
sin(x) 返回数字的正弦值 
sqrt(x) 返回数字的平方根 
tan(x) 返回一个角度的正切值 
toSource() 显示对象的源代码 
valueOf() 返回数学对象的原始值 
扩展: 
1.绝对值是指一个数在数轴上所对应点到原点的距离叫做这个数的绝对值,是两个点的距离,，绝对值用“ | |”来表示。|b-a|或|a-b|表示数轴上表示a的点和表示b的点的距离,（零绝对值0）. 
2.四舍五入都是对小数而言的. 
3.x=y%2 表示,x=y/2的余数

Array数组

 

JS函数对象

任何函数function都派生于Funciton对象，而Function对象派生于Object对象

可以使用关键字function创建函数对象；无需指定返回值类型；参数列表声明不需var关键字；无函数重载；函数内部可以直接调用arguments数组（隐式定义），该数组存储了实参列表；函数名代表一种引用类型，可用（函数名 instanceof Function）测试；打印函数引用会输出整个函数定义。

3.1动态函数和匿名函数

1）动态函数: 动态函数是通过js的内置对象Function定义。形式为：new Function(arg1 , arg2)，由于arg1和arg2为变量，所以可以动态指定。如： 
var run = new Function(“x,y”,”return x+y;”);

2）匿名函数：没有函数名，形如：var run = function(x,y){return x+y;}; 
注：打印动态函数的引用可以发现动态函数也是匿名函数。

3.2 全局函数

String(object) 将一个对象值转换为一个字符串  
Number(object) 将一个对象的值转换为一个数字 
Eg:sum+=Number(cell.innerText); 
eval(str)接收一个字符串形式的表达式，并试图求出表达式的值。作为参数的表达式可以采用任何合法的操作符和常数。如果参数中包含JS命令，这些命令也可以被执行，就像这些命令是JS程序的一部分一样。 
函数可计算某个字符串，并执行其中的的 JavaScript 代码。eval(“2+3”) // 返回 5 
decodeURI(URIstring) 为加密的URI进行解码  
decodeURIComponent(URIstring) 为加密的URI组件解码  
encodeURI(URIstring) 将字符串加密为URI  
encodeURIComponent(URIstring) 将字符串加密为URI组件  
parseInt(str) 将一个字符串解析为一个整数,不是四舍五入操作,而是切尾  
试图从一个字符串中提取一个整数。可附加一个n整数实现返回n进制整数。如果在字符串中存在除了数字、符号、小数点和指数符号以外的字符，就停止转换，返回已有的结果。如果第一个字符就不能转换，函数就返回NaN值。 
parseFloat(str)试图从一个字符串中提取一个浮点值。如果在字符串中存在除了数字、符号、小数点和指数符号以外的字符，就停止转换并返回已有的结果。如果第一个字符就不能转换，函数就返回NaN值。 
isNaN()用于判断是否为NaN值类型，如果是函数返回true。 
isFinite(number)可以判断参数number是否是一个无穷。如果是则函数返回false，否则返回true。 
escape(string)对一个字符串进行解码  
接受一个字符串，这个字符串中可能含有空格、分号等字符。函数把字符串转换成Cookie的内部表示方式。函数返回值就是这种内部的表达方式。 
函数可对字符串进行编码，这样就可以在所有的计算机上读取该字符串 
unescape(string)接受一个Cookie，把其内部表达方式转化成普通的字符串形式。 JS函数一共可分为常规函数、数组函数、日期函数、数学函数、字符串函数等五类。

var student1 = new Object();    //定义对象引用，或者var student1 = {},new Object()。所有的包装类都派生于Object。Object基类包含hasOwnProperty、isPrototypeOf、propertyIsEnumerable、toLocaleString、toString、valueOf方法
student1.name = "student1";     //直接设置同时添加对象属性
student1["age"]=12;                 //直接设置同时添加对象属性
student1.getname = function(){      //设置添加对象方法。函数表达式，只有在执行到本行才解析
   return this.name;                //this表示作用对象，这里为student1
};
//var {name:personname, age:personage} = student1;  //解构赋值，对应项使用副本赋值，如[value1,value2]=[value2,value1];可实现两个基本数据交换
printf(JSON.stringify(student1));   //JSON.stringify把对象转化为JSON字符串表示

student1 = {
    name:"student1",
    _age:12,                        //前面有下滑线是一种常用的标记，用于表示只能通过对象方法访问的属性,只是对开发者的一种标记习惯，并不是真的私有变量
    getname:function(){
        return this.name;
    }
};
Object.defineProperty(student1,"name1",{  //可以用于定义新数据属性，也可以修改原有数据属性。也可以不使用defineProperty可以直接定义数据属性。也可以使用defineProperties同时定义多个数据或访问器属性
    writable:true,                  //对象属性的数据属性，是否可修改
    enumerable:true,                //对象属性的数据属性，通过for-in遍历到
    configurable:true,              //对象属性的数据属性，能否通过delete删除属性，configurable属性在定义为false以后，就不能再被设置
    value:"sst"                     //对象属性的值属性，默认为underfined
});
Object.defineProperty(student1,"age",{   //访问器属性，不能直接定义，必须通过defineProperty定义，不包含数据值，设置时调用set函数，读取时调用get函数。访问器属性名称不要和数据属性名称相同
     get:function(){return this._age},
    set:function(newvalue){this._age=newvalue;this.name="xxt";}
});
student1.age=22;                //age不是数据属性，而是访问属性。这里是调用了set函数，
Object.preventExtensions(student1);//设置对象不可被扩展，以后再添加属性都是underfined，防止被篡改
Object.seal(student1);              //密封对象，对象不能添加删除属性。
Object.freeze(student1);            //冻结对象，属性不可修改。只能通过set访问器修改
printf(JSON.stringify(student1)); //将JSON格式转化为字符串。JSON格式即KEY-VALUE格式
for(var myproperty in student1){ //for in遍历对象属性
    console.log(myproperty,":",student1[myproperty]);
}




function Student(name,age){         //自定义函数，构造函数，等同于java中的自定义类。所有的类型派生于Object
    var sex="男";                //函数内部为私有属性
    this.name=name;                 //通过this创建的是可以被实例对象访问的
    this.age=age;
    this.getName=function(){
        return this.name;       //函数内部this表示此函数引用的拥有者，不是传入参数。当作为全局函数时，this表示window
    };
    this.setName= function(name){  //函数不关心传入或者定义的参数数量和类型，因此所有函数没有重载
        if(typeof name=="string")  //基本数据类型，做类型检验，避免参数传递错误
            this.name = name;      //没有指定返回值，实际返回的是undefined
    };
    this.getAge =function (){
        if(this.age.toFixed(2)<<2) //转化为false的值："",0,NaN,null,underfined。其他转化为true，类型首字母大写，变量首字母小写，<<按位移动，<<<无符号按位移动,toFixed(2)表示保留2位小数
            return -~this.age;     //~按位取非，&按位取与，|按位取或 ^按位取异或，一元减号，表示取负
        return this.age;            //保证所有路径都有返回值，虽然不加也不会出错，因为有默认返回值undefined
    };
    this.setAge= function(age){     //函数参数总是按值传递，无论基本类型还是引用类型，引用类型传递引用的值，不传递指向对象的值
        if(age instanceof Number){ //包装类型，做类型检验，避免参数传递错误
            this.age = parseInt(age.toString(16),16);//parseInt将字符串化为整数，支持识别多进制和转化为多进制，toString()转化为字符串，支持多进制转化
        }
        //typeof判断基本类型，underfined声明未定义(underfined类型只有一个值)，boolean布尔型，string字符串，number数值，object对象或null(null类也只有一个值)，function函数
        //instanceof判断包装类型，基本类型对象的包装类型为Underfined,Boolean,String,Number,Object,
        typestr = typeof("getAge"); //省略var的变量为全局变量
    }
}
student1=new Student("小明",12);          //new是创建了一个新对象，构造函数将属性和方法绑定到这个新对象上
Student("小红",13);                   //作为全局函数。通过构造函数将属性绑定到window上
var student2 = new Object();
Student.call(student2,"小刚",14);     //call和apply通过构造函数，将属性绑定到以存在对象student2上
if(student2 instanceof Student)         //instanceof判断变量是否是某个类型或其派生类型实例的，student1是Student类，同时也是Object
     printf(student2.name);


//js的继承有多重方式。每种方式的内存操作都是不同。下面展示其中一种。
// js的类型继承原理和java、c#相同。派生类继承基类时，会实例化(浅复制)一个基类对象和保留引用在派生类空间。派生类内的实例的基类和派生类自定义的函数分别操控各自的属性。在函数和属性操作中时，会自动先派生后基类的顺序查找，不用手动查找
//关于实例化：只复制且全部复制在构造函数中开辟了内存的变量，包括引用变量。派生类实例化时基类对象进行浅复制。
function Monitor(){   //自定义函数，相当于自定义一个类，类名Monitor。在文件中多称为构造函数，相当于c++和java中的自定义类。每个函数类，都有基类Object
    this.task=["学习"];
}
Monitor.prototype.data = "原型数据";  //prototype获取派生类的基类对象引用，通过基类对象引用直接为基类添加属性。系统会为派生类提供默认原型，也可以通过继承自定义原型
person1 = new Monitor();                //通过函数类实例化对象
person2 = new Monitor();                //实例化对象
Object.getPrototypeOf(person1).data="原型数据1";  //通过实例修改原型。Object.getPrototypeOf()获取对象原型。实例对象包含对原型的引用，但需要使用getPrototypeOf函数获取
person1.data="派生数据";            //修改派生类属性，这样当查找data数据会先自动搜索派生类，再自动搜素基类。

printf(person1.hasOwnProperty("data"));     //是否拥有指定属性(不算基类属性)。true因为自定义了该属性
printf(person1.data);                           //读取自定义属性

var keys = Object.keys(Monitor.prototype);      //获取对象所拥有(不包括继承的)的可枚举实例，Monitor是类，Monitor.prototype是基类实例。如果换成person1，则只能获取派生类的自定义属性。getOwnPropertyNames可获取对象拥有的所有属性
printf(keys);
delete person1.data;                            //删除派生类自定义的属性
printf(person1.hasOwnProperty("data"));         //是否拥有指定属性。false，因为该属性在派生类中被删除了，只有基类中存在，虽然可以访问，但是是继承过来的，不是自己拥有的
printf("data" in person1);                  //是否包含指定属性。true包含，只是不拥有
printf(person1.data);                           //基类属性
Monitor.prototype.sex=["男"];                //通过派生类向基类添加数组引用变量
person1.sex.push("女");                          //在实例对象中保留了基类的引用和浅复制了基类对象。这里的sex是经过了一次从派生类到基类的向上查询。
printf("基类中的引用:"+person2.sex);          //实例对象连带更新。所以构造函数用于指定专属属性，原型用于存放共享属性
person1.task.push("工作");                    //修改构造函数中引用指向的对象
printf("派生类中的引用:"+person2.task);        //实例对象不连带更新构造函数中的数据。因为实例化时会深复制构造函数中的所有数据，在实例化时为每个对象都创建

Monitor.prototype=new Student("组长",12);     //继承，派生类Person设置基类为Student。在继承中会为浅复制一个基类实例放在派生类空间中，同时将引用存储为prototype，放在派生类Person中