内置对象与原生对象
内置（Build-in）对象与原生（Naitve）对象的区分在于：前者老是在引擎初始化阶段就被建立好的对象，是后者的一个子集；而后者包括了一些在运转历程当中动态建立的对象。
原生对象（New后的对象）
ECMA-262 把原生对象（native object）定义为“独立于宿主环境的 ECMAScript 完成供应的对象”。包括以下：
Object、Function、Array、String、Boolean、Number、Date、RegExp、Error、EvalError、RangeError、ReferenceError、SyntaxError、TypeError、URIError、ActiveXObject(服务器方面)、Enumerator(鸠合遍历类)、RegExp（正则表达式）
由此能够看出，简朴来讲，原生对象就是 ECMA-262 定义的类（援用范例）。
内置对象（不需要New）
定义：由ECMAScript完成供应的对象，独立于宿主环境，在一个剧本递次实行的最先处。
注：每一个内置对象(built-in object)都是原生对象（Native Object），一个内置的组织函数是一个内置的对象，也是一个组织函数。
举个栗子：
Native objects: Object (constructor), Date, Math, parseInt, eval。 string 要领比方 indexOf 和 replace, array 要领, ...
Host objects (假定是浏览器环境): window, document, location, history, XMLHttpRequest, setTimeout, getElementsByTagName, querySelectorAll, ...
ECMA-262][2 只定义了两个新的内置对象，即 Global 和 Math （它们也是原生对象，依据定义，每一个内置对象都是原生对象）。
以下是ECMA-262定义的内置对象（built-in）：
global、Object、Function、Array、String、Boolean、Number、Math、Date、RegExp、JSON、Error对象（Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError 和URIError）
我们也能够修正内置对象的原型
if (!Array.prototype.forEach) {
Array.prototype.forEach = function(fn){
for ( var i = 0; i < this.length; i++ ) {
fn( this[i], i, this );
}
};
}
["a", "b", "c"].forEach(function(value, index, array){
assert( value, "Is in position " + index + " out of " + (array.length - 1) );
});
以上代码将输出：
PASS Is in position 0 out of 2
PASS Is in position 1 out of 2
PASS Is in position 2 out of 2
注重：扩大原型是很风险的：
Object.prototype.keys = function(){
var keys = [];
for ( var i in this )
keys.push( i );
return keys;
};
var obj = { a: 1, b: 2, c: 3 };
assert( obj.keys().length == 3, "We should only have 3 properties." );
delete Object.prototype.keys;
输出： FAIL We should only have 3 properties.
假如不是有特殊需要而去扩大原生对象和原型（prototype）的做法是不好的
//不要如许做
Array.prototype.map = function() {
// code
}; 除非如许做是值得的，比方，向一些旧的浏览器中增加一些ECMAScript5中的要领。
在这类情况下，我们平常如许做：
<script type="text/javascript">
if (!Array.prototype.map) {
Array.prototype.map = function() {
//code
};
}
</script>
用原型扩大对象
对js原生对象的扩大不过就是往prototype里注册，比方，我们能够往String对象里扩大ltrim,rtrim等要领。js每一个对象都继续自Object，而且，对象和其他属性都经由历程prototype对象来继续。经由历程prototype对象，我们能够扩大任何对象，包括内建的对象，如String和Date：
String对象的扩大
<script type="text/javascript">
if(typeof String.prototype.ltrim=='undefined'){
String.prototype.ltrim = function(){
var s = this;
s = s.replace(/^\s*/g, '');
return s;
}
}
if(typeof String.prototype.rtrim=='undefined'){
String.prototype.rtrim = function(){
var s = this;
s = s.replace(/\s*$/g, '');
return s;
}
}
if(typeof String.prototype.trim=='undefined'){
String.prototype.trim = function(){
return this.ltrim().rtrim();
}
}
if(typeof String.prototype.htmlEncode=='undefined'){
String.prototype.htmlEncode = function(encodeNewLine){//encodeNewLine:是不是encode换行符
var s = this;
s = s.replace(/&/g, '&');
s = s.replace(/</g, '<');
s = s.replace(/>/g, '>');
s = s.replace(/'/g, '"');
if(encodeNewLine){
s = s.replace(/\r\n/g, '<br />');
s = s.replace(/\r/g, '<br />');
s = s.replace(/\n/g, '<br />');
}
return s;
}
}
</script>
Date对象的扩大
getDaysInMonth：猎取某月有若干天
Date.getDaysInMonth = function (year, month) {
var days = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
days = 31
break;
case 4:
case 6:
case 9:
case 11:
days = 30;
break;
case 2:
if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
days = 29;
else
days = 28;
break;
}
return days;
}
if (typeof Date.prototype.format == 'undefined') {
Date.prototype.format = function (mask) {
var d = this;
var zeroize = function (value, length) {
if (!length) length = 2;
value = String(value);
for (var i = 0, zeros = ''; i < (length - value.length); i++) {
zeros += '0';
}
return zeros + value;
};
return mask.replace(/"[^"]*"|'[^']*'|\b(?:d{1,4}|m{1,4}|yy(?:yy)?|([hHMstT])\1?|[lLZ])\b/g, function ($0) {
switch ($0) {
case 'd': return d.getDate();
case 'dd': return zeroize(d.getDate());
case 'ddd': return ['Sun', 'Mon', 'Tue', 'Wed', 'Thr', 'Fri', 'Sat'][d.getDay()];
case 'dddd': return ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][d.getDay()];
case 'M': return d.getMonth() + 1;
case 'MM': return zeroize(d.getMonth() + 1);
case 'MMM': return ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][d.getMonth()];
case 'MMMM': return ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][d.getMonth()];
case 'yy': return String(d.getFullYear()).substr(2);
case 'yyyy': return d.getFullYear();
case 'h': return d.getHours() % 12 || 12;
case 'hh': return zeroize(d.getHours() % 12 || 12);
case 'H': return d.getHours();
case 'HH': return zeroize(d.getHours());
case 'm': return d.getMinutes();
case 'mm': return zeroize(d.getMinutes());
case 's': return d.getSeconds();
case 'ss': return zeroize(d.getSeconds());
case 'l': return zeroize(d.getMilliseconds(), 3);
case 'L': var m = d.getMilliseconds();
if (m > 99) m = Math.round(m / 10);
return zeroize(m);
case 'tt': return d.getHours() < 12 ? 'am' : 'pm';
case 'TT': return d.getHours() < 12 ? 'AM' : 'PM';
case 'Z': return d.toUTCString().match(/[A-Z]+$/);
// Return quoted strings with the surrounding quotes removed
default: return $0.substr(1, $0.length - 2);
}
});
};
}
运用原生js完成复制对象及扩大
jQuery的extend()要领能很轻易的完成扩大对象要领，这里要完成的是：运用原生js完成复制对象，扩大对象，相似jQuery中的extend()要领
var obj1 = {
name : 'trigkit4',
age : 22
};
var obj2 = {
name : 'frank',
age : 21,
speak : function(){
alert("hi, I'm + name ");
}
};
var obj3 ={
age : 20
};
function cloneObj(oldObj) { //复制对象要领
if (typeof(oldObj) != 'object') return oldObj;
if (oldObj == null) return oldObj;
var newObj = Object();
for (var i in oldObj)
newObj[i] = cloneObj(oldObj[i]);
return newObj;
}
function extendObj() { //扩大对象
var args = arguments;//将通报过来的参数数组赋值给args变量
if (args.length < 2) return;
var temp = cloneObj(args[0]); //挪用复制对象要领
for (var n = 1; n < args.length; n++) {
for (var i in args[n]) {
temp[i] = args[n][i];
}
}
return temp;
}
var obj =extendObj(obj1,obj2,obj3);
console.log(obj);//{ name: 'frank', age: 20, speak: [Function] }
console.log(obj1);//{ name: 'trigkit4', age: 22 }
console.log(obj2);//{ name: 'frank', age: 21, speak: [Function] }
console.log(obj3);//{ age: 20 }
es5-safe 模块
es5-safe 模块里，仅扩大了能够较好完成的能够平安运用的部份要领，包括：
Function.prototype.bind
Object.create
Object.keys
Array.isArray
Array.prototype.forEach
Array.prototype.map
Array.prototype.filter
Array.prototype.every
Array.prototype.some
Array.prototype.reduce
Array.prototype.reduceRight
Array.prototype.indexOf
Array.prototype.lastIndexOf
String.prototype.trim
Date.now
对象的建立
JavaScript 支撑四种范例的对象：内部对象、天生的对象、宿主给出的对象（如 Internet 浏览器中的 window 和 document）以及 ActiveX 对象（外部组件）。
Microsoft Jscript 供应了 11 个内部（或“内置”）对象。它们是Array、Boolean、Date、Function、Global、Math、Number、Object、RegExp、Error 以及 String 对象。每一个对象有相干的要领和属性，
JavaScript中对象的建立有以下几种体式格局：
（1）运用内置对象
（2）运用JSON标记
（3）自定义对象组织
一、运用内置对象
JavaScript可用的内置对象可分为两种：
1，JavaScript言语原生对象（言语级对象），如String、Object、Function等；
2，JavaScript运转期的宿主对象（环境宿主级对象），如window、document、body等。内置对象列表
Array
Boolean
Date
Error
EvalError
Function
Infinity
JSON
Map
Math
NaN
Number
Object
ParallelArray
Promise
Proxy
RegExp
Set
String
Symbol
SyntaxError
Uint32Array
WeakSet
decodeURI
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()已烧毁
eval()
isFinite()
isNaN()
null
parseFloat
parseInt
undefined
自定义对象组织
建立高等对象组织有两种体式格局：运用“this”关键字组织、运用原型prototype组织
Date对象
get系列要领
getDate() 从 Date 对象返回一个月中的某一天 (1 ~ 31)。
getDay() 从 Date 对象返回一周中的某一天 (0 ~ 6)。
getMonth() 从 Date 对象返回月份 (0 ~ 11)。
getFullYear() 从 Date 对象以四位数字返回年份。注重不要运用getYear()。
getHours() 返回 Date 对象的小时 (0 ~ 23)。
getMinutes() 返回 Date 对象的分钟 (0 ~ 59)。
getSeconds() 返回 Date 对象的秒数 (0 ~ 59)。
getMilliseconds() 返回 Date 对象的毫秒(0 ~ 999)。
getTime() 返回 1970 年 1 月 1 日至今的毫秒数。
getTimezoneOffset() 返回当地时候与格林威治标准时候 (GMT) 的分钟差。
getUTCDate() 依据世界时从 Date 对象返回月中的一天 (1 ~ 31)。
getUTCDay() 依据世界时从 Date 对象返回周中的一天 (0 ~ 6)。
getUTCMonth() 依据世界时从 Date 对象返回月份 (0 ~ 11)。
getUTCFullYear() 依据世界时从 Date 对象返回四位数的年份。
getUTCHours() 依据世界时返回 Date 对象的小时 (0 ~ 23)。
getUTCMinutes() 依据世界时返回 Date 对象的分钟 (0 ~ 59)。
getUTCSeconds() 依据世界时返回 Date 对象的秒钟 (0 ~ 59)。
getUTCMilliseconds() 依据世界时返回 Date 对象的毫秒(0 ~ 999)。
set系列要领
setDate() 设置 Date 对象中月的某一天 (1 ~ 31)。
setMonth() 设置 Date 对象中月份 (0 ~ 11)。
setFullYear() 设置 Date 对象中的年份（四位数字）。注重不要运用setYear()要领。
setHours() 设置 Date 对象中的小时 (0 ~ 23)。
setMinutes() 设置 Date 对象中的分钟 (0 ~ 59)。
setSeconds() 设置 Date 对象中的秒钟 (0 ~ 59)。
setMilliseconds() 设置 Date 对象中的毫秒 (0 ~ 999)。
setTime() 以毫秒设置 Date 对象。
setUTCDate() 依据世界时设置 Date 对象中月份的一天 (1 ~ 31)。
setUTCMonth() 依据世界时设置 Date 对象中的月份 (0 ~ 11)。
setUTCFullYear() 依据世界时设置 Date 对象中的年份（四位数字）。
setUTCHours() 依据世界时设置 Date 对象中的小时 (0 ~ 23)。
setUTCMinutes() 依据世界时设置 Date 对象中的分钟 (0 ~ 59)。
setUTCSeconds() 依据世界时设置 Date 对象中的秒钟 (0 ~ 59)。
setUTCMilliseconds() 依据世界时设置 Date 对象中的毫秒 (0 ~ 999)。
toString系列要领
toString() 把 Date 对象转换为字符串，toString()老是返回一个用美式英语表达的字符串。
toTimeString() 把 Date 对象的时候部份转换为字符串。
toDateString() 把 Date 对象的日期部份转换为字符串。
toUTCString() 依据世界时，把 Date 对象转换为字符串。
toLocaleString() 依据当地时候花样，把 Date 对象转换为字符串。
toLocaleTimeString() 依据当地时候花样，把 Date 对象的时候部份转换为字符串。
toLocaleDateString() 依据当地时候花样，把 Date 对象的日期部份转换为字符串。
Array对象
属性
constructor
指定建立对象原型的函数。
index
假如数组是经由历程正则表达式婚配建立的，比配是字符串的下标索引为0.
input
假如数组是经由历程正则表达式婚配建立的，返回原始的字符串。
length长度
返回数组中元素个数.
prototype
许可为一切对象附加属性.
要领
这些要领能够转变数组本身:
pop
移除数组的末了一个元素，返回值是被删除的元素。
push
在数组的末端增加一个或许多个元素，返回值是新的数组的长度。
reverse
倒置数组中元素的递次，本来第一个元素如今变成末了一个，一样本来的末了一个元素变成了如今的第一个，也就是数组的索引发生了变化。
shift
删除数组的第一个元素，返回值是删除的元素。
sort
对数组中的元素举行排序。
splice
增加或删除数组中的一个或多个元素。
unshift
增加一个或许多个元素在数组的开首，返回值是新的数组的长度。Accessor 要领
这些历程不转变数组本身
concat
返回一个包括此数组和其他数组和/或值的连系的新数组
indexOf
返回第一个与给定参数相称的数组元素的索引，没有找到则返回-1。
join
将一切的数组元素衔接成一个字符串。
lastIndexOf
返回在数组中搜刮到的与给定参数相称的元素的末了（最大）索引。
slice
返回数组中的一段。
toSource
Returns an array literal representing the specified array; you can use this value to create a new array. Overrides the Object.toSource method.
toString
返回代表该数组及其元素的字符,重写Object.toString 历程.
valueOf
Returns the primitive value of the array. Overrides the Object.valueOf method.
轮回（迭代）历程
filter
对数组中的每一个元素挪用参数中指定的过滤函数，并将关于过滤函数返回值为true的那些数组元素鸠合为新的数组返回。
forEach
对数组的每一个元素顺次挪用参数中指定的函数。
every
假如数组中每一个元素都满足参数中供应的测试函数，则返回真。
map
Creates a new array with the results of calling a provided function on every element in this array.
some
假如数组中至少有一个元素满足参数函数的测试，则返回true。
总结：
转变原数组的要领：pop()、push()、reverse()、shift()、sort()、splice()、unshift()
不转变原数组的要领：concat()、join()、slice()、toString()
Boolean
属性
Boolean.length
长度属性,值为1.
Boolean.prototype
代表Boolean组织器的原型.
要领
Boolean.prototype.toSource()
Boolean.prototype.toString()
Boolean.prototype.valueOf()
String 对象
属性
String.length
String.prototype
要领：
charAt() 要领可返回指定位置的字符。stringObject.charAt(index)
charCodeAt() 要领可返回指定位置的字符的 Unicode 编码。这个返回值是 0 – 65535 之间的整数。 stringObject.charCodeAt(index)
concat() 要领用于衔接两个或多个字符串。
stringObject.concat(stringX, stringX, …, stringX)
indexOf() 要领可返回某个指定的字符串值在字符串中初次涌现的位置。
stringObject.indexOf(searchvalue, fromindex)
lastIndexOf() 要领可返回一个指定的字符串值末了涌现的位置，在一个字符串中的指定位置从后向前搜刮。
localeCompare()：用当地特定的递次来比较两个字符串stringObject.localeCompare(target)
match() 要领可在字符串内检索指定的值，或找到一个或多个正则表达式的婚配。
该要领相似 indexOf() 和 lastIndexOf()，然则它返回指定的值，而不是字符串的位置。
stringObject.match(regexp)
replace() 要领用于在字符串顶用一些字符替换另一些字符，或替换一个与正则表达式婚配的子串。stringObject.replace(regexp/substr, replacement)
search() 要领用于检索字符串中指定的子字符串，或检索与正则表达式相婚配的子字符串。
stringObject.search(regexp)
slice() 要领可提取字符串的某个部份，并以新的字符串返回被提取的部份。
stringObject.slice(start, end)
substring()不引荐运用，发起运用slice()替换。
substr()不引荐运用，发起运用slice()替换。
toLocaleLowerCase()不引荐运用，只在土耳其语等少数语种中有效，发起运用toLowerCase()替换。
toLocaleUpperCase()不引荐运用，只在土耳其语等少数语种中有效，发起运用toUpperCase()替换。
toLowerCase() 要领用于把字符串转换为小写。
toUpperCase() 要领用于把字符串转换为大写。
注重：String 对象的要领 slice()、substring() 和 substr() 都可返回字符串的指定部份。强烈发起在一切场所都运用 slice() 要领。
RegExp对象
属性
RegExp.prototype.constructor
建立该正则对象的组织函数。
RegExp.prototype.global
是不是开启全局婚配，也就是婚配目的字符串中一切能够的婚配项，而不是只举行第一次婚配。
RegExp.prototype.ignoreCase
在婚配字符串时是不是要疏忽字符的大小写。
RegExp.prototype.lastIndex
下次婚配最先的字符串索引位置。
RegExp.prototype.multiline
是不是开启多行情势婚配（影响 ^ 和 $ 的行动）
RegExp.prototype.source
正则对象的源情势文本。
要领
RegExp.prototype.exec()
在目的字符串中实行一次正则婚配操纵。
RegExp.prototype.test()
测试当前正则是不是能婚配目的字符串。
RegExp.prototype.toString()
返回一个字符串，其值为该正则对象的字面量情势。覆蓋了Object.prototype.toString() 要领。
Object对象
当以非组织函数情势被挪用时，Object 等同于 new Object()。
属性或要领
Object的每一个实例都具有配合的基础属性和要领
| 属性或许要领 | 申明 |
|---|---|
| constructor | 指向建立当前对象的组织函数 |
| hasOwnProperty(name) | 检测给定属性name在实例对象（不是原型对象）中是不是存在。name以字符串情势指定 |
| isPropertyOf(object) | 检测传入的对象object是不是该要领挪用者的原型对象。平常花样：Class.prototype.isPropertyOf(object) |
| propertyIsEnumerable(pr) | 检测属性pr可否用for-in轮回罗列。属性pro用字符串情势指定 |
| toLocaleString() | 返回对象的字符串示意。与区域和环境对应 |
| toString() | 返回对象的字符串示意 |
| valueOf() | 返回对象的字符串、数值或布尔值示意 |
静态要领
Object.create(prototype, descriptors)
以指定的原型建立对象，而且能够（可选）的设置对象的属性
Object.defineProperty(object, propertyname, descriptor)
对指定的对象的一个属性设置雄厚的值掌握
Object.defineProperties(object, descriptors)
对指定的对象的一组属性供应雄厚的值掌握
Object.getOwnPropertyDescriptor(object, propertyname)
返回属性的定义
Object.getOwnPropertyNames(object)
返回一切属性的称号，哪怕说是不能罗列的属性
Object.preventExtensions(object)
防备新的属性增加到对象
Object.isExtensible(object)
是不是可增加属性到对象
Object.seal(object)
阻挠向指定对象增加新属性或删除现有属性
Object.freeze(object)
防备现有属性和属性值的修正，并防备新特征的增加。
Object.isFrozen(object)
搜检当前对象是不是已凝结
Object.getPrototypeOf(object)
返回指定对象的原型
全局属性和要领
全局要领
全局属性
