原生对象及扩展

嵌入对象列表

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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

上述资料来源:

   // (new Date()).Format(“yyyy-M-d h:m:s.S”)      -> 2014-4-16
7:6:9.25  

大局属性和措施

$(function () {  

Date对象的增加

getDaysInMonth:获取某月有个别许天

JavaScript

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);
} }); }; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
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);
 
                    }
 
                });
 
            };
        }

});  

JavaScript 原生对象及扩张

2016/09/26 · JavaScript
· 对象

初稿出处: trigkit4   

上面在Date对象实现了Format()方法,那几个常常也用得很多。

属性

constructor 钦定创立对象原型的函数。 index
如若数组是经过正则表明式相配成立的,比配是字符串的下标索引为0. input
举个例子数组是通过正则表达式相称创造的,重回原始的字符串。 length长度
重返数组瓜月素个数. prototype 允许为具备指标附加属性.

1
2
3
4
5
6
7
8
9
10
11
12
13
constructor
    指定创建对象原型的函数。
 
index
    如果数组是通过正则表达式匹配创建的,比配是字符串的下标索引为0.
 
input
    如果数组是通过正则表达式匹配创建的,返回原始的字符串。
length长度
    返回数组中元素个数.
 
prototype
    允许为所有对象附加属性.

                this[n++] = this[i]  

总结:

改换原数组的主意:pop()、push()、reverse()、shift()、sort()、splice()、unshift()
不退换原数组的不二法门:concat()、join()、slice()、toString()

1
2
3
改变原数组的方法:pop()、push()、reverse()、shift()、sort()、splice()、unshift()
 
不改变原数组的方法:concat()、join()、slice()、toString()

   // 月(M)、日(d)、小时(h)、分(m)、秒(s)、季度(q) 能够用 1-2 个占位符,
  

toString体系措施

toString() 把 Date
对象调换为字符串,toString()总是回到三个用美式塞尔维亚语表明的字符串。
toTimeString() 把 Date 对象的大运有个别退换为字符串。 toDateString() 把
Date 对象的日子部分改换为字符串。 toUTCString() 依据世界时,把 Date
对象转变为字符串。 toLocaleString() 依据当地时间格式,把 Date
对象调换为字符串。 toLocaleTimeString() 遵照本地时间格式,把 Date
对象的岁月部分改变为字符串。 toLocaleDateString() 依照本地时间格式,把
Date 对象的日子部分改动为字符串。

1
2
3
4
5
6
7
toString() 把 Date 对象转换为字符串,toString()总是返回一个用美式英语表达的字符串。
toTimeString() 把 Date 对象的时间部分转换为字符串。
toDateString() 把 Date 对象的日期部分转换为字符串。
toUTCString() 根据世界时,把 Date 对象转换为字符串。
toLocaleString() 根据本地时间格式,把 Date 对象转换为字符串。
toLocaleTimeString() 根据本地时间格式,把 Date 对象的时间部分转换为字符串。
toLocaleDateString() 根据本地时间格式,把 Date 对象的日期部分转换为字符串。

           “s+”: this.getSeconds(), //秒   

用原型扩大对象

对js原生对象的扩充无非正是往prototype里登记,比方,我们得今后String对象里扩张ltrim,rtrim等艺术。js每一个对象都持续自Object,而且,对象和任何质量都经过prototype目的来承袭。通过prototype目的,我们能够扩张任何对象,满含内建的靶子,如StringDate

[javascript]  

放置对象与原生对象

内置(Build-in)对象与原生(Naitve)对象的区别在于:前者总是在斯特林发动机早先化阶段就被创建好的指标,是后世的二个子集;而后面一个包蕴了一部分在运营进程中动态成立的靶子。

图片 1

        s3 = RegExp.$3;  

方法

JavaScript

RegExp.prototype.exec() 在目的字符串中实行一回正则相称操作。
RegExp.prototype.test() 测量检验当前正则是不是能合营目的字符串。
RegExp.prototype.toString()
重返三个字符串,其值为该正则对象的字面量方式。覆盖了Object.prototype.toString()
方法。

1
2
3
4
5
6
7
RegExp.prototype.exec()
    在目标字符串中执行一次正则匹配操作。
RegExp.prototype.test()
    测试当前正则是否能匹配目标字符串。
RegExp.prototype.toString()
    返回一个字符串,其值为该正则对象的字面量形式。覆盖了Object.prototype.toString() 方法。

    }  

一、使用内置对象

JavaScript可用的松手对象可分为二种:
1,JavaScript语言原生对象(语言级对象),如String、Object、Function等;
2,JavaScript运转期的宿主对象(意况宿主级对象),如window、document、body等。

1
2
3
4
JavaScript可用的内置对象可分为两种:
 
1,JavaScript语言原生对象(语言级对象),如String、Object、Function等;
2,JavaScript运行期的宿主对象(环境宿主级对象),如window、document、body等。

       if (/(y+)/.test(fmt)) fmt = fmt.replace(RegExp.$1,
(this.getFullYear() + “”).substr(4 – RegExp.$1.length));  

大局方法

图片 2

$(function () { var arr = [1, 2, 3];  

自定义对象协会

创制高档对象协会有二种方法:使用“this”关键字构造、使用原型prototype构造

       var r = /^(d{4})-(d{1,2})-(d{1,2})$/;  

RegExp对象

           s = s + arr[i]+’,’;  

方法

那个方法可以变动数组本身:

pop 移除数组的末尾三个要素,重回值是被去除的要素。 push
在数组的尾声加多二个可能多个因素,再次回到值是新的数组的尺寸。 reverse
颠倒数组桐月素的各类,原先第八个因素未来改成最终二个,相同原先的末梢贰个成分变为了当今的首先个,相当于数组的目录发生了变通。
shift 删除数组的首先个因素,再次来到值是剔除的要素。 sort
对数组中的成分进行排序。 splice 增多或删除数组中的几个或三个要素。
unshift 加多两个要么多个成分在数组的启幕,重回值是新的数组的尺寸。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
pop
    移除数组的最后一个元素,返回值是被删除的元素。
 
push
    在数组的末尾添加一个或者多个元素,返回值是新的数组的长度。
 
reverse
    颠倒数组中元素的顺序,原先第一个元素现在变成最后一个,同样原先的最后一个元素变成了现在的第一个,也就是数组的索引发生了变化。
 
shift
    删除数组的第一个元素,返回值是删除的元素。
 
sort
    对数组中的元素进行排序。
 
splice
    添加或删除数组中的一个或多个元素。
 
unshift
    添加一个或者多个元素在数组的开头,返回值是新的数组的长度。

Array.prototype.remove = function (dx) {  

方法:

JavaScript

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()不推荐使用,只在土耳其共和国(Türkiye Cumhuriyeti)语等个别语种中有用,提出接纳toLowerCase()代替。
toLocaleUpperCase()不推荐使用,只在土耳其共和国(The Republic of Turkey)语等个别语种中有用,指出选用toUpperCase()替代。
toLowerCase() 方法用于把字符串调换为小写。 toUpperCase()
方法用于把字符串调换为大写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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()方法。

 

方法

JavaScript

Boolean.prototype.toSource() Boolean.prototype.toString()
Boolean.prototype.valueOf()

1
2
3
Boolean.prototype.toSource()
Boolean.prototype.toString()
Boolean.prototype.valueOf()

        for (var i = 0, n = 0; i < this.length; i++) {  

属性

JavaScript

Boolean.length 长度属性,值为1. Boolean.prototype
代表Boolean构造器的原型.

1
2
3
4
Boolean.length
    长度属性,值为1.
Boolean.prototype
    代表Boolean构造器的原型.

   });  

目的的创造

JavaScript
帮忙多样类型的靶子:内部对象、生成的目的、宿主给出的指标(如 Internet
浏览器中的 windowdocument)以及ActiveX 对象(外界组件)。

Microsoft Jscript 提供了 11
个内部(或“内置”)对象。它们是Array、Boolean、Date、Function、Global、Math、Number、Object、RegExp、Error
以及 String 对象。每贰个对象有相关的主意和性质,

JavaScript中目的的开创有以下二种艺术:

(1)使用内置对象 (2)使用JSON符号 (3)自定义对象组织

1
2
3
(1)使用内置对象
(2)使用JSON符号
(3)自定义对象构造

   // (new Date()).Format(“yyyy-MM-dd hh:mm:ss.S”) -> 2014-04-16
10:12:30.526  

Object对象

当以非构造函数格局被调用时,Object 等同于 new Object()

           “h+”: this.getHours(), //小时   

Boolean

        }  

循环(迭代)过程

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。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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。

        s1 = RegExp.$1;  

String对象的扩大

JavaScript

<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(/rn/g, ‘<br />’); s =
s.replace(/r/g, ‘<br />’); s = s.replace(/n/g, ‘<br
/>’); } return s; } } </script>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<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, ‘&amp;’);
            s = s.replace(/</g, ‘&lt;’);
            s = s.replace(/>/g, ‘&gt;’);
            s = s.replace(/’/g, ‘&quot;’);
            if(encodeNewLine){
                s = s.replace(/rn/g, ‘<br />’);
                s = s.replace(/r/g, ‘<br />’);
                s = s.replace(/n/g, ‘<br />’);
            }
            return s;
        }
    }
</script>

        r.exec(‘1988-01-10’);  

Date对象

        s2 = RegExp.$2;  

es5-safe 模块

es5-safe 模块里,仅扩大了足以较好落到实处的能够安枕而卧选取的有的方法,包罗:

JavaScript

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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

详情:

       }  

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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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.

[javascript] 

属性

JavaScript

String.length String.prototype

1
2
String.length
String.prototype

           “q+”: Math.floor((this.getMonth() + 3) / 3), //季度   

属性

RegExp.prototype.constructor 创立该正则对象的构造函数。
RegExp.prototype.global
是或不是展开全局相称,也等于协作指标字符串中存有望的相称项,并非只实行首次相配。
RegExp.prototype.ignoreCase 在相配字符串时是还是不是要不经意字符的大小写。
RegExp.prototype.lastIndex 后一次合营起来的字符串索引地方。
RegExp.prototype.multiline 是不是开启多行方式相配(影响 ^ 和 $ 的一坐一起)
RegExp.prototype.source 正则对象的源方式文本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
RegExp.prototype.constructor
创建该正则对象的构造函数。
RegExp.prototype.global
是否开启全局匹配,也就是匹配目标字符串中所有可能的匹配项,而不是只进行第一次匹配。
 
RegExp.prototype.ignoreCase
在匹配字符串时是否要忽略字符的大小写。
 
RegExp.prototype.lastIndex
下次匹配开始的字符串索引位置。
 
RegExp.prototype.multiline
是否开启多行模式匹配(影响 ^ 和 $ 的行为)
 
RegExp.prototype.source
正则对象的源模式文本。

       return fmt;  

String 对象

            if (this[i] != this[dx]) {  

停放对象(无需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, …

1
2
3
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 只定义了几个新的嵌入对象,即 GlobalMath
(它们也是原生对象,根据定义,每一个内置对象都以原生对象)。

以下是ECMA-262概念的停放对象(built-in):

global、Object、Function、Array、String、Boolean、Number、Math、Date、RegExp、JSON、Error对象(Error,
EvalError, RangeError, ReferenceError, SyntaxError, TypeError
和URIError)

1
global、Object、Function、Array、String、Boolean、Number、Math、Date、RegExp、JSON、Error对象(Error,   EvalError, RangeError, ReferenceError,   SyntaxError, TypeError 和URIError)

图片 3

咱俩也得以修改内置对象的原型

JavaScript

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) );
});

1
2
3
4
5
6
7
8
9
10
11
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

1
2
3
PASS Is in position 0 out of 2
PASS Is in position 1 out of 2
PASS Is in position 2 out of 2

专一:增添原型是很凶险的:

JavaScript

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;

1
2
3
4
5
6
7
8
9
10
11
12
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)的做法是不佳的

JavaScript

//不要那样做 Array.prototype.map = function() { // code };

1
2
3
4
//不要这样做
Array.prototype.map = function() {
    // code
};

唯有那样做是值得的,举例,向一些旧的浏览器中增多一些ECMAScript5中的方法。
在这种情景下,大家经常那样做:

XHTML

<script type=”text/javascript”> if (!Array.prototype.map) {
Array.prototype.map = function() { //code }; } </script>

1
2
3
4
5
6
7
<script type="text/javascript">
    if (!Array.prototype.map) {
        Array.prototype.map = function() {
            //code
        };
    }
</script>

           “d+”: this.getDate(), //日   

Array对象

测验该方法

原生对象(New后的靶子)

ECMA-262 把原生对象(native object)定义为“独立于宿主意况的
ECMAScript 完结提供的靶子”。包蕴如下:

Object、Function、Array、String、Boolean、Number、Date、RegExp、Error、EvalError、RangeError、ReferenceError、SyntaxError、TypeError、UKugaIError、ActiveXObject(服务器方面)、Enumerator(集合遍历类)、RegExp(正则表明式)

1
Object、Function、Array、String、Boolean、Number、Date、RegExp、Error、EvalError、RangeError、ReferenceError、SyntaxError、TypeError、URIError、ActiveXObject(服务器方面)、Enumerator(集合遍历类)、RegExp(正则表达式)

透过可以看出,简单的说,原生对象正是 ECMA-262 定义的类(援引类型)。

来源:

        if (isNaN(dx) || dx > this.length) { return false; }  

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)。
setUTC米尔iseconds() 依据世界时设置 Date 对象中的微秒 (0 ~ 999)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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)。

       arr.remove(1);  

get连串措施

getDate() 从 Date 对象回来7个月底的某一天 (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() 再次回到 一九六九 年 1 月 1 日现今的阿秒数。
getTimezoneOffset() 再次回到本地时间与Green威治规范时间 (欧霉素T) 的分钟差。
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)。
getUTC米尔iseconds() 依据世界时重返 Date 对象的纳秒(0 ~ 999)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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)。

[javascript]  

静态方法

JavaScript

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) 重临钦赐对象的原型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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)
返回指定对象的原型

代码1

发表评论

电子邮件地址不会被公开。 必填项已用*标注