javascript对象object详解

javascript 里最基本的数据类型是对象。

JavaScript里的对象其实是一个无序的属性集合，属性又是一个个的名-值对。

除了字符串，数字，true，false，null或者undefined以外，其他所有的值在JavaScript里头都是对象。

对象是引用类型，如果变量x表示一个对象，当执行var y = x;语句后，实际上y和x指向的是同一个对象。所以，当你通过y改变对象的值，这种变化也会反映到x上。

如何创建对象：

1. 字面量表示法：

var book = {};   //创建一个没有属性的对象

var book = {

name : "The Definitive Guide",

"main title" : "JavaScript",      //当属性名中间有空格，或者"-"时，要用引号把属性名括起来

author : {                          //对象的属性也可以是对象

firstname : "Rex",

lastname : "Mai

}

};

2. 使用new关键字：

var o = new Object(); // 创建一个空对象，效果等同{}.

var a = new Array(); // 创建一个空数组，效果等同 [].

var d = new Date(); // 创建一个表示当前时间的对象

var r = new RegExp("js"); // 创建一个正则表达式对象

3.使用Object.create()

这是ECMAScript5 新添加的方法，该方法接受一个参数——对象原型。

var o1 = Object.create({x:1, y:2});

var o2 = Object.create(Object.prototype);    // 结果等同于{}或new Object()

你可以给该方法传null，结果会是一个不继承任何属性和方法的空对象

获取对象的值：

通过.或者[]操作符。

book.title;

book["title"];

var propertyName = "title";

book[propertyName];

如果对象的属性是固定的，那么这两个方法的作用差别不大。但由于javascript是一种松散类型的语言，所以，你可以在程序运行期间为对象添加任意数量的属性。当你使用.操作符访问对象属性时，.后面的名字其实只是一个标识符，所以你必须完整的输入这个标识符，才能够访问到。

属性特性：

在ECMAScript5中，添加了API同获取和设置属性特性。在这里， 我 们有一个对象，property descriptor，它用来表示属性的4个特性（value/get, writable/set, enumerable, configurable)。其中，writable, enumerable和configurable属性为布尔值，get和set属性为function。

getOwnPropertyDescriptor()

我们可以通过Object.getOwnPropertyDescriptor()获取特定对象里某个属性的property descriptor，这个方法只能获取对象的自有属性。

// Returns {value: 1, writable:true, enumerable:true, configurable:true}

Object.getOwnPropertyDescriptor({x:1}, "x");

// Now query the octet property of the random object defined above.

// Returns { get: /*func*/, set:undefined, enumerable:true, configurable:true}

Object.getOwnPropertyDescriptor(random, "octet");

// Returns undefined for inherited properties and properties that don‘t exist.

Object.getOwnPropertyDescriptor({}, "x"); // undefined, no such prop

Object.getOwnPropertyDescriptor({}, "toString"); // undefined, inherited

defineProperty()

通过Object.defineProperty()来设置属性特性，该方法有3个参数，1.操作的对象，2.要修改或创建的属性名，3.property descriptor对象

var o = {}; // Start with no properties at all

// Add a nonenumerable data property x with value 1.

Object.defineProperty(o, "x", { value : 1,writable: true,enumerable: false,configurable: true});

// Check that the property is there but is nonenumerable

o.x; // => 1

Object.keys(o) // => []

// Now modify the property x so that it is read-only

Object.defineProperty(o, "x", { writable: false });

　　传入的property descriptor对象不需要把4个特性全部包含进去；如果是创建新属性，特性又没有出现在property descriptor对象里，则那些特性值为false或者undefined。如果是修改属性，没出现的特性值不会改变。该方法只会创建或修改自有对象，不会改变改变继承的属性。

　　应该也注意到了，Object.defineProperty()只能创建或设置一个属性，如果想一次性创建或修改多个属性，可以使用Object.defineProperties()，它有2个参数，1.要修改的对象，2.包含属性名及property descriptor对象的对象

var p = Object.defineProperties({}, {

　　x: { value: 1, writable: true, enumerable:true, configurable:true },

　　y: { value: 1, writable: true, enumerable:true, configurable:true },

　　r: {

　　get: function() { return Math.sqrt(this.x*this.x + this.y*this.y) },

　　　　　enumerable:true,

　　　　　configurable:true

}

});

对象属性：

原型属性(prototype)

对象的原型属性是用来继承属性的。

通过直接量创建的对象，原型为：Object.prototype

通过new创建的对象，原型为：构造函数的prototype

通过Object.create()创建的对象，原型为：使用的第一个参数

ECMAScript5中，将对象作为参数传入Object.getPrototypeOf()，可以获取对象的原型。

通过对象直接量或Object.create()创建的对象包含一个名为constructor的属性，该属性指代Object()构造函数。

想要检测一个对象是否是另一个对象的原型（或出于原型链中），可以使用isPrototypeOf()方法。

p.isPrototypeOf(o)         //若o是p的原型或存在于原型链中，则返回true

类属性(class)

对象的类属性是一个字符串，用以表示对象类型信息。ECMAScript3和5都没有提供设置这个属性的方法，而且只有一个间接的方法可以查询它——默认的toString()方法。但由于很多对象继承的toString()方法被重写了，所以最好使用call去调用。

function classof(o) {             //该函数可以返回传递给它的任意对象的类

if( o === "null" ) return "Null";

if( o === "undefined") return "Undefined";

Object.prototype.toString.call(o).slice(8,-1);

}

内置构造函数创建的对象包含”类属性”，它与构造函数名称相匹配。通过对象直接量，Object.create()和自定义构造函数创建的对象的类属性是”Object”，创建的对象也是一样，类属性也是”Object”。因此对于自定义的类来说，没办法通过类属性来区分对象的类。

classof(null) // => "Null"

classof(1) // => "Number"

classof("") // => "String"

classof(false) // => "Boolean"

classof({}) // => "Object"

classof([]) // => "Array"

classof(/./) // => "Regexp"

classof(new Date()) // => "Date"

classof(window) // => "Window" (a client-side host object)

function f() {}; // Define a custom constructor

classof(new f()); // => "Object"

可扩展属性（extensible）

该属性用以表示是否可以给一个对象添加新属性。在ECMAScript5中，所有内置对象和自定义对象都是显示可扩展。

Object.esExtensible()：用来判断对象是否是可扩展的。

Object.preventExtensions()：用来将对象转换为不可扩展。注意，一旦将对象设为不可扩展，则无法再将其转换回可扩展。该方法也只会影响到对象本身的可扩展性。如果给一个不可扩展的对象的原型添加属性，这个不可扩展对象还是会继承这些新属性。

Object.seal()：和preventExtensions()类似，它除了可以将对象设备不可扩展外，还可以将对象的所有自有属性设置为不可配置的。也就是说，不可以给这个对象添加新属性，而且它的已有属性也不能删除或者配置，但是它的已有可写属性依然可以设置。被封闭(seal)的对象，是不能解锁(unseal)的。我们可以通过Object.isSeal()方法来检测对象是否封闭。

Object.freeze()：更严格的锁定对象。和seal类似，不过它还会将自有的所有数据属性设为只读（如果对象的存储器有setter方法，该属性不会被影响，也就是说可以通过给属性赋值调用它们）。通过Object.isFrozen()检测对象是否冻结。

js常用内置方法

方法: 

decodeURI(URIstring) 为加密的URI进行解码

decodeURIComponent(URIstring) 为加密的URI组件解码

encodeURI(URIstring) 将字符串加密为URI

encodeURIComponent(URIstring) 将字符串加密为URI组件

String(object) 将一个对象值转换为一个字符串

Number(object) 将一个对象的值转换为一个数字

eval(str)接收一个字符串形式的表达式，并试图求出表达式的值。作为参数的表达式可以采用任何合法的操作符和常数。如果参数中包含JS命令，这些命令也可以被执行，就像这些命令是JS程序的一部分一样。

函数可计算某个字符串，并执行其中的的 JavaScript 代码。eval("2+3") // 返回 5

parseInt(str) 将一个字符串解析为一个整数,不是四舍五入操作,而是切尾

试图从一个字符串中提取一个整数。可附加一个n整数实现返回n进制整数。如果在字符串中存在除了数字、符号、小数点和指数符号以外的字符，就停止转换，返回已有的结果。如果第一个字符就不能转换，函数就返回NaN值。

parseFloat(str)试图从一个字符串中提取一个浮点值。如果在字符串中存在除了数字、符号、小数点和指数符号以外的字符，就停止转换并返回已有的结果。如果第一个字符就不能转换，函数就返回NaN值。

isNaN()用于判断是否为NaN值类型，如果是函数返回true。

isFinite(number)可以判断参数number是否是一个无穷。如果是则函数返回false，否则返回true。

escape(string)对一个字符串进行解码

接受一个字符串，这个字符串中可能含有空格、分号等字符。函数把字符串转换成Cookie的内部表示方式。函数返回值就是这种内部的表达方式。

函数可对字符串进行编码，这样就可以在所有的计算机上读取该字符串

unescape(string))接受一个Cookie，把其内部表达方式转化成普通的字符串形式。 JS函数一共可分为常规函数、数组函数、日期函数、数学函数、字符串函数等五类。

JavaScript 内置对象属性及方法集合

1.String 

属性:

constructor 所建立对象的函数参考

prototype 能够为对象加入的属性和方法

length 返回字符串的字符长度

方法(20):

anchor("name")用来把字符串转换为HTML锚点标记内(<A NAME=>)

big() 把字符串中的文本变成大字体(<BIG>)

blink() 把字符串中的文本变成闪烁字体(<BLINK>)

bold() 把字符串中的文本变成黑字体(<B>)

fixed() 把字符串中的文本变成固定间距字体,即电报形式(<TT>)

fontcolor(color)设置字符串中文本的颜色(<FONT COLOR=>)

Fontsize(size) 把字符串中的文本变成指定大小(<FONTSIZE=>)

italics() 把字符串中的文本变成斜字体(<I>)

Link(url)用来把字符串转换-HTML链接标记中(<A HREF=>)

small() 把字符串中的文本变成小字体(<SMALL>)

strike() 把字符串中的文本变成划掉字体(<STRIKE>)

sub() 把字符串中的文本变成下标(subscript)字体((SUB>)

sup() 把字符串中的文本变成上标(superscript)字体(<SUP>)

charAt(index) 返回指定索引处的字符

charCodeAt(index)返回一个整数,该整数表示String对象中指定位置处的字符的Unicode编码

concat(string2)连接两条或多条字符串

fromCharCode(num1, num2, …, numN)获取指定的Unicode值并返回字符串

indexOf(searchString, startIndex) 返回字符串中第一个出现指定字符串的位置

lastlndexOf(searchString, startIndex) 返回字符串中最后一个出现指定字符串的位置

match(regex) 在字符串中查找指定值

replace(regex, newString)将字符串中的某些字符替换成其它字符

search(regex) 针对某执行值对字符串进行查找

slice(startIndex, endIndex)将部分字符抽出并在新的字符串中返回剩余部分

split(delimiter)将字符串分配为数组

substr(startIndex, length) 从startIndex取,取length个字符

substring(startIndex, endIndex) 从startIndex和endIndex之间的字符,不包括endIndex

toLowerCase() 把字符串中的文本变成小写

toUpperCase() 把字符串中的文本变成大写

toSource() 显示对象的源代码

valueOf() 返回字符串对象的原始值

详解

1.1 string.charAt(pos)

返回pos位置上的字符串(js没有char类型). 若pos<0或>=string.length, 则返回空字符串.

1.2 string.charCodeAt(pos)

与charAt()的区别在于返回位置上字符串对应的字符编码值(unicode), 若pos不在合法范围内, 就返回NaN. 示例,

var s = ‘戴忠‘;var i;for (i = 0; i < s.length; i++) {

console.log(i + ‘ ‘ + s.charAt(i) + ‘ ‘ + s.charCodeAt(i));  // 0 戴 25140 1 忠 24544

}

1.3 string.concat(string…)

将字符串连接在一起并返回.

1.4 string.indexOf(searchString, pos)

从string的pos开始向后查找searchString， 若找到则返回searchString出现的初始位置，否则返回-1.

<script type="text/javascript">

var str="Hello world!"

document.write(str.indexOf("Hello") + "<br />")

document.write(str.indexOf("World") + "<br />")

document.write(str.indexOf("world"))

</script>

以上代码的输出：

0

-1

6

1.5 string.lastIndexOf(searchString, pos)

它与indexOf(searchString, pos)的区别在于查找方向相反, 从pos位置开始向前查找.

1.6 str1.localeCompare(str2)

比较两个字符串, 若str1<str2则返回负数, 若相等则返回0, 否则正数.

1.7 string.match(regexp)

若regexp带‘g‘, 则返回包含匹配内容的数组(不包含分组).没有‘g‘时, 则和regexp.exec(string)返回相同的结果. 例如,

var s1 = ‘1a2b‘;var reg1 = /\d+/;var reg2 = /[^\d]+/g;var reg3 = /(\d)+/;

console.log(reg1.exec(s1));  // [ ‘1‘, index: 0, input: ‘1a2b‘ ]

console.log(s1.match(reg1)); // [ ‘1‘, index: 0, input: ‘1a2b‘ ]

console.log(s1.match(reg3)); // [ ‘1‘, ‘1‘, index: 0, input: ‘1a2b‘ ]

console.log(s1.match(reg2)); // [ ‘a‘, ‘b‘ ]

1.8 string.replace(searchValue, replaceValue)

将string中匹配searchValue的内容, 用repalceValue取代, 最后返回生成的新字符串.一般只替换第一次配置的内容, 在包含‘g‘时, 全部替换. 参数说明:

1. searchValue是字符串, 或者是正则表达式;
2. repalceValue可包含一些特殊含义的内容, 如

3.replaceValue可以是函数, 在匹配时依次传入, 匹配的整个文本, 第一个捕获分组, 第 二个捕获分组, 依次其他分组. 这个函数的返回值作为实际的取代值.

5.9 string.search(regexp)

与indexOf()功能类似, 返回值情况相同. 这个方法忽略‘g‘.

5.10 string.slice(start, end)

复制string的内容, 范围[start, end), 不包含end位置的内容. 这个函数的参数取值情况和array.slice()参数取值情况差不多.

5.11 string.split(separator, limit)

将string根据separator的要求分隔内容, 返回形成的数组.limit参数是可选的, 表示分隔的最大个数.separator是一个字符串或者正则表达式.这个方法忽略‘g‘.

5.12 string.toLowerCase()

返回小写的新字符串.

5.13 string.toUpperCase()

返回大写的新字符串.

5.14 String.fromCharCode(code…)

参数是一些数值, 把这些数值作为字符的编码值对待, 返回一个字符串. 这个方法和charCodeAt()相反.

var str = String.fromCharCode(25140, 24544);

console.log(str); // ‘戴忠‘

2.Array 

属性:

constructor 所建立对象的函数参考

prototype 能够为对象加入的属性和方法

index For an array created by a regular expression_r match, the zero-based index of the match in the string.

input For an array created by a regular expression_r match, reflects the original string against which the regular expression_r was matched.

length 获取数组元素的个数,即最大下标加1

方法(13):

concat(array1,arrayn)将两个或两个以上的数组值连接起来,合并后返回结果 ,返回一个新数组；

join(string) 将数组中元素合并为字符串,string为分隔符.如省略参数则直接合并,不再分隔 返回array的字符串表示

pop() 移除数组中的最后一个元素并返回该元素 ,并将这个元素作为返回值。array为空时，返回undefined。

array.push(item…)

将item添加到array的尾部，返回array的新长度值。
注意，若item是数组，则把它作为array的一项直接加入，这和concat的处理方式不同.
与concat的区别：1. push()修改array，而concat()生成新数组；2. 对于item是数组的情况，处理方式不同。

reverse() 倒置array的内容，并返回array。

shift() 移除数组中的第一个元素并返回该元素 ,array为空时，返回undefined。

sort(compare Function) 在未指定排序号的情况下,按照元素的字母顺序排列,如果不是字符串类型则转换成字符串再排序,返回排序后的数组 ,将数组根据比较函数定义的规则重新排序后，返回array. 默认是将array的内容按照字符串的形式比较, 所以通常需要自定义比较函数; 比较函数的一般形式是function (a, b) {…}, 若a<=b时则a在b之前, a>b时则a在b之后.

toSource() 显示对象的源代码

toString() 将数组所有元素返回一个字符串,其间用逗号分隔

unshift(value)为数组的开始部分加上一个或多个元素,并且返回该数组的新长度 ,与push()类似, 将item们插入array头部, 返回array的新长度.

valueOf() 返回数组对象的原始值

langth函数：返回数组的长度。

splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。

arrayObject.splice(index,howmany,item1,.....,itemX)

说明

splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。

如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。

3.Date 

属性(1):

constructor 所建立对象的函数参考

prototype 能够为对象加入的属性和方法

方法(43):

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() 返回日期对象的原始值

4.RegExp 

4.1 regexp.exec(String)

匹配成功, 返回数组,数组第一个項是匹配的整个字符串, 此后項是匹配分组,最后是匹配信息如配置位置,输入的字符串;若找不到匹配, 返回null.
lastIndex属性: 当regexp带有‘g‘全局标识时, regexp对象维护一个lastIndex属性,每次exec()从lastIndex开始查找;
这个值在exec每次成功执行后, 取值配置成功字符串的后一个字符开始位置.在配置失败后, lastIndex被设置为0.
使用注意的地方, 就在于若在配置成功又不再执行exec时, 需要手动将lastIndex设置为0.
常规使用模式,

var text = ‘string‘;var regexp = /regexp/g;;var array;while (array = regexp.exec(string)) {

..... //todo something

}

4.2 regexp.test(String)

regexp配置string, 则返回true, 否则返回false.
test()时, 不应使用g, 性能优于exec().

js使用正则表达式

var invoiceValue = document.getElementById("invoiceValue").value;

var invoiceMoney = document.getElementById("invoiceMoney").value;

if (isNaN(invoiceMoney)) {

alert("发票面额只能输入数字");

return false;

}

if(invoiceMoney.length>9){

alert("发票面额输入长度不能超过9位数");

return false;

}

var re = /^[0-9]*[1-9][0-9]*$/;

var flag = re.test(invoiceValue);

if (flag == false) {

alert("张数只能输入正整数");

return false;

}

5.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)    返回 x 四舍五入后的最大整数

cos(x)     返回一个数字的余弦值

exp(x)     返回 E^x 值

floor(x)    返回 x 四舍五入后的最小整数

log(x)     返回底数为E的自然对数

max(x,y)    返回 x 和 y 之间较大的数

min(x,y)    返回 x 和 y 之间较小的数

pow(x,y)    返回 y^x 的值

random()    返回位于 0 到 1 之间的随机函数

round(x)    四舍五入后取整

sin(x)     返回数字的正弦值

sqrt(x)    返回数字的平方根

tan(x)     返回一个角度的正切值

toSource() 显示对象的源代码

valueOf() 返回数学对象的原始值

6.Object

Object是在javascript中一个被我们经常使用的类型，而且JS中的所有对象都是继承自Object对象的。

首先我们都知道，对象就是一组相似数据和功能的集合，我们就是用它来模拟我们现实世界中的对象的。那在Javascript中，创建对象的方式通常有两种方式：构造函数和对象字面量。

创建对象

首先我们都知道，对象就是一组相似数据和功能的集合，我们就是用它来模拟我们现实世界中的对象的。那在Javascript中，创建对象的方式通常有两种方式：构造函数和对象字面量。

new构造函数法

var person = new Object();

person.name = "狼狼的蓝胖子";

person.age = 25;

或者

function Person(name, age) {

this.name = name;

this.age = age;

}

var person = new Person("Jack", 15);

这种方式使用new关键字，接着跟上Object构造函数，再来给对象实例动态添加上不同的属性。这种方式相对来说比较繁琐，一般推荐使用对象字面量来创建对象。

对象字面量

对象字面量很好理解，使用key/value的形式直接创建对象，简洁方便。

var person = {

name: “狼狼的蓝胖子”,

age: 25

};

这种方式直接通过花括号将对象的属性包起来，使用key/value的方式创建对象属性，每个属性之间用逗号隔开。

注意：如果是最后一个属性，后面就不要加逗号，因为在一些旧的浏览器下会报错。

对象实例的属性和方法

constructor属性

constructor属性是保存当前对象的构造函数，前面的例子中，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 = [];

console.log(arr.hasOwnProperty("length"));//true

console.log(arr.hasOwnProperty("hasOwnProperty"));//false

isPrototypeOf(Object)方法

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

function MyObject() {}

var obj = new MyObject();

console.log(Object.prototype.isPrototypeOf(obj));

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

propertyIsEnumerable(prototypeName)方法

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

var obj = {

name: "objName"

}

for (var i in obj) {

console.log(i);

}

执行这段代码输出字符串“name”，这就说明通过for…in语句可以得到obj的name这个属性，但是我们知道，obj的属性还有很多，比如constructor，比如hasOwnPrototype等等，但是它们没有被输出，说明这些属性不能被for…in给枚举出来，可以通过propertyIsEnumerable方法来得到。

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

如代码所示，三个不同的对象实例调用valueOf返回不同的数据。

7.Number 

valueOf()

返回数学对象的原始值

number.toExponential(fractionDigits)

将数字转换为指数表示形式字符串，fractionDigits指定指数的小数位的位数, 取值区间[0,20].

number.toFixed(fractionDigits)

将数字表示成10进制字符串, fractionDigits同上.

number.toPrecision(precision)

与toFixed()类同, 只是precision指定的是数字的有效位数, 取值范围[0,21].

3.4 number.toString(radix)

将number转换为需要的进制字符串形式，radix默认是10.

Boolean对象与Function略

10.常规函数

　　(1)alert函数：显示一个警告对话框，包括一个OK按钮。

　　(2)confirm函数：显示一个确认对话框，包括OK、Cancel按钮。

　　(3)escape函数：将字符转换成Unicode码。

　　(4)eval函数：计算表达式的结果。

　　(5)isNaN函数：测试是(true)否(false)不是一个数字。

　　(6)parseFloat函数：将字符串转换成符点数字形式。

　　(7)parseInt函数：将符串转换成整数数字形式(可指定几进制)。

　　(8)prompt函数：显示一个输入对话框，提示等待用户输入。

　　(9)unescape函数：解码由escape函数编码的字符。

JS中数组的操作

1、数组的创建

var arrayObj = new Array();　//创建一个数组

var arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度

var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　创建一个数组并赋值

要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。

2、数组的元素的访问

var testGetArrValue=arrayObj[1]; //获取数组的元素值

arrayObj[1]= "这是新值"; //给数组元素赋予新的值

3、数组元素的添加

arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度

arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度

arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回""。

4、数组元素的删除

arrayObj.pop(); //移除最后一个元素并返回该元素值

arrayObj.shift(); //移除最前一个元素并返回该元素值，数组中元素自动前移

arrayObj.splice(deletePos,deleteCount); //删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素

5、数组的截取和合并

arrayObj.slice(start, [end]); //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素

arrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组

6、数组的拷贝

arrayObj.slice(0); //返回数组的拷贝数组，注意是一个新的数组，不是指向

arrayObj.concat(); //返回数组的拷贝数组，注意是一个新的数组，不是指向

7、数组元素的排序

arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址

arrayObj.sort(); //对数组元素排序，返回数组地址

8、数组元素的字符串化

arrayObj.join(separator); //返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。

toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用

二、数组对象的3个属性

1、length 属性

Length属性表示数组的长度，即其中元素的个数。因为数组的索引总是由0开始，所以一个数组的上下限分别是：0和length-1。和其他大多数语言不同的是，JavaScript数组的length属性是可变的，这一点需要特别注意。当length属性被设置得更大时，整个数组的状态事实上不会发生变化，仅仅是length属性变大；当length属性被设置得比原来小时，则原先数组中索引大于或等于length的元素的值全部被丢失。下面是演示改变length属性的例子：

var arr=[12,23,5,3,25,98,76,54,56,76];

//定义了一个包含10个数字的数组

alert(arr.length); //显示数组的长度10

arr.length=12; //增大数组的长度

alert(arr.length); //显示数组的长度已经变为12

alert(arr[8]); //显示第9个元素的值，为56

arr.length=5; //将数组的长度减少到5，索引等于或超过5的元素被丢弃

alert(arr[8]); //显示第9个元素已经变为"undefined"

arr.length=10; //将数组长度恢复为10

alert(arr[8]); //虽然长度被恢复为10，但第9个元素却无法收回，显示"undefined"

由上面的代码我们可以清楚的看到length属性的性质。但length对象不仅可以显式的设置，它也有可能被隐式修改。JavaScript中可以使用一个未声明过的变量，同样，也可以使用一个未定义的数组元素（指索引超过或等于length的元素），这时，length属性的值将被设置为所使用元素索引的值加1。例如下面的代码：

var arr=[12,23,5,3,25,98,76,54,56,76];

alert(arr.length);

arr[15]=34;

alert(arr.length);

代码中同样是先定义了一个包含10个数字的数组，通过alert语句可以看出其长度为10。随后使用了索引为15的元素，将其赋值为15，即arr[15]=34，这时再用alert语句输出数组的长度，得到的是16。无论如何，对于习惯于强类型编程的开发人员来说，这是一个很令人惊讶的特性。事实上，使用new Array()形式创建的数组，其初始长度就是为0，正是对其中未定义元素的操作，才使数组的长度发生变化。

由上面的介绍可以看到，length属性是如此的神奇，利用它可以方便的增加或者减少数组的容量。因此对length属性的深入了解，有助于在开发过程中灵活运用。

2、prototype 属性

返回对象类型原型的引用。prototype 属性是 object 共有的。

objectName.prototype

objectName 参数是object对象的名称。

说明：用 prototype 属性提供对象的类的一组基本功能。 对象的新实例“继承”赋予该对象原型的操作。

对于数组对象，以以下例子说明prototype 属性的用途。

给数组对象添加返回数组中最大元素值的方法。要完成这一点，声明一个函数，将它加入 Array.prototype， 并使用它。

function array_max( )

{

var i, max = this[0];

for (i = 1; i < this.length; i++)

{

if (max < this[i])

max = this[i];

}

return max;

}

Array.prototype.max = array_max;

var x = new Array(1, 2, 3, 4, 5, 6);

var y = x.max( );

该代码执行后，y 保存数组 x 中的最大值，或说 6。

3、constructor 属性

表示创建对象的函数。

object.constructor //object是对象或函数的名称。

说明：constructor 属性是所有具有 prototype 的对象的成员。它们包括除 Global 和 Math 对象以外的所有 JScript 固有对象。constructor 属性保存了对构造特定对象实例的函数的引用。

例如：

x = new String("Hi");

if (x.constructor == String) // 进行处理（条件为真）。

或

function MyFunc {

// 函数体。

}

y = new MyFunc;

if (y.constructor == MyFunc) // 进行处理（条件为真）。

对于数组来说：

y = new Array();