forked from rust-js/rjs
-
Notifications
You must be signed in to change notification settings - Fork 1
/
ecma-262 5.1.txt
17241 lines (12134 loc) · 695 KB
/
ecma-262 5.1.txt
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
ECMAScript Language Specification - ECMA-262 Edition 5.1
[Ecma International Logo.]
Standard ECMA-262
=================
5.1 Edition / June 2011
=======================
ECMAScript® Language Specification
==================================
This is the HTML rendering of Ecma-262 Edition 5.1, The ECMAScript Language Specification.
The PDF rendering of this document is located at
http://www.ecma-international.org/ecma-262/5.1/ECMA-262.pdf.
The PDF version is the definitive specification. Any discrepancies between this HTML version and the
PDF version are unintentional.
Copyright notice
================
Copyright © 2011 Ecma International
- Ecma International
- Rue du Rhone 114
- CH-1204 Geneva
- Tel: +41 22 849 6000
- Fax: +41 22 849 6001
- Web: http://www.ecma-international.org
This document and possible translations of it may be copied and furnished to others, and derivative
works that comment on or otherwise explain it or assist in its implementation may be prepared,
copied, published, and distributed, in whole or in part, without restriction of any kind, provided
that the above copyright notice and this section are included on all such copies and derivative
works. However, this document itself may not be modified in any way, including by removing the
copyright notice or references to Ecma International, except as needed for the purpose of developing
any document or deliverable produced by Ecma International (in which case the rules applied to
copyrights must be followed) or as required to translate it into languages other than English.
The limited permissions granted above are perpetual and will not be revoked by Ecma International or
its successors or assigns.
This document and the information contained herein is provided on an “AS IS” basis and ECMA
INTERNATIONAL DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY
WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY OWNERSHIP RIGHTS OR ANY
IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE."
Software License
All Software contained in this document (“Software)” is protected by copyright and is being made
available under the “BSD License”, included below. This Software may be subject to third party
rights (rights from parties other than Ecma International), including patent rights, and no licenses
under such third party rights are granted under this license even if the third party concerned is a
member of Ecma International. SEE THE ECMA CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT
http://www.ecma-international.org/memento/codeofconduct.htm FOR INFORMATION REGARDING THE LICENSING
OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA INTERNATIONAL STANDARDS*.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions
and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
and the following disclaimer in the documentation and/or other materials provided with the
distribution.
3. Neither the name of the authors nor Ecma International may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Contents
========
1. Copyright notice
2. Introduction
3. 1 Scope
4. 2 Conformance
5. 3 Normative references
6. 4 Overview
1. 4.1 Web Scripting
2. 4.2 Language Overview
1. 4.2.1 Objects
2. 4.2.2 The Strict Variant of ECMAScript
3. 4.3 Terms and definitions
1. 4.3.1 type
2. 4.3.2 primitive value
3. 4.3.3 object
4. 4.3.4 constructor
5. 4.3.5 prototype
6. 4.3.6 native object
7. 4.3.7 built-in object
8. 4.3.8 host object
9. 4.3.9 undefined value
10. 4.3.10 Undefined type
11. 4.3.11 null value
12. 4.3.12 Null type
13. 4.3.13 Boolean value
14. 4.3.14 Boolean type
15. 4.3.15 Boolean object
16. 4.3.16 String value
17. 4.3.17 String type
18. 4.3.18 String object
19. 4.3.19 Number value
20. 4.3.20 Number type
21. 4.3.21 Number object
22. 4.3.22 Infinity
23. 4.3.23 NaN
24. 4.3.24 function
25. 4.3.25 built-in function
26. 4.3.26 property
27. 4.3.27 method
28. 4.3.28 built-in method
29. 4.3.29 attribute
30. 4.3.30 own property
31. 4.3.31 inherited property
7. 5 Notational Conventions
1. 5.1 Syntactic and Lexical Grammars
1. 5.1.1 Context-Free Grammars
2. 5.1.2 The Lexical and RegExp Grammars
3. 5.1.3 The Numeric String Grammar
4. 5.1.4 The Syntactic Grammar
5. 5.1.5 The JSON Grammar
6. 5.1.6 Grammar Notation
2. 5.2 Algorithm Conventions
8. 6 Source Text
9. 7 Lexical Conventions
1. 7.1 Unicode Format-Control Characters
2. 7.2 White Space
3. 7.3 Line Terminators
4. 7.4 Comments
5. 7.5 Tokens
6. 7.6 Identifier Names and Identifiers
1. 7.6.1 Reserved Words
7. 7.7 Punctuators
8. 7.8 Literals
1. 7.8.1 Null Literals
2. 7.8.2 Boolean Literals
3. 7.8.3 Numeric Literals
4. 7.8.4 String Literals
5. 7.8.5 Regular Expression Literals
9. 7.9 Automatic Semicolon Insertion
1. 7.9.1 Rules of Automatic Semicolon Insertion
2. 7.9.2 Examples of Automatic Semicolon Insertion
10. 8 Types
1. 8.1 The Undefined Type
2. 8.2 The Null Type
3. 8.3 The Boolean Type
4. 8.4 The String Type
5. 8.5 The Number Type
6. 8.6 The Object Type
1. 8.6.1 Property Attributes
2. 8.6.2 Object Internal Properties and Methods
7. 8.7 The Reference Specification Type
1. 8.7.1 GetValue (V)
2. 8.7.2 PutValue (V, W)
8. 8.8 The List Specification Type
9. 8.9 The Completion Specification Type
10. 8.10 The Property Descriptor and Property Identifier Specification Types
1. 8.10.1 IsAccessorDescriptor ( Desc )
2. 8.10.2 IsDataDescriptor ( Desc )
3. 8.10.3 IsGenericDescriptor ( Desc )
4. 8.10.4 FromPropertyDescriptor ( Desc )
5. 8.10.5 ToPropertyDescriptor ( Obj )
11. 8.11 The Lexical Environment and Environment Record Specification Types
12. 8.12 Algorithms for Object Internal Methods
1. 8.12.1 [[GetOwnProperty]] (P)
2. 8.12.2 [[GetProperty]] (P)
3. 8.12.3 [[Get]] (P)
4. 8.12.4 [[CanPut]] (P)
5. 8.12.5 [[Put]] ( P, V, Throw )
6. 8.12.6 [[HasProperty]] (P)
7. 8.12.7 [[Delete]] (P, Throw)
8. 8.12.8 [[DefaultValue]] (hint)
9. 8.12.9 [[DefineOwnProperty]] (P, Desc, Throw)
11. 9 Type Conversion and Testing
1. 9.1 ToPrimitive
2. 9.2 ToBoolean
3. 9.3 ToNumber
1. 9.3.1 ToNumber Applied to the String Type
4. 9.4 ToInteger
5. 9.5 ToInt32: (Signed 32 Bit Integer)
6. 9.6 ToUint32: (Unsigned 32 Bit Integer)
7. 9.7 ToUint16: (Unsigned 16 Bit Integer)
8. 9.8 ToString
1. 9.8.1 ToString Applied to the Number Type
9. 9.9 ToObject
10. 9.10 CheckObjectCoercible
11. 9.11 IsCallable
12. 9.12 The SameValue Algorithm
12. 10 Executable Code and Execution Contexts
1. 10.1 Types of Executable Code
1. 10.1.1 Strict Mode Code
2. 10.2 Lexical Environments
1. 10.2.1 Environment Records
2. 10.2.2 Lexical Environment Operations
3. 10.2.3 The Global Environment
3. 10.3 Execution Contexts
1. 10.3.1 Identifier Resolution
4. 10.4 Establishing an Execution Context
1. 10.4.1 Entering Global Code
2. 10.4.2 Entering Eval Code
3. 10.4.3 Entering Function Code
5. 10.5 Declaration Binding Instantiation
6. 10.6 Arguments Object
13. 11 Expressions
1. 11.1 Primary Expressions
1. 11.1.1 The this Keyword
2. 11.1.2 Identifier Reference
3. 11.1.3 Literal Reference
4. 11.1.4 Array Initialiser
5. 11.1.5 Object Initialiser
6. 11.1.6 The Grouping Operator
2. 11.2 Left-Hand-Side Expressions
1. 11.2.1 Property Accessors
2. 11.2.2 The new Operator
3. 11.2.3 Function Calls
4. 11.2.4 Argument Lists
5. 11.2.5 Function Expressions
3. 11.3 Postfix Expressions
1. 11.3.1 Postfix Increment Operator
2. 11.3.2 Postfix Decrement Operator
4. 11.4 Unary Operators
1. 11.4.1 The delete Operator
2. 11.4.2 The void Operator
3. 11.4.3 The typeof Operator
4. 11.4.4 Prefix Increment Operator
5. 11.4.5 Prefix Decrement Operator
6. 11.4.6 Unary + Operator
7. 11.4.7 Unary - Operator
8. 11.4.8 Bitwise NOT Operator ( ~ )
9. 11.4.9 Logical NOT Operator ( ! )
5. 11.5 Multiplicative Operators
1. 11.5.1 Applying the * Operator
2. 11.5.2 Applying the / Operator
3. 11.5.3 Applying the % Operator
6. 11.6 Additive Operators
1. 11.6.1 The Addition operator ( + )
2. 11.6.2 The Subtraction Operator ( - )
3. 11.6.3 Applying the Additive Operators to Numbers
7. 11.7 Bitwise Shift Operators
1. 11.7.1 The Left Shift Operator ( << )
2. 11.7.2 The Signed Right Shift Operator ( >> )
3. 11.7.3 The Unsigned Right Shift Operator ( >>> )
8. 11.8 Relational Operators
1. 11.8.1 The Less-than Operator ( < )
2. 11.8.2 The Greater-than Operator ( > )
3. 11.8.3 The Less-than-or-equal Operator ( <= )
4. 11.8.4 The Greater-than-or-equal Operator ( >= )
5. 11.8.5 The Abstract Relational Comparison Algorithm
6. 11.8.6 The instanceof operator
7. 11.8.7 The in operator
9. 11.9 Equality Operators
1. 11.9.1 The Equals Operator ( == )
2. 11.9.2 The Does-not-equals Operator ( != )
3. 11.9.3 The Abstract Equality Comparison Algorithm
4. 11.9.4 The Strict Equals Operator ( === )
5. 11.9.5 The Strict Does-not-equal Operator ( !== )
6. 11.9.6 The Strict Equality Comparison Algorithm
10. 11.10 Binary Bitwise Operators
11. 11.11 Binary Logical Operators
12. 11.12 Conditional Operator ( ? : )
13. 11.13 Assignment Operators
1. 11.13.1 Simple Assignment ( = )
2. 11.13.2 Compound Assignment ( op= )
14. 11.14 Comma Operator ( , )
14. 12 Statements
1. 12.1 Block
2. 12.2 Variable Statement
1. 12.2.1 Strict Mode Restrictions
3. 12.3 Empty Statement
4. 12.4 Expression Statement
5. 12.5 The if Statement
6. 12.6 Iteration Statements
1. 12.6.1 The do-while Statement
2. 12.6.2 The while Statement
3. 12.6.3 The for Statement
4. 12.6.4 The for-in Statement
7. 12.7 The continue Statement
8. 12.8 The break Statement
9. 12.9 The return Statement
10. 12.10 The with Statement
1. 12.10.1 Strict Mode Restrictions
11. 12.11 The switch Statement
12. 12.12 Labelled Statements
13. 12.13 The throw Statement
14. 12.14 The try Statement
1. 12.14.1 Strict Mode Restrictions
15. 12.15 The debugger statement
15. 13 Function Definition
1. 13.1 Strict Mode Restrictions
2. 13.2 Creating Function Objects
1. 13.2.1 [[Call]]
2. 13.2.2 [[Construct]]
3. 13.2.3 The [[ThrowTypeError]] Function Object
16. 14 Program
1. 14.1 Directive Prologues and the Use Strict Directive
17. 15 Standard Built-in ECMAScript Objects
1. 15.1 The Global Object
1. 15.1.1 Value Properties of the Global Object
2. 15.1.2 Function Properties of the Global Object
3. 15.1.3 URI Handling Function Properties
4. 15.1.4 Constructor Properties of the Global Object
5. 15.1.5 Other Properties of the Global Object
2. 15.2 Object Objects
1. 15.2.1 The Object Constructor Called as a Function
2. 15.2.2 The Object Constructor
3. 15.2.3 Properties of the Object Constructor
4. 15.2.4 Properties of the Object Prototype Object
5. 15.2.5 Properties of Object Instances
3. 15.3 Function Objects
1. 15.3.1 The Function Constructor Called as a Function
2. 15.3.2 The Function Constructor
3. 15.3.3 Properties of the Function Constructor
4. 15.3.4 Properties of the Function Prototype Object
5. 15.3.5 Properties of Function Instances
4. 15.4 Array Objects
1. 15.4.1 The Array Constructor Called as a Function
2. 15.4.2 The Array Constructor
3. 15.4.3 Properties of the Array Constructor
4. 15.4.4 Properties of the Array Prototype Object
5. 15.4.5 Properties of Array Instances
5. 15.5 String Objects
1. 15.5.1 The String Constructor Called as a Function
2. 15.5.2 The String Constructor
3. 15.5.3 Properties of the String Constructor
4. 15.5.4 Properties of the String Prototype Object
5. 15.5.5 Properties of String Instances
6. 15.6 Boolean Objects
1. 15.6.1 The Boolean Constructor Called as a Function
2. 15.6.2 The Boolean Constructor
3. 15.6.3 Properties of the Boolean Constructor
4. 15.6.4 Properties of the Boolean Prototype Object
5. 15.6.5 Properties of Boolean Instances
7. 15.7 Number Objects
1. 15.7.1 The Number Constructor Called as a Function
2. 15.7.2 The Number Constructor
3. 15.7.3 Properties of the Number Constructor
4. 15.7.4 Properties of the Number Prototype Object
5. 15.7.5 Properties of Number Instances
8. 15.8 The Math Object
1. 15.8.1 Value Properties of the Math Object
2. 15.8.2 Function Properties of the Math Object
9. 15.9 Date Objects
1. 15.9.1 Overview of Date Objects and Definitions of Abstract Operators
2. 15.9.2 The Date Constructor Called as a Function
3. 15.9.3 The Date Constructor
4. 15.9.4 Properties of the Date Constructor
5. 15.9.5 Properties of the Date Prototype Object
6. 15.9.6 Properties of Date Instances
10. 15.10 RegExp (Regular Expression) Objects
1. 15.10.1 Patterns
2. 15.10.2 Pattern Semantics
3. 15.10.3 The RegExp Constructor Called as a Function
4. 15.10.4 The RegExp Constructor
5. 15.10.5 Properties of the RegExp Constructor
6. 15.10.6 Properties of the RegExp Prototype Object
7. 15.10.7 Properties of RegExp Instances
11. 15.11 Error Objects
1. 15.11.1 The Error Constructor Called as a Function
2. 15.11.2 The Error Constructor
3. 15.11.3 Properties of the Error Constructor
4. 15.11.4 Properties of the Error Prototype Object
5. 15.11.5 Properties of Error Instances
6. 15.11.6 Native Error Types Used in This Standard
7. 15.11.7 NativeError Object Structure
12. 15.12 The JSON Object
1. 15.12.1 The JSON Grammar
2. 15.12.2 parse ( text [ , reviver ] )
3. 15.12.3 stringify ( value [ , replacer [ , space ] ] )
18. 16 Errors
19. Annex A (informative) Grammar Summary
1. A.1 Lexical Grammar
2. A.2 Number Conversions
3. A.3 Expressions
4. A.4 Statements
5. A.5 Functions and Programs
6. A.6 Universal Resource Identifier Character Classes
7. A.7 Regular Expressions
8. A.8 JSON
1. A.8.1 JSON Lexical Grammar
2. A.8.2 JSON Syntactic Grammar
20. Annex B (informative) Compatibility
1. B.1 Additional Syntax
1. B.1.1 Numeric Literals
2. B.1.2 String Literals
2. B.2 Additional Properties
1. B.2.1 escape (string)
2. B.2.2 unescape (string)
3. B.2.3 String.prototype.substr (start, length)
4. B.2.4 Date.prototype.getYear ( )
5. B.2.5 Date.prototype.setYear (year)
6. B.2.6 Date.prototype.toGMTString ( )
21. Annex C (informative) The Strict Mode of ECMAScript
22. Annex D (informative) Corrections and Clarifications in the 5th Edition with Possible 3rd
Edition Compatibility Impact
23. Annex E (informative) Additions and Changes in the 5th Edition that Introduce Incompatibilities
with the 3rd Edition
24. Annex F (informative) Technically Significant Corrections and Clarifications in the 5.1 Edition
25. Bibliography
Introduction
============
This Ecma Standard is based on several originating technologies, the most well known being
JavaScript (Netscape) and JScript (Microsoft). The language was invented by Brendan Eich at Netscape
and first appeared in that company’s Navigator 2.0 browser. It has appeared in all subsequent
browsers from Netscape and in all browsers from Microsoft starting with Internet Explorer 3.0.
The development of this Standard started in November 1996. The first edition of this Ecma Standard
was adopted by the Ecma General Assembly of June 1997.
That Ecma Standard was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and
approved as international standard ISO/IEC 16262, in April 1998. The Ecma General Assembly of June
1998 approved the second edition of ECMA-262 to keep it fully aligned with ISO/IEC 16262. Changes
between the first and the second edition are editorial in nature.
The third edition of the Standard introduced powerful regular expressions, better string handling,
new control statements, try/catch exception handling, tighter definition of errors, formatting for
numeric output and minor changes in anticipation of forthcoming internationalisation facilities and
future language growth. The third edition of the ECMAScript standard was adopted by the Ecma General
Assembly of December 1999 and published as ISO/IEC 16262:2002 in June 2002.
Since publication of the third edition, ECMAScript has achieved massive adoption in conjunction with
the World Wide Web where it has become the programming language that is supported by essentially all
web browsers. Significant work was done to develop a fourth edition of ECMAScript. Although that
work was not completed and not published as the fourth edition of ECMAScript, it informs continuing
evolution of the language. The fifth edition of ECMAScript (published as ECMA-262 5th edition)
codifies de facto interpretations of the language specification that have become common among
browser implementations and adds support for new features that have emerged since the publication of
the third edition. Such features include accessor properties, reflective creation and inspection of
objects, program control of property attributes, additional array manipulation functions, support
for the JSON object encoding format, and a strict mode that provides enhanced error checking and
program security.
This present edition 5.1 of the ECMAScript Standard is fully aligned with third edition of the
international standard ISO/IEC 16262:2011.
ECMAScript is a vibrant language and the evolution of the language is not complete. Significant
technical enhancement will continue with future editions of this specification.
This Ecma Standard has been adopted by the General Assembly of June 2011.
ECMAScript Language Specification
1 Scope
=======
This Standard defines the ECMAScript scripting language.
2 Conformance
=============
A conforming implementation of ECMAScript must provide and support all the types, values, objects,
properties, functions, and program syntax and semantics described in this specification.
A conforming implementation of this Standard shall interpret characters in conformance with the
Unicode Standard, Version 3.0 or later and ISO/IEC 10646-1 with either UCS-2 or UTF-16 as the
adopted encoding form, implementation level 3. If the adopted ISO/IEC 10646-1 subset is not
otherwise specified, it is presumed to be the BMP subset, collection 300. If the adopted encoding
form is not otherwise specified, it presumed to be the UTF-16 encoding form.
A conforming implementation of ECMAScript is permitted to provide additional types, values, objects,
properties, and functions beyond those described in this specification. In particular, a conforming
implementation of ECMAScript is permitted to provide properties not described in this specification,
and values for those properties, for objects that are described in this specification.
A conforming implementation of ECMAScript is permitted to support program and regular expression
syntax not described in this specification. In particular, a conforming implementation of ECMAScript
is permitted to support program syntax that makes use of the “future reserved words” listed in
7.6.1.2 of this specification.
3 Normative references
======================
The following referenced documents are indispensable for the application of this document. For dated
references, only the edition cited applies. For undated references, the latest edition of the
referenced document (including any amendments) applies.
ISO/IEC 9899:1996, Programming Languages – C, including amendment 1 and technical corrigenda 1 and 2
ISO/IEC 10646-1:1993, Information Technology – Universal Multiple-Octet Coded Character Set (UCS)
plus its amendments and corrigenda
4 Overview
==========
This section contains a non-normative overview of the ECMAScript language.
ECMAScript is an object-oriented programming language for performing computations and manipulating
computational objects within a host environment. ECMAScript as defined here is not intended to be
computationally self-sufficient; indeed, there are no provisions in this specification for input of
external data or output of computed results. Instead, it is expected that the computational
environment of an ECMAScript program will provide not only the objects and other facilities
described in this specification but also certain environment-specific host objects, whose
description and behaviour are beyond the scope of this specification except to indicate that they
may provide certain properties that can be accessed and certain functions that can be called from an
ECMAScript program.
A scripting language is a programming language that is used to manipulate, customise, and automate
the facilities of an existing system. In such systems, useful functionality is already available
through a user interface, and the scripting language is a mechanism for exposing that functionality
to program control. In this way, the existing system is said to provide a host environment of
objects and facilities, which completes the capabilities of the scripting language. A scripting
language is intended for use by both professional and non-professional programmers.
ECMAScript was originally designed to be a Web scripting language, providing a mechanism to enliven
Web pages in browsers and to perform server computation as part of a Web-based client-server
architecture. ECMAScript can provide core scripting capabilities for a variety of host environments,
and therefore the core scripting language is specified in this document apart from any particular
host environment.
Some of the facilities of ECMAScript are similar to those used in other programming languages; in
particular Java™, Self, and Scheme as described in:
Gosling, James, Bill Joy and Guy Steele. The Java™ Language Specification. Addison Wesley Publishing
Co., 1996.
Ungar, David, and Smith, Randall B. Self: The Power of Simplicity. OOPSLA ’87 Conference
Proceedings, pp. 227–241, Orlando, FL, October 1987.
IEEE Standard for the Scheme Programming Language. IEEE Std 1178-1990.
4.1 Web Scripting
=================
A web browser provides an ECMAScript host environment for client-side computation including, for
instance, objects that represent windows, menus, pop-ups, dialog boxes, text areas, anchors, frames,
history, cookies, and input/output. Further, the host environment provides a means to attach
scripting code to events such as change of focus, page and image loading, unloading, error and
abort, selection, form submission, and mouse actions. Scripting code appears within the HTML and the
displayed page is a combination of user interface elements and fixed and computed text and images.
The scripting code is reactive to user interaction and there is no need for a main program.
A web server provides a different host environment for server-side computation including objects
representing requests, clients, and files; and mechanisms to lock and share data. By using
browser-side and server-side scripting together, it is possible to distribute computation between
the client and server while providing a customised user interface for a Web-based application.
Each Web browser and server that supports ECMAScript supplies its own host environment, completing
the ECMAScript execution environment.
4.2 Language Overview
=====================
The following is an informal overview of ECMAScript—not all parts of the language are described.
This overview is not part of the standard proper.
ECMAScript is object-based: basic language and host facilities are provided by objects, and an
ECMAScript program is a cluster of communicating objects. An ECMAScript object is a collection of
properties each with zero or more attributes that determine how each property can be used—for
example, when the Writable attribute for a property is set to false, any attempt by executed
ECMAScript code to change the value of the property fails. Properties are containers that hold other
objects, primitive values, or functions. A primitive value is a member of one of the following
built-in types: Undefined, Null, Boolean, Number, and String; an object is a member of the remaining
built-in type Object; and a function is a callable object. A function that is associated with an
object via a property is a method.
ECMAScript defines a collection of built-in objects that round out the definition of ECMAScript
entities. These built-in objects include the global object, the Object object, the Function object,
the Array object, the String object, the Boolean object, the Number object, the Math object, the
Date object, the RegExp object, the JSON object, and the Error objects Error, EvalError, RangeError,
ReferenceError, SyntaxError, TypeError and URIError.
ECMAScript also defines a set of built-in operators. ECMAScript operators include various unary
operations, multiplicative operators, additive operators, bitwise shift operators, relational
operators, equality operators, binary bitwise operators, binary logical operators, assignment
operators, and the comma operator.
ECMAScript syntax intentionally resembles Java syntax. ECMAScript syntax is relaxed to enable it to
serve as an easy-to-use scripting language. For example, a variable is not required to have its type
declared nor are types associated with properties, and defined functions are not required to have
their declarations appear textually before calls to them.
4.2.1 Objects
=============
ECMAScript does not use classes such as those in C++, Smalltalk, or Java. Instead objects may be
created in various ways including via a literal notation or via constructors which create objects
and then execute code that initialises all or part of them by assigning initial values to their
properties. Each constructor is a function that has a property named “prototype” that is used to
implement prototype-based inheritance and shared properties. Objects are created by using
constructors in new expressions; for example, new Date(2009,11) creates a new Date object.
Invoking a constructor without using new has consequences that depend on the constructor. For
example, Date() produces a string representation of the current date and time rather than an object.
Every object created by a constructor has an implicit reference (called the object’s prototype) to
the value of its constructor’s “prototype” property. Furthermore, a prototype may have a non-null
implicit reference to its prototype, and so on; this is called the prototype chain. When a reference
is made to a property in an object, that reference is to the property of that name in the first
object in the prototype chain that contains a property of that name. In other words, first the
object mentioned directly is examined for such a property; if that object contains the named
property, that is the property to which the reference refers; if that object does not contain the
named property, the prototype for that object is examined next; and so on.
[An image of lots of boxes and arrows.]
Figure 1 — Object/Prototype Relationships
In a class-based object-oriented language, in general, state is carried by instances, methods are
carried by classes, and inheritance is only of structure and behaviour. In ECMAScript, the state and
methods are carried by objects, and structure, behaviour, and state are all inherited.
All objects that do not directly contain a particular property that their prototype contains share
that property and its value. Figure 1 illustrates this:
CF is a constructor (and also an object). Five objects have been created by using new expressions:
cf1, cf2, cf3, cf4, and cf5. Each of these objects contains properties named q1 and q2. The dashed
lines represent the implicit prototype relationship; so, for example, cf3’s prototype is CFp. The
constructor, CF, has two properties itself, named P1 and P2, which are not visible to CFp, cf1, cf2,
cf3, cf4, or cf5. The property named CFP1 in CFp is shared by cf1, cf2, cf3, cf4, and cf5 (but not
by CF), as are any properties found in CFp’s implicit prototype chain that are not named q1, q2, or
CFP1. Notice that there is no implicit prototype link between CF and CFp.
Unlike class-based object languages, properties can be added to objects dynamically by assigning
values to them. That is, constructors are not required to name or assign values to all or any of the
constructed object’s properties. In the above diagram, one could add a new shared property for cf1,
cf2, cf3, cf4, and cf5by assigning a new value to the property in CFp.
4.2.2 The Strict Variant of ECMAScript
======================================
The ECMAScript Language recognises the possibility that some users of the language may wish to
restrict their usage of some features available in the language. They might do so in the interests
of security, to avoid what they consider to be error-prone features, to get enhanced error checking,
or for other reasons of their choosing. In support of this possibility, ECMAScript defines a strict
variant of the language. The strict variant of the language excludes some specific syntactic and
semantic features of the regular ECMAScript language and modifies the detailed semantics of some
features. The strict variant also specifies additional error conditions that must be reported by
throwing error exceptions in situations that are not specified as errors by the non-strict form of
the language.
The strict variant of ECMAScript is commonly referred to as the strict mode of the language. Strict
mode selection and use of the strict mode syntax and semantics of ECMAScript is explicitly made at
the level of individual ECMAScript code units. Because strict mode is selected at the level of a
syntactic code unit, strict mode only imposes restrictions that have local effect within such a code
unit. Strict mode does not restrict or modify any aspect of the ECMAScript semantics that must
operate consistently across multiple code units. A complete ECMAScript program may be composed for
both strict mode and non-strict mode ECMAScript code units. In this case, strict mode only applies
when actually executing code that is defined within a strict mode code unit.
In order to conform to this specification, an ECMAScript implementation must implement both the full
unrestricted ECMAScript language and the strict mode variant of the ECMAScript language as defined
by this specification. In addition, an implementation must support the combination of unrestricted
and strict mode code units into a single composite program.
4.3 Terms and definitions
=========================
For the purposes of this document, the following terms and definitions apply.
4.3.1 type
==========
set of data values as defined in Clause 8 of this specification
4.3.2 primitive value
=====================
member of one of the types Undefined, Null, Boolean, Number, or String as defined in Clause 8
NOTE A primitive value is a datum that is represented directly at the lowest level of the language
implementation.
4.3.3 object
============
member of the type Object
NOTE An object is a collection of properties and has a single prototype object. The prototype may be
the null value.
4.3.4 constructor
=================
function object that creates and initialises objects
NOTE The value of a constructor’s “prototype” property is a prototype object that is used to
implement inheritance and shared properties.
4.3.5 prototype
===============
object that provides shared properties for other objects
NOTE When a constructor creates an object, that object implicitly references the constructor’s
“prototype” property for the purpose of resolving property references. The constructor’s “prototype”
property can be referenced by the program expression constructor.prototype, and properties added to
an object’s prototype are shared, through inheritance, by all objects sharing the prototype.
Alternatively, a new object may be created with an explicitly specified prototype by using the
Object.create built-in function.
4.3.6 native object
===================
object in an ECMAScript implementation whose semantics are fully defined by this specification
rather than by the host environment
NOTE Standard native objects are defined in this specification. Some native objects are built-in;
others may be constructed during the course of execution of an ECMAScript program.
4.3.7 built-in object
=====================
object supplied by an ECMAScript implementation, independent of the host environment, that is
present at the start of the execution of an ECMAScript program
NOTE Standard built-in objects are defined in this specification, and an ECMAScript implementation
may specify and define others. Every built-in object is a native object. A built-in constructor is a
built-in object that is also a constructor.
4.3.8 host object
=================
object supplied by the host environment to complete the execution environment of ECMAScript
NOTE Any object that is not native is a host object.
4.3.9 undefined value
=====================
primitive value used when a variable has not been assigned a value
4.3.10 Undefined type
=====================
type whose sole value is the undefined value
4.3.11 null value
=================
primitive value that represents the intentional absence of any object value
4.3.12 Null type
================
type whose sole value is the null value
4.3.13 Boolean value
====================
member of the Boolean type
NOTE There are only two Boolean values, true and false.
4.3.14 Boolean type
===================
type consisting of the primitive values true and false
4.3.15 Boolean object
=====================
member of the Object type that is an instance of the standard built-in Boolean constructor
NOTE A Boolean object is created by using the Boolean constructor in a new expression, supplying a
Boolean value as an argument. The resulting object has an internal property whose value is the
Boolean value. A Boolean object can be coerced to a Boolean value.
4.3.16 String value
===================
primitive value that is a finite ordered sequence of zero or more 16-bit unsigned integer
NOTE A String value is a member of the String type. Each integer value in the sequence usually
represents a single 16-bit unit of UTF-16 text. However, ECMAScript does not place any restrictions
or requirements on the values except that they must be 16-bit unsigned integers.
4.3.17 String type
==================
set of all possible String values
4.3.18 String object
====================
member of the Object type that is an instance of the standard built-in String constructor
NOTE A String object is created by using the String constructor in a new expression, supplying a
String value as an argument. The resulting object has an internal property whose value is the String
value. A String object can be coerced to a String value by calling the String constructor as a
function (15.5.1).
4.3.19 Number value
===================
primitive value corresponding to a double-precision 64-bit binary format IEEE 754 value
NOTE A Number value is a member of the Number type and is a direct representation of a number.
4.3.20 Number type
==================
set of all possible Number values including the special “Not-a-Number” (NaN) values, positive
infinity, and negative infinity
4.3.21 Number object
====================
member of the Object type that is an instance of the standard built-in Number constructor
NOTE A Number object is created by using the Number constructor in a new expression, supplying a
Number value as an argument. The resulting object has an internal property whose value is the Number
value. A Number object can be coerced to a Number value by calling the Number constructor as a
function (15.7.1).
4.3.22 Infinity
===============
number value that is the positive infinite Number value
4.3.23 NaN
==========
number value that is a IEEE 754 “Not-a-Number” value
4.3.24 function
===============
member of the Object type that is an instance of the standard built-in Function constructor and that
may be invoked as a subroutine
NOTE In addition to its named properties, a function contains executable code and state that
determine how it behaves when invoked. A function’s code may or may not be written in ECMAScript.
4.3.25 built-in function
========================
built-in object that is a function
NOTE Examples of built-in functions include parseInt and Math.exp. An implementation may provide
implementation-dependent built-in functions that are not described in this specification.
4.3.26 property
===============
association between a name and a value that is a part of an object
NOTE Depending upon the form of the property the value may be represented either directly as a data
value (a primitive value, an object, or a function object) or indirectly by a pair of accessor
functions.
4.3.27 method
=============
function that is the value of a property
NOTE When a function is called as a method of an object, the object is passed to the function as its
this value.
4.3.28 built-in method
======================
method that is a built-in function
NOTE Standard built-in methods are defined in this specification, and an ECMAScript implementation
may specify and provide other additional built-in methods.
4.3.29 attribute
================
internal value that defines some characteristic of a property
4.3.30 own property
===================
property that is directly contained by its object
4.3.31 inherited property
=========================
property of an object that is not an own property but is a property (either own or inherited) of the
object’s prototype
5 Notational Conventions
========================
5.1 Syntactic and Lexical Grammars
==================================
5.1.1 Context-Free Grammars
===========================
A context-free grammar consists of a number of productions. Each production has an abstract symbol
called a nonterminal as its left-hand side, and a sequence of zero or more nonterminal and terminal
symbols as its right-hand side. For each grammar, the terminal symbols are drawn from a specified
alphabet.
Starting from a sentence consisting of a single distinguished nonterminal, called the goal symbol, a
given context-free grammar specifies a language, namely, the (perhaps infinite) set of possible
sequences of terminal symbols that can result from repeatedly replacing any nonterminal in the
sequence with a right-hand side of a production for which the nonterminal is the left-hand side.
5.1.2 The Lexical and RegExp Grammars
=====================================
A lexical grammar for ECMAScript is given in clause 7. This grammar has as its terminal symbols
characters (Unicode code units) that conform to the rules for SourceCharacter defined in Clause 6.
It defines a set of productions, starting from the goal symbol InputElementDiv or
InputElementRegExp, that describe how sequences of such characters are translated into a sequence of
input elements.
Input elements other than white space and comments form the terminal symbols for the syntactic
grammar for ECMAScript and are called ECMAScript tokens. These tokens are the reserved words,
identifiers, literals, and punctuators of the ECMAScript language. Moreover, line terminators,
although not considered to be tokens, also become part of the stream of input elements and guide the
process of automatic semicolon insertion (7.9). Simple white space and single-line comments are
discarded and do not appear in the stream of input elements for the syntactic grammar. A
MultiLineComment (that is, a comment of the form “/*…*/” regardless of whether it spans more than
one line) is likewise simply discarded if it contains no line terminator; but if a MultiLineComment
contains one or more line terminators, then it is replaced by a single line terminator, which
becomes part of the stream of input elements for the syntactic grammar.
A RegExp grammar for ECMAScript is given in 15.10. This grammar also has as its terminal symbols the
characters as defined by SourceCharacter. It defines a set of productions, starting from the goal
symbol Pattern, that describe how sequences of characters are translated into regular expression
patterns.
Productions of the lexical and RegExp grammars are distinguished by having two colons “::” as
separating punctuation. The lexical and RegExp grammars share some productions.
5.1.3 The Numeric String Grammar
================================
Another grammar is used for translating Strings into numeric values. This grammar is similar to the
part of the lexical grammar having to do with numeric literals and has as its terminal symbols
SourceCharacter. This grammar appears in 9.3.1.
Productions of the numeric string grammar are distinguished by having three colons “:::” as
punctuation.
5.1.4 The Syntactic Grammar
===========================
The syntactic grammar for ECMAScript is given in clauses 11, 12, 13 and 14. This grammar has
ECMAScript tokens defined by the lexical grammar as its terminal symbols (5.1.2). It defines a set
of productions, starting from the goal symbol Program, that describe how sequences of tokens can