ECMAScript Language Specification

The Math object is a single object that has some named properties, some of which are functions.

The value of the internal [[Prototype]] property of the Math object is the Object prototype object (15.2.3.1). The value of the internal [[Class]] property of the Math object is "Math".

The Math object does not have a [[Construct]] property; it is not possible to use the Math object as a constructor with the new operator.

The Math object does not have a [[Call]] property; it is not possible to invoke the Math object as a function.

NOTE
In this specification, the phrase "the number value for x" has a technical meaning defined in 8.5.

The number value for e, the base of the natural logarithms, which is approximately 2.7182818284590452354.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

The number value for the natural logarithm of 10, which is approximately 2.302585092994046.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

The number value for the natural logarithm of 2, which is approximately 0.6931471805599453.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

The number value for the base-2 logarithm of e, the base of the natural logarithms; this value is approximately 1.4426950408889634.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

NOTE
The value of Math.LOG2E is approximately the reciprocal of the value of Math.LN2.

The number value for the base-10 logarithm of e, the base of the natural logarithms; this value is approximately 0.4342944819032518.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

NOTE

The value of Math.LOG10E is approximately the reciprocal of the value of Math.LN10.

The number value for , the ratio of the circumference of a circle to its diameter, which is approximately 3.1415926535897932.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

The number value for the square root of 1/2, which is approximately 0.7071067811865476.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

NOTE
The value of Math.SQRT1_ 2 is approximately the reciprocal of the value of Math.SQRT2.

The number value for the square root of 2, which is approximately 1.4142135623730951.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

Every function listed in this section applies the ToNumber operator to each of its arguments (in left-to-right order if there is more than one) and then performs a computation on the resulting number value(s).

In the function descriptions below, the symbols NaN, -0, +0, -∞ and +∞ refer to the number values described in 8.5.

NOTE
The behaviour of the functions acos, asin, atan, atan2, cos, exp, log, pow, sin, and sqrt is not precisely specified here except to require specific results for certain argument values that represent boundary cases of interest. For other argument values, these functions are intended to compute approximations to the results of familiar mathematical functions, but some latitude is allowed in the choice of approximation algorithms. The general intent is that an implementer should be able to use the same mathematical library for ECMAScript on a given hardware platform that is available to C programmers on that platform.

Although the choice of algorithms is left to the implementation, it is recommended (but not specified by this standard) that implementations use the approximation algorithms for IEEE 754 arithmetic contained in fdlibm, the freely distributable mathematical library from Sun Microsystems (fdlibm-comment@sunpro.eng.sun.com). This specification also requires specific results for certain argument values that represent boundary cases of interest

Returns the absolute value of x; the result has the same magnitude as x but has positive sign.

• If x is NaN, the result is NaN.
• If x is -0, the result is +0.
• If x is -∞, the result is +∞.

Returns an implementation-dependent approximation to the arc cosine of x. The result is expressed in radians and ranges from +0 to +π.

• If x is NaN, the result is NaN.
• If x is greater than 1, the result is NaN.
• If x is less than -1, the result is NaN.
• If x is exactly 1, the result is +0.

Returns an implementation-dependent approximation to the arc sine of x. The result is expressed in radians and ranges from π/2 to +π/2.

• If x is NaN, the result is NaN.
• If x is greater than 1, the result is NaN.
• If x is less than -1, the result is NaN.
• If x is +0, the result is +0.
• If x is -0, the result is -0.

Returns an implementation-dependent approximation to the arc tangent of x. The result is expressed in radians and ranges from π/2 to +π/2.

• If x is NaN, the result is NaN.
• If x is +0, the result is +0.
• If x is -0, the result is -0.
• If x is +∞ , the result is an implementation-dependent approximation to +π/2.
• If x is -∞, the result is an implementation-dependent approximation to -π/2.

Returns an implementation-dependent approximation to the arc tangent of the quotient y/x of the arguments y and x, where the signs of y and x are used to determine the quadrant of the result. Note that it is intentional and traditional for the two-argument arc tangent function that the argument named y be first and the argument named x be second. The result is expressed in radians and ranges from -π to +π.

• If either x or y is NaN, the result is NaN.
• If y> 0 and x is +0, the result is an implementation-dependent approximation to +π/2.
• If y> 0 and x is -0, the result is an implementation-dependent approximation to +π/2.
• If y is +0 and x> 0, the result is +0.
• If y is +0 and x is +0, the result is +0.
• If y is +0 and x is -0, the result is an implementation-dependent approximation to +π.
• If y is +0 and x< 0, the result is an implementation-dependent approximation to +π.
• If y is -0 and x > 0, the result is -0.
• If y is -0 and x is +0, the result is -0.
• If y is -0 and x is -0, the result is an implementation-dependent approximation to -π.
• If y is -0 and x< 0, the result is an implementation-dependent approximation to -π.
• If y< 0 and x is +0, the result is an implementation-dependent approximation to -π/2.
• If y< 0 and x is -0, the result is an implementation-dependent approximation to -π/2.
• If y> 0 and y is finite and x is +∞, the result is +0.
• If y> 0 and y is finite and x is -∞, the result if an implementation-dependent approximation to +π.
• If y< 0 and y is finite and x is +∞, the result is -0.
• If y< 0 and y is finite and x is -∞, the result is an implementation-dependent approximation to -π.
• If y is +∞ and x is finite, the result is an implementation-dependent approximation to +π/2.
• If y is -∞ and x is finite, the result is an implementation-dependent approximation to -π/2.
• If y is +∞ and x is +∞, the result is an implementation-dependent approximation to +π/4.
• If y is +∞ and x is -∞, the result is an implementation-dependent approximation to +3π/4.
• If y is -∞ and x is +∞, the result is an implementation-dependent approximation to -π/4.
• If y is -∞ and x is -∞, the result is an implementation-dependent approximation to -3π/4.

Returns the smallest (closest to -∞) number value that is not less than x and is equal to a mathematical integer. If x is already an integer, the result is x.

• If x is NaN, the result is NaN.
• If x is +0, the result is +0.
• If x is -0, the result is -0.
• If x is +∞, the result is +∞.
• If x is -∞, the result is -∞.
• If x is less than 0 but greater than -1, the result is -0.

The value of Math.ceil(x) is the same as the value of -Math.floor(-x).

Returns an implementation-dependent approximation to the cosine of x. The argument is expressed in radians.

• If x is NaN, the result is NaN.
• If x is +0, the result is 1.
• If x is -0, the result is 1.
• If x is +∞, the result is NaN.
• If x is -∞, the result is NaN.

Returns an implementation-dependent approximation to the exponential function of x (e raised to the power of x, where e is the base of the natural logarithms).

• If x is NaN, the result is NaN.
• If x is +0, the result is 1.
• If x is -0, the result is 1.
• If x is +∞ , the result is +∞.
• If x is -∞, the result is +0.

Returns the greatest (closest to +∞ ) number value that is not greater than x and is equal to a mathematical integer. If x is already an integer, the result is x.

• If x is NaN, the result is NaN.
• If x is +0, the result is +0.
• If x is -0, the result is -0.
• If x is +∞, the result is +∞.
• If x is -∞, the result is -∞.
• If x is greater than 0 but less than 1, the result is +0.

NOTE
The value of Math.floor(x) is the same as the value of -Math.ceil(-x).

Returns an implementation-dependent approximation to the natural logarithm of x.

• If x is NaN, the result is NaN.
• If x is less than 0, the result is NaN.
• If x is +0 or -0, the result is -∞.
• If x is 1, the result is +0.
• If x is +∞, the result is +∞.

Given zero or more arguments, calls ToNumber on each of the arguments and returns the largest of the resulting values.

• If no arguments are given, the result is -∞.
• If any value is NaN, the result is NaN.
• The comparison of values to determine the largest value is done as in 11.8.5 except that +0 is considered to be larger than -0.

The length property of the max method is 2.

Given zero or more arguments, calls ToNumber on each of the arguments and returns the smallest of the resulting values.

• If no arguments are given, the result is +∞.
• If any value is NaN, the result is NaN.
• The comparison of values to determine the smallest value is done as in 11.8.5 except that +0 is considered to be larger than -0.

The length property of the min method is 2.

Returns an implementation-dependent approximation to the result of raising x to the power y.

• If y is NaN, the result is NaN.
• If y is +0, the result is 1, even if x is NaN.
• If y is -0, the result is 1, even if x is NaN.
• If x is NaN and y is nonzero, the result is NaN.
• If abs(x)> 1 and y is +∞, the result is +∞ .
• If abs(x)> 1 and y is -∞, the result is +0.
• If abs(x)== 1 and y is +∞ , the result is NaN.
• If abs(x)== 1 and y is -∞, the result is NaN.
• If abs(x)< 1 and y is +∞ , the result is +0.
• If abs(x)< 1 and y is -∞, the result is +∞.
• If x is +∞ and y> 0, the result is +∞ .
• If x is +∞ and y< 0, the result is +0.
• If x is -∞ and y> 0 and y is an odd integer, the result is -∞.
• If x is -∞ and y> 0 and y is not an odd integer, the result is +∞ .
• If x is -∞ and y< 0 and y is an odd integer, the result is -0.
• If x is -∞ and y< 0 and y is not an odd integer, the result is +0.
• If x is +0 and y> 0, the result is +0.
• If x is +0 and y< 0, the result is +∞ .
• If x is -0 and y > 0 and y is an odd integer, the result is -0.
• If x is -0 and y> 0 and y is not an odd integer, the result is +0.
• If x is -0 and y < 0 and y is an odd integer, the result is -∞.
• If x is -0 and y< 0 and y is not an odd integer, the result is +∞ .
• If x< 0 and x is finite and y is finite and y is not an integer, the result is NaN.

Returns a number value with positive sign, greater than or equal to 0 but less than 1, chosen randomly or pseudo randomly with approximately uniform distribution over that range, using an implementation-dependent algorithm or strategy. This function takes no arguments.

Returns the number value that is closest to x and is equal to a mathematical integer. If two integer number values are equally close to x, then the result is the number value that is closer to +∞ .If x is already an integer, the result is x.

• If x is NaN, the result is NaN.
• If x is +0, the result is +0.
• If x is -0, the result is -0.
• If x is +∞ , the result is +∞ .
• If x is -∞, the result is -∞.
• If x is greater than 0 but less than 0.5, the result is +0.
• If x is less than 0 but greater than or equal to -0.5, the result is -0.

NOTE 1
Math.round(3.5) returns 4, but Math.round(-3.5) returns -3.

NOTE 2
The value of Math.round(x) is the same as the value of Math.floor(x+ 0.5), except when x is -0 or is less than 0 but greater than or equal to -0.5; for these cases Math.round(x) returns -0, but Math.floor(x+ 0.5) returns +0.

Returns an implementation-dependent approximation to the sine of x. The argument is expressed in radians.

• If x is NaN, the result is NaN.
• If x is +0, the result is +0.
• If x is -0, the result is -0.
• If x is +∞ or -∞, the result is NaN.

Returns an implementation-dependent approximation to the square root of x.

• If x is NaN, the result is NaN.
• If x less than 0, the result is NaN.
• If x is +0, the result is +0.
• If x is -0, the result is -0.
• If x is +∞ , the result is +∞ .

Returns an implementation-dependent approximation to the tangent of x. The argument is expressed in radians.

• If x is NaN, the result is NaN.
• If x is +0, the result is +0.
• If x is -0, the result is -0.
• If x is +∞ or ∞, the result is NaN.

A Date object contains a number indicating a particular instant in time to within a millisecond. The number may also be NaN, indicating that the Date object does not represent a specific instant of time.

The following sections define a number of functions for operating on time values. Note that, in every case, if any argument to such a function is NaN, the result will be NaN.

Time is measured in ECMAScript in milliseconds since 01 January, 1970 UTC. Leap seconds are ignored. It is assumed that there are exactly 86,400,000 milliseconds per day. ECMAScript number values can represent all integers from -9,007,199,254,740,991 to 9,007,199,254,740,991; this range suffices to measure times to millisecond precision for any instant that is within approximately 285,616 years, either forward or backward, from 01 January, 1970 UTC.

The actual range of times supported by ECMAScript Date objects is slightly smaller: exactly -100,000,000 days to 100,000,000 days measured relative to midnight at the beginning of 01 January, 129 UTC. This gives a range of 8,640,000,000,000,000 milliseconds to either side of 01 January, 1970 UTC.

The exact moment of midnight at the beginning of 01 January, 1970 UTC is represented by the value +0.

A given time value t belongs to day number

Day(t) = floor(t /msPerDay)

where the number of milliseconds per day is msPerDay = 86400000

The remainder is called the time within the day: TimeWithinDay(t)= t modulo msPerDay

ECMAScript uses an extrapolated Gregorian system to map a day number to a year number and to determine the month and date within that year. In this system, leap years are precisely those which are (divisible by 4) and ((not divisible by 100) or (divisible by 400)). The number of days in year number y is therefore defined by

DaysInYear(y) = 365 if (y modulo 4) != 0
              = 366 if (y modulo 4) = 0 and (y modulo 100) != 0
              = 365 if (y modulo 100) = 0 and (y modulo 400) != 0
              = 366 if (y modulo 400) = 0

All non-leap years have 365 days with the usual number of days per month and leap years have an extra day in February. The day number of the first day of year y is given by:

DayFromYear(y) = 365 * (y-1970) + floor((y-1969)/4) - floor((y-1901)/100) + floor((y-1601)/400)

The time value of the start of a year is:

TimeFromYear(y)= msPerDay * DayFromYear(y)

A time value determines a year by:

YearFromTime(t) = the largest integer y (closest to positive infinity) such that TimeFromYear(y) <= t

The leap-year function is 1 for a time within a leap year and otherwise is zero:

InLeapYear(t) = 0 if DaysInYear(YearFromTime(t)) = 365
              = 1 if DaysInYear(YearFromTime(t)) = 366

Months are identified by an integer in the range 0 to 11, inclusive. The mapping MonthFromTime(t) from a time value t to a month number is defined by:

MonthFromTime(t)  = 0 if   0               <= DayWithinYear(t)< 31 
                 =  1 if  31               <= DayWithinYear(t) < 59+InLeapYear(t) 
                 =  2 if  59+InLeapYear(t) <= DayWithinYear(t) < 90+InLeapYear(t) 
                 =  3 if  90+InLeapYear(t) <= DayWithinYear(t) < 120+InLeapYear(t) 
                 =  4 if 120+InLeapYear(t) <= DayWithinYear(t) < 151+InLeapYear(t) 
                 =  5 if 151+InLeapYear(t) <= DayWithinYear(t) < 181+InLeapYear(t) 
                 =  6 if 181+InLeapYear(t) <= DayWithinYear(t) < 212+InLeapYear(t) 
                 =  7 if 212+InLeapYear(t) <= DayWithinYear(t) < 243+InLeapYear(t) 
                 =  8 if 243+InLeapYear(t) <= DayWithinYear(t) < 273+InLeapYear(t) 
                 =  9 if 273+InLeapYear(t) <= DayWithinYear(t) < 304+InLeapYear(t) 
                 = 10 if 304+InLeapYear(t) <= DayWithinYear(t) < 334+InLeapYear(t) 
                 = 11 if 334+InLeapYear(t) <= DayWithinYear(t) < 365+InLeapYear(t)

where

DayWithinYear(t)= Day(t)-DayFromYear(YearFromTime(t))

A month value of 0 specifies January; 1 specifies February; 2 specifies March; 3 specifies April; 4 specifies May; 5 specifies June; 6 specifies July; 7 specifies August; 8 specifies September; 9 specifies October; 10 specifies November; and 11 specifies December. Note that MonthFromTime(0) = 0, corresponding to Thursday, 01 January, 1970.

A date number is identified by an integer in the range 1 through 31, inclusive. The mapping DateFromTime(t) from a time value t to a month number is defined by:

DateFromTime(t) = DayWithinYear(t)+ 1 if MonthFromTime(t)=0 
                = DayWithinYear(t)-30 if MonthFromTime(t)=1 
                = DayWithinYear(t)-58-InLeapYear(t) if MonthFromTime(t)=2
                = DayWithinYear(t)-89-InLeapYear(t) if MonthFromTime(t)=3
                = DayWithinYear(t)-119-InLeapYear(t) if MonthFromTime(t)=4 
                = DayWithinYear(t)-150-InLeapYear(t) if MonthFromTime(t)=5
                = DayWithinYear(t)-180-InLeapYear(t) if MonthFromTime(t)=6 
                = DayWithinYear(t)-211-InLeapYear(t) if MonthFromTime(t)=7 
                = DayWithinYear(t)-242-InLeapYear(t) if MonthFromTime(t)=8 
                = DayWithinYear(t)-272-InLeapYear(t) if MonthFromTime(t)=9 
                = DayWithinYear(t)-303-InLeapYear(t) if MonthFromTime(t)=10 
                = DayWithinYear(t)-333-InLeapYear(t) if MonthFromTime(t)=11

The weekday for a particular time value t is defined as

WeekDay(t)=( Day(t) + 4) modulo 7

A weekday value of 0 specifies Sunday; 1 specifies Monday; 2 specifies Tuesday; 3 specifies Wednesday; 4 specifies Thursday; 5 specifies Friday; and 6 specifies Saturday. Note that WeekDay(0) = 4, corresponding to Thursday, 01 January, 1970.

An implementation of ECMAScript is expected to determine the local time zone adjustment. The local time zone adjustment is a value LocalTZA measured in milliseconds which when added to UTC represents the local standard time. Daylight saving time is not reflected by LocalTZA. The value LocalTZA does not vary with time but depends only on the geographic location.

An implementation of ECMAScript is expected to determine the daylight saving time algorithm. The algorithm to determine the daylight saving time adjustment DaylightSavingTA(t), measured in milliseconds, must depend only on four things:

(1) the time since the beginning of the year

t - TimeFromYear(YearFromTime(t))

(2) whether t is in a leap year

InLeapYear(t)

(3) the week day of the beginning of the year

WeekDay(TimeFromYear(YearFromTime(t)) and

(4) the geographic location.

The implementation of ECMAScript should not try to determine whether the exact time was subject to daylight saving time, but just whether daylight saving time would have been in effect if the current daylight saving time algorithm had been used at the time. This avoids complications such as taking into account the years that the locale observed daylight saving time year round.

If the host environment provides functionality for determining daylight saving time, the implementation of ECMAScript is free to map the year in question to an equivalent year (same leap-year- ness and same starting week day for the year) for which the host environment provides daylight saving time information. The only restriction is that all equivalent years should produce the same result.

Conversion from UTC to local time is defined by

LocalTime(t)= t + LocalTZA + DaylightSavingTA(t)

Conversion from local time to UTC is defined by

UTC(t)= t - LocalTZA - DaylightSavingTA(t - LocalTZA)

Note that UTC(LocalTime(t)) is not necessarily always equal to t.

The following functions are useful in decomposing time values:

HourFromTime(t) = floor(t / msPerHour) modulo HoursPerDay

MinFromTime(t) = floor(t / msPerMinute) modulo MinutesPerHour

SecFromTime(t) = floor(t / msPerSecond) modulo SecondsPerMinute

msFromTime(t)= t modulo msPerSecond

where HoursPerDay = 24

MinutesPerHour = 60

SecondsPerMinute = 60

msPerSecond = 1000

msPerMinute = msPerSecond * SecondsPerMinute = 60000

msPerHour = msPerMinute * MinutesPerHour = 3600000

The operator MakeTime calculates a number of milliseconds from its four arguments, which must be ECMAScript number values. This operator functions as follows:

1. If hour is not finite or min is not finite or sec is not finite or ms is not finite, return NaN.

2. Call ToInteger(hour).

3. Call ToInteger(min).

4. Call ToInteger(sec).

5. Call ToInteger(ms).

6. Compute Result(2) * msPerHour + Result(3) * msPerMinute + Result(4) * msPerSecond + Result(5), performing the arithmetic according to IEEE 754 rules (that is, as if using the ECMAScript operators * and +).

7. Return Result(6).

The operator MakeDay calculates a number of days from its three arguments, which must be ECMAScript number values. This operator functions as follows:

1. If year is not finite or month is not finite or date is not finite, return NaN.

2. Call ToInteger(year).

3. Call ToInteger(month).

4. Call ToInteger(date).

5. Compute Result(2) + floor(Result(3)/ 12).

6. Compute Result(3) modulo 12.

7. Find a value t such that YearFromTime(t) == Result(5) and MonthFromTime(t) == Result(6) and DateFromTime(t) == 1; but if this is not possible (because some argument is out of range), return NaN.

8. Compute Day(Result(7)) + Result(4)-1.

9. Return Result(8).

The operator MakeDate calculates a number of milliseconds from its two arguments, which must be ECMAScript number values. This operator functions as follows:

1. If day is not finite or time is not finite, return NaN.

2. Compute day * msPerDay + time.

3. Return Result(2).

The operator TimeClip calculates a number of milliseconds from its argument, which must be an ECMAScript number value. This operator functions as follows:

1. If time is not finite, return NaN.

2. If abs(Result(1)) > 8.64 x 10¹⁵ , return NaN.

3. Return an implementation-dependent choice of either ToInteger( Result(2)) or ToInteger(Result(2)) + (+ 0). (Adding a positive zero converts 0 to +0.)

NOTE
The point of step 3 is that an implementation is permitted a choice of internal representations of time values, for example as a 64-bit signed integer or as a 64-bit floating-point value. Depending on the implementation, this internal representation may or may not distinguish 0 and +0.

When Date is called as a function rather than as a constructor, it returns a string representing the current time (UTC).

NOTE
The function call Date(...) is not equivalent to the object creation expression new Date(...) with the same arguments.

All of the arguments are optional; any arguments supplied are accepted but are completely ignored. A string is created and returned as if by the expression (new Date()).toString().

When Date is called as part of a new expression, it is a constructor: it initialises the newly created object.

When Date is called with two to seven arguments, it computes the date from year, month, and (optionally) date, hours, minutes, seconds and ms.

The [[Prototype]] property of the newly constructed object is set to the original Date prototype object, the one that is the initial value of Date.prototype (15.9.4.1).

The [[Class]] property of the newly constructed object is set to "Date".

The [[Value]] property of the newly constructed object is set as follows:

1. Call ToNumber(year).

2. Call ToNumber(month).

3. If date is supplied use ToNumber(date); else use 1.

4. If hours is supplied use ToNumber(hours); else use 0.

5. If minutes is supplied use ToNumber(minutes); else use 0.

6. If seconds is supplied use ToNumber(seconds); else use 0.

7. If ms is supplied use ToNumber(ms); else use 0.

8. If Result(1) is not NaN and 0 <= ToInteger(Result(1)) < 99, Result(8) is 1900+ ToInteger(Result(1)); otherwise, Result(8) is Result(1).

9. Compute MakeDay(Result(8), Result(2), Result(3)).

10. Compute MakeTime(Result(4), Result(5), Result(6), Result(7)).

11. Compute MakeDate(Result(9), Result(10)).

12. Set the [[Value]] property of the newly constructed object to TimeClip(UTC(Result(11))).

The [[Prototype]] property of the newly constructed object is set to the original Date prototype object, the one that is the initial value of Date.prototype (15.9.4.1).

The [[Class]] property of the newly constructed object is set to "Date".

The [[Value]] property of the newly constructed object is set as follows:

1. Call ToPrimitive(value).

2. If Type(Result(1)) is String, then go to step 5.

3. Let V be ToNumber(Result(1)).

4. Set the [[Value]] property of the newly constructed object to TimeClip(V) and return.

5. Parse Result(1) as a date, in exactly the same manner as for the parse method (15.9.4.2); let V be the time value for this date.

6. Go to step 4.

The [[Prototype]] property of the newly constructed object is set to the original Date prototype object, the one that is the initial value of Date.prototype (15.9.4.1).

The [[Class]] property of the newly constructed object is set to "Date".

The [[Value]] property of the newly constructed object is set to the current time (UTC).

The value of the internal [[Prototype]] property of the Date constructor is the Function prototype object (15.3.4).

Besides the internal properties and the length property (whose value is 7), the Date constructor has the following properties:

The initial value of Date.prototype is the built-in Date prototype object (15.9.5).

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

The parse function applies the ToString operator to its argument and interprets the resulting string as a date; it returns a number, the UTC time value corresponding to the date. The string may be interpreted as a local time, a UTC time, or a time in some other time zone, depending on the contents of the string.

If x is any Date object whose milliseconds amount is zero within a particular implementation of ECMAScript, then all of the following expressions should produce the same numeric value in that implementation, if all the properties referenced have their initial values:

x. valueOf()

Date.parse(x. toString())

Date.parse(x.toUTCString())

However, the expression

Date.parse(x. toLocaleString())

is not required to produce the same number value as the preceding three expressions and, in general, the value produced by Date.parse is implementation-dependent when given any string value that could not be produced in that implementation by the toString or toUTCString method.

When the UTC function is called with fewer than two arguments, the behaviour is implementation-dependent. When the UTC function is called with two to seven arguments, it computes the date from year, month and (optionally) date, hours, minutes, seconds and ms. The following steps are taken:

1. Call ToNumber(year).

2. Call ToNumber(month).

3. If date is supplied use ToNumber(date); else use 1.

4. If hours is supplied use ToNumber(hours); else use 0.

5. If minutes is supplied use ToNumber(minutes); else use 0.

6. If seconds is supplied use ToNumber(seconds); else use 0.

7. If ms is supplied use ToNumber(ms); else use 0.

8. If Result(1) is not NaN and 0 <= ToInteger(Result(1)) <= 99, Result(8) is 1900+ ToInteger(Result(1)); otherwise, Result(8) is Result(1).

9. Compute MakeDay(Result(8), Result(2), Result(3)).

10. Compute MakeTime(Result(4), Result(5), Result(6), Result(7)).

11. Return TimeClip(MakeDate(Result(9), Result(10))).

The length property of the UTC function is 7.

NOTE
The UTC function differs from the Date constructor in two ways: it returns a time value as a number, rather than creating a Date object, and it interprets the arguments in UTC rather than as local time.

The Date prototype object is itself a Date object (its [[Class]] is "Date") whose value is NaN.

The value of the internal [[Prototype]] property of the Date prototype object is the Object prototype object (15.2.3.1).

In following descriptions of functions that are properties of the Date prototype object, the phrase "this Date object" refers to the object that is the this value for the invocation of the function. None of these functions are generic; a TypeError exception is thrown if the this value is not an object for which the value of the internal [[Class]] property is "Date". Also, the phrase "this time value" refers to the number value for the time represented by this Date object, that is, the value of the internal [[Value]] property of this Date object.

The initial value of Date.prototype.constructor is the built-in Date constructor.

This function returns a string value. The contents of the string are implementation-dependent, but are intended to represent the Date in the current time zone in a convenient, human-readable form.

NOTE
It is intended that for any Date value d, the result of Date.prototype.parse(d.toString()) (section 15.9.4.2) is equal to d.

This function returns a string value. The contents of the string are implementation-dependent, but are intended to represent the "date" portion of the Date in the current time zone in a convenient, human-readable form.

This function returns a string value. The contents of the string are implementation-dependent, but are intended to represent the "time" portion of the Date in the current time zone in a convenient, human-readable form.

This function returns a string value. The contents of the string are implementation-dependent, but are intended to represent the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.

NOTE
The first parameter to this function is likely to be used in a future version of this standard; it is recommended that implementations do not use this parameter position for anything else.

This function returns a string value. The contents of the string are implementation-dependent, but are intended to represent the "date" portion of the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.

NOTE
The first parameter to this function is likely to be used in a future version of this standard; it is recommended that implementations do not use this parameter position for anything else.

This function returns a string value. The contents of the string are implementation-dependent, but are intended to represent the "time" portion of the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.

NOTE
The first parameter to this function is likely to be used in a future version of this standard; it is recommended that implementations do not use this parameter position for anything else.

The valueOf function returns a number, which is this time value.

1. If the this value is not an object whose [[Class]] property is "Date", throw a TypeError exception.

2. Return this time value.

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return YearFromTime(LocalTime(t)).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return YearFromTime(t).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return MonthFromTime(LocalTime(t)).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return MonthFromTime(t).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return DateFromTime(LocalTime(t)).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return DateFromTime(t).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return WeekDay(LocalTime(t)).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return WeekDay(t).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return HourFromTime(LocalTime(t)).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return HourFromTime(t).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return MinFromTime(LocalTime(t)).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return MinFromTime(t).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return SecFromTime(LocalTime(t)).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return SecFromTime(t).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return msFromTime(LocalTime(t)).

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return msFromTime(t).

Returns the difference between local time and UTC time in minutes.

1. Let t be this time value.

2. If t is NaN, return NaN.

3. Return (t - LocalTime(t)) / msPerMinute.

1. If the this value is not a Date object, throw a TypeError exception.

2. Call ToNumber(time).

3. Call TimeClip(Result(1)).

4. Set the [[Value]] property of the this value to Result(2).

5. Return the value of the [[Value]] property of the this value.

1. Let t be the result of LocalTime(this time value).

2. Call ToNumber(ms).

3. Compute MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), Result(2)).

4. Compute UTC(MakeDate(Day(t), Result(3))).

5. Set the [[Value]] property of the this value to TimeClip(Result(4)).

6. Return the value of the [[Value]] property of the this value.

1. Let t be this time value.

2. Call ToNumber(ms).

3. Compute MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), Result(2)).

4. Compute MakeDate(Day(t), Result(3)).

5. Set the [[Value]] property of the this value to TimeClip(Result(4)).

6. Return the value of the [[Value]] property of the this value.

If ms is not specified, this behaves as if ms were specified with the value getMilliseconds().

1. Let t be the result of LocalTime(this time value).

2. Call ToNumber(sec).

3. If ms is not specified, compute msFromTime(t); otherwise, call ToNumber(ms).

4. Compute MakeTime(HourFromTime(t), MinFromTime(t), Result(2), Result(3)).

5. Compute UTC(MakeDate(Day(t), Result(4))).

6. Set the [[Value]] property of the this value to TimeClip(Result(5)).

7. Return the value of the [[Value]] property of the this value.

The length property of the setSeconds method is 2.

If ms is not specified, this behaves as if ms were specified with the value getUTCMilliseconds().

1. Let t be this time value.

2. Call ToNumber(sec).

3. If ms is not specified, compute msFromTime(t); otherwise, call ToNumber(ms).

4. Compute MakeTime(HourFromTime(t), MinFromTime(t), Result(2), Result(3)).

5. Compute MakeDate(Day(t), Result(4)).

6. Set the [[Value]] property of the this value to TimeClip( Result(5)).

7. Return the value of the [[Value]] property of the this value.

The length property of the setUTCSeconds method is 2.

If sec is not specified, this behaves as if sec were specified with the value getSeconds().

If ms is not specified, this behaves as if ms were specified with the value getMilliseconds().

1. Let t be the result of LocalTime(this time value).

2. Call ToNumber(min).

3. If sec is not specified, compute SecFromTime(t); otherwise, call ToNumber(sec).

4. If ms is not specified, compute msFromTime(t); otherwise, call ToNumber(ms).

5. Compute MakeTime(HourFromTime(t), Result(2), Result(3), Result(4)).

6. Compute UTC(MakeDate(Day(t), Result(5))).

7. Set the [[Value]] property of the this value to TimeClip( Result(6)).

8. Return the value of the [[Value]] property of the this value.

The length property of the setMinutes method is 3.

If sec is not specified, this behaves as if sec were specified with the value getUTCSeconds().

If ms is not specified, this behaves as if ms were specified with the value getUTCMilliseconds().

1. Let t be this time value.

2. Call ToNumber(min).

3. If sec is not specified, compute SecFromTime(t); otherwise, call ToNumber(sec).

4. If ms is not specified, compute msFromTime(t); otherwise, call ToNumber(ms).

5. Compute MakeTime(HourFromTime(t), Result(2), Result(3), Result(4)).

6. Compute MakeDate(Day(t), Result(5)).

7. Set the [[Value]] property of the this value to TimeClip( Result(6)).

8. Return the value of the [[Value]] property of the this value.

The length property of the setUTCMinutes method is 3.

If min is not specified, this behaves as if min were specified with the value getMinutes().

If sec is not specified, this behaves as if sec were specified with the value getSeconds(). If ms is not specified, this behaves as if ms were specified with the value getMilliseconds().

1. Let t be the result of LocalTime(this time value).

2. Call ToNumber(hour).

3. If min is not specified, compute MinFromTime(t); otherwise, call ToNumber(min).

4. If sec is not specified, compute SecFromTime(t); otherwise, call ToNumber(sec).

5. If ms is not specified, compute msFromTime(t); otherwise, call ToNumber(ms).

6. Compute MakeTime(Result(2), Result(3), Result(4), Result(5)).

7. Compute UTC(MakeDate(Day(t), Result(6))).

8. Set the [[Value]] property of the this value to TimeClip(Result(7)).

9. Return the value of the [[Value]] property of the this value.

The length property of the setHours method is 4.

If min is not specified, this behaves as if min were specified with the value getUTCMinutes().

If sec is not specified, this behaves as if sec were specified with the value getUTCSeconds(). If ms is not specified, this behaves as if ms were specified with the value getUTCMilliseconds().

1. Let t be this time value.

2. Call ToNumber(hour).

3. If min is not specified, compute MinFromTime(t); otherwise, call ToNumber(min).

4. If sec is not specified, compute SecFromTime(t); otherwise, call ToNumber(sec).

5. If ms is not specified, compute msFromTime(t); otherwise, call ToNumber(ms).

6. Compute MakeTime(Result(2), Result(3), Result(4), Result(5)).

7. Compute MakeDate(Day(t), Result(6)).

8. Set the [[Value]] property of the this value to TimeClip(Result(7)).

9. Return the value of the [[Value]] property of the this value.

The length property of the setUTCHours method is 4.

1. Let t be the result of LocalTime(this time value).

2. Call ToNumber(date).

3. Compute MakeDay(YearFromTime(t), MonthFromTime(t), Result(2)).

4. Compute UTC(MakeDate(Result(3), TimeWithinDay(t))).

5. Set the [[Value]] property of the this value to TimeClip( Result(4)).

6. Return the value of the [[Value]] property of the this value.

1. Let t be this time value.

2. Call ToNumber(date).

3. Compute MakeDay(YearFromTime(t), MonthFromTime(t), Result(2)).

4. Compute MakeDate(Result(3), TimeWithinDay(t)).

5. Set the [[Value]] property of the this value to TimeClip( Result(4)).

6. Return the value of the [[Value]] property of the this value.

If date is not specified, this behaves as if date were specified with the value getDate().

1. Let t be the result of LocalTime(this time value).

2. Call ToNumber(month).

3. If date is not specified, compute DateFromTime(t); otherwise, call ToNumber(date).

4. Compute MakeDay(YearFromTime(t), Result(2), Result(3)).

5. Compute UTC(MakeDate(Result(4), TimeWithinDay(t))).

6. Set the [[Value]] property of the this value to TimeClip( Result(5)).

7. Return the value of the [[Value]] property of the this value.

The length property of the setMonth method is 2.

If date is not specified, this behaves as if date were specified with the value getUTCDate().

1. Let t be this time value.

2. Call ToNumber(month).

3. If date is not specified, compute DateFromTime(t); otherwise, call ToNumber(date).

4. Compute MakeDay(YearFromTime(t), Result(2), Result(3)).

5. Compute MakeDate(Result(4), TimeWithinDay(t)).

6. Set the [[Value]] property of the this value to TimeClip(Result(5)).

7. Return the value of the [[Value]] property of the this value.

The length property of the setUTCMonth method is 2.

If month is not specified, this behaves as if month were specified with the value getMonth().

If date is not specified, this behaves as if date were specified with the value getDate().

1. Let t be the result of LocalTime(this time value); but if this time value is NaN, let t be +0.

2. Call ToNumber(year).

3. If month is not specified, compute MonthFromTime(t); otherwise, call ToNumber(month).

4. If date is not specified, compute DateFromTime(t); otherwise, call ToNumber(date).

5. Compute MakeDay(Result(2), Result(3), Result(4)).

6. Compute UTC(MakeDate(Result(5), TimeWithinDay(t))).

7. Set the [[Value]] property of the this value to TimeClip(Result(6)).

8. Return the value of the [[Value]] property of the this value.

The length property of the setFullYear method is 3.

If month is not specified, this behaves as if month were specified with the value getUTCMonth().

If date is not specified, this behaves as if date were specified with the value getUTCDate().

1. Let t be this time value; but if this time value is NaN, let t be +0.

2. Call ToNumber(year).

3. If month is not specified, compute MonthFromTime( t); otherwise, call ToNumber(month).

4. If date is not specified, compute DateFromTime(t); otherwise, call ToNumber(date).

5. Compute MakeDay(Result(2), Result(3), Result(4)).

6. Compute MakeDate(Result(5), TimeWithinDay(t)).

7. Set the [[Value]] property of the this value to TimeClip( Result(6)).

8. Return the value of the [[Value]] property of the this value.

The length property of the setUTCFullYear method is 3.

This function returns a string value. The contents of the string are implementation-dependent, but are intended to represent the Date in a convenient, human-readable form in UTC.

Date instances have no special properties beyond those inherited from the Date prototype object.

A RegExp object contains a regular expression and the associated flags.

NOTE
The form and functionality of regular expressions is modelled after the regular expression facility in the Perl 5 programming language.

The RegExp constructor applies the following grammar to the input pattern string. An error occurs if the grammar cannot interpret the string as an expansion of Pattern.

Syntax

Pattern ::

Disjunction

Disjunction ::

Alternative
Alternative | Disjunction

Alternative ::

[empty]
Alternative Term

Term ::

Assertion
Atom
Atom Quantifier

Assertion ::

^
$
\b
\B

Quantifier ::

QuantifierPrefix
QuantifierPrefix ?

QuantifierPrefix ::

*
+
?
{ DecimalDigits }
{ DecimalDigits ,}
{ DecimalDigits , DecimalDigits }

Atom ::

PatternCharacter
.
\ AtomEscape
CharacterClass
( Disjunction )
(?: Disjunction )
(?= Disjunction )
(?! Disjunction )

PatternCharacter ::

SourceCharacter but not any of: ^ $ \ . * + ? ( ) [ ] { } |

AtomEscape ::

DecimalEscape
CharacterEscape
CharacterClassEscape

CharacterEscape ::

ControlEscape
c ControlLetter
HexEscapeSequence
UnicodeEscapeSequence
IdentityEscape

ControlEscape :: one of

f n r t v

ControlLetter :: one of

a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

IdentityEscape ::

SourceCharacter but not IdentifierPart

DecimalEscape ::

DecimalIntegerLiteral [lookahead ∉ DecimalDigit]

CharacterClassEscape :: one of

d D s S w W

CharacterClass ::

[ [lookahead ∉ {^}] ClassRanges ]
[^ ClassRanges ]

ClassRanges ::

[empty]
NonemptyClassRanges

NonemptyClassRanges ::

ClassAtom
ClassAtom NonemptyClassRangesNoDash
ClassAtom - ClassAtom ClassRanges

NonemptyClassRangesNoDash ::

ClassAtom
ClassAtomNoDash NonemptyClassRangesNoDash
ClassAtomNoDash - ClassAtom ClassRanges

ClassAtom ::

-ClassAtomNoDash

ClassAtomNoDash ::

SourceCharacter but not one of \ ] -
\ ClassEscape

ClassEscape ::

DecimalEscape
b
CharacterEscape
CharacterClassEscape

A regular expression pattern is converted into an internal function using the process described below. An implementation is encouraged to use more efficient algorithms than the ones listed below, as long as the results are the same.

The descriptions below use the following variables:

• Input is the string being matched by the regular expression pattern. The notation input[ n] means the nth character of input, where n can range between 0 (inclusive) and InputLength (exclusive).
• InputLength is the number of characters in the Input string.
• NCapturingParens is the total number of left capturing parentheses (i. e. the total number of times the Atom :: ( Disjunction ) production is expanded) in the pattern. A left capturing parenthesis is any ( pattern character that is matched by the ( terminal of the Atom :: ( Disjunction ) production.
• IgnoreCase is the setting of the RegExp object's ignoreCase property.
• Multiline is the setting of the RegExp object's multiline property.

Furthermore, the descriptions below use the following internal data structures:

• A CharSet is a mathematical set of characters.
• A State is an ordered pair (endIndex, captures) where endIndex is an integer and captures is an internal array of NCapturingParens values. States are used to represent partial match states in the regular expression matching algorithms. The endIndex is one plus the index of the last input character matched so far by the pattern, while captures holds the results of capturing parentheses. The nth element of captures is either a string that represents the value obtained by the nth set of capturing parentheses or undefined if the nth set of capturing parentheses hasn't been reached yet. Due to backtracking, many states may be in use at any time during the matching process.
• A MatchResult is either a State or the special token failure that indicates that the match failed. A
• Continuation function is an internal closure (i. e. an internal function with some arguments already bound to values) that takes one State argument and returns a MatchResult result. If an internal closure references variables bound in the function that creates the closure, the closure uses the values that these variables had at the time the closure was created. The continuation attempts to match the remaining portion (specified by the closure's already-bound arguments) of the pattern against the input string, starting at the intermediate state given by its State argument. If the match succeeds, the continuation returns the final State that it reached; if the match fails, the continuation returns failure.
• A Matcher function is an internal closure that takes two arguments --a State and a Continuation --and returns a MatchResult result. The matcher attempts to match a middle subpattern (specified by the closure's already-bound arguments) of the pattern against the input string, starting at the intermediate state given by its State argument. The Continuation argument should be a closure that matches the rest of the pattern. After matching the subpattern of a pattern to obtain a new State, the matcher then calls Continuation on that state to test if the rest of the pattern can match as well. If it can, the matcher returns the state returned by the continuation; if not, the matcher may try different choices at its choice points, repeatedly calling Continuation until it either succeeds or all possibilities have been exhausted.
• An AssertionTester function is an internal closure that takes a State argument and returns a boolean result. The assertion tester tests a specific condition (specified by the closure's already-bound arguments) against the current place in the input string and returns true if the condition matched or false if not.
• An EscapeValue is either a character or an integer. An EscapeValue is used to denote the interpretation of a DecimalEscape escape sequence: a character ch means that the escape sequence is interpreted as the character ch, while an integer n means that the escape sequence is interpreted as a backreference to the nth set of capturing parentheses.

The production Pattern :: Disjunction evaluates as follows:

1. Evaluate Disjunction to obtain a Matcher m.

2. Return an internal closure that takes two arguments, a string str and an integer index, and performs the following:

Informative comments: A Pattern evaluates ("compiles") to an internal function value. RegExp.prototype.exec can then apply this function to a string and an offset within the string to determine whether the pattern would match starting at exactly that offset within the string, and, if it does match, what the values of the capturing parentheses would be. The algorithms in 15.10.2 are designed so that compiling a pattern may throw a SyntaxError exception; on the other hand, once the pattern is successfully compiled, applying its result function to find a match in a string cannot throw an exception (except for any host-defined exceptions that can occur anywhere such as out-of-memory).

The production Disjunction :: Alternative evaluates by evaluating Alternative to obtain a Matcher and returning that Matcher.

The production Disjunction :: Alternative | Disjunction evaluates as follows:

1. Evaluate Alternative to obtain a Matcher m1.

2. Evaluate Disjunction to obtain a Matcher m2.

3. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

Informative comments: The | regular expression operator separates two alternatives. The pattern first tries to match the left Alternative (followed by the sequel of the regular expression); if it fails, it tries to match the right Disjunction (followed by the sequel of the regular expression). If the left Alternative, the right Disjunction, and the sequel all have choice points, all choices in the sequel are tried before moving on to the next choice in the left Alternative. If choices in the left Alternative are exhausted, the right Disjunction is tried instead of the left Alternative. Any capturing parentheses inside a portion of the pattern skipped by | produce undefined values instead of strings. Thus, for example,

/a|ab/.exec("abc")

returns the result "a" and not "ab". Moreover,

/((a)|(ab))((c)|(bc))/.exec("abc")

returns the array

["abc", "a", "a", undefined, "bc", undefined, "bc"]

and not

["abc", "ab", undefined, "ab", "c", "c", undefined]

The production Alternative :: [empty] evaluates by returning a Matcher that takes two arguments, a State x and a Continuation c, and returns the result of calling c( x).

The production Alternative :: Alternative Term evaluates as follows:

1. Evaluate Alternative to obtain a Matcher m1.

2. Evaluate Term to obtain a Matcher m2.

3. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

Informative comments: Consecutive Terms try to simultaneously match consecutive portions of the input string. If the left Alternative, the right Term, and the sequel of the regular expression all have choice points, all choices in the sequel are tried before moving on to the next choice in the right Term, and all choices in the right Term are tried before moving on to the next choice in the left Alternative.

The production Term :: Assertion evaluates by returning an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

1. Evaluate Assertion to obtain an AssertionTester t.

2. Call t(x) and let r be the resulting boolean value.

3. If r is false, return failure.

4. Call c(x) and return its result.

The production Term :: Atom evaluates by evaluating Atom to obtain a Matcher and returning that Matcher.

The production Term :: Atom Quantifier evaluates as follows:

1. Evaluate Atom to obtain a Matcher m.

2. Evaluate Quantifier to obtain the three results: an integer min, an integer (or ∞) max, and boolean greedy.

3. If max is finite and less than min, then throw a SyntaxError exception.

4. Let parenIndex be the number of left capturing parentheses in the entire regular expression that occur to the left of this production expansion's Term. This is the total number of times the Atom :: ( Disjunction ) production is expanded prior to this production's Term plus the total number of Atom :: ( Disjunction ) productions enclosing this Term.

5. Let parenCount be the number of left capturing parentheses in the expansion of this production's Atom. This is the total number of Atom :: ( Disjunction ) productions enclosed by this production's Atom.

6. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

The internal helper function RepeatMatcher takes eight parameters, a Matcher m, an integer min, an integer (or ∞) max, a boolean greedy,a Statex, a Continuation c, an integer parenIndex, andan integer parenCount, and performs the following:

1. If max is zero, then call c(x) and return its result.

2. Create an internal Continuation closure d that takes one State argument y and performs the following:

3. Let cap be a fresh copy of x's captures internal array.

4. For every integer k that satisfies parenIndex < k and k <= parenIndex+ parenCount, set cap[k] to undefined.

5. Let e be x's endIndex.

6. Let xr be the State (e, cap).

7. If min is not zero, then call m(xr, d) and return its result.

8. If greedy is true, then go to step 12.

9. Call c(x) and let z be its result.

10. If z is not failure, return z.

11. Call m(xr, d) and return its result.

12. Call m(xr, d) and let z be its result.

13. If z is not failure, return z.

14. Call c(x) and return its result.

Informative comments: An Atom followed by a Quantifier is repeated the number of times specified by the Quantifier. A quantifier can be non-greedy, in which case the Atom pattern is repeated as few times as possible while still matching the sequel, or it can be greedy, in which case the Atom pattern is repeated as many times as possible while still matching the sequel. The Atom pattern is repeated rather than the input string that it matches, so different repetitions of the Atom can match different input substrings.

If the Atom and the sequel of the regular expression all have choice points, the Atom is first matched as many (or as few, if non-greedy) times as possible. All choices in the sequel are tried before moving on to the next choice in the last repetition of Atom. All choices in the last (n th ) repetition of Atom are tried before moving on to the next choice in the next-to-last (n- 1) st repetition of Atom; at which point it may turn out that more or fewer repetitions of Atom are now possible; these are exhausted (again, starting with either as few or as many as possible) before moving on to the next choice in the (n-1) st repetition of Atom and so on.

Compare

/a[a-z]{2,4}/.exec("abcdefghi")

which returns "abcde" with

/a[a-z]{2,4}?/.exec("abcdefghi")

which returns "abc".

Consider also

/(aa|aabaac|ba|b|c)*/.exec("aabaac")

which, by the choice point ordering above, returns the array

["aaba", "ba"]

and not any of:

["aabaac", "aabaac"] ["aabaac", "c"]

The above ordering of choice points can be used to write a regular expression that calculates the greatest common divisor of two numbers (represented in unary notation). The following example calculates the gcd of 10 and 15:

"aaaaaaaaaa, aaaaaaaaaaaaaaa".replace(/^(a+)\1*,\1+$/,"$1")

which returns the gcd in unary notation "aaaaa".

Step 4 of the RepeatMatcher clears Atom's captures each time Atom is repeated. We can see its behaviour in the regular expression

/(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac")

which returns the array

["zaacbbbcac", "z", "ac", "a", undefined, "c"]

and not

["zaacbbbcac", "z", "ac", "a", "bbb", "c"]

because each iteration of the outermost * clears all captured strings contained in the quantified Atom, which in this case includes capture strings numbered 2, 3, and 4.

Step 1 of theRepeatMatcher's closure d states that, once the minimum number of repetitions has been satisfied, any more expansions of Atom that match the empty string are not considered for further repetitions. This prevents the regular expression engine from falling into an infinite loop on patterns such as:

/(a*)*/.exec("b")

or the slightly more complicated:

/(a*)b\1+/.exec("baaaac")

which returns the array

["b", ""]

The production Assertion :: ^ evaluates by returning an internal AssertionTester closure that takes a State argument x and performs the following:

1. Let e be x's endIndex.

2. If e is zero, return true.

3. If Multiline is false, return false.

4. If the character Input[ e- 1] is one of the line terminator characters <LF>, <CR>, <LS>, or <PS>, return true.

5. Return false.

The production Assertion :: $ evaluates by returning an internal AssertionTester closure that takes a State argument x and performs the following:

1. Let e be x's endIndex.

2. If e is equal to InputLength, return true.

3. If multiline is false, return false.

4. If the character Input[ e] is one of the line terminator characters <LF>, <CR>, <LS>, or <PS>, return true.

5. Return false.

The production Assertion :: \b evaluates by returning an internal AssertionTester closure that takes a State argument x and performs the following:

1. Let e be x's endIndex.

2. Call IsWordChar(e-1) and let a be the boolean result.

3. Call IsWordChar(e) and let b be the boolean result.

4. If a is true and b is false, return true.

5. If a is false and b is true, return true.

6. Return false.

The production Assertion :: \B evaluates by returning an internal AssertionTester closure that takes a State argument x and performs the following:

1. Let e be x's endIndex.

2. Call IsWordChar(e- 1) and let a be the boolean result.

3. Call IsWordChar(e) and let b be the boolean result.

4. If a is true and b is false, return false.

5. If a is false and b is true, return false.

6. Return true.

The internal helper function IsWordChar takes an integer parameter e and performs the following:

1. If e == -1 or e == InputLength, return false.

2. Let c be the character Input[ e].

3. If c is one of the sixty-three characters in the table below, return true.

a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9 _

4. Return false.

The production Quantifier :: QuantifierPrefix evaluates as follows:

1. Evaluate QuantifierPrefix to obtain the two results: an integer min and an integer (or ∞) max.

2. Return the three results min , max, and true.

The production Quantifier :: QuantifierPrefix ? evaluates as follows:

1. Evaluate QuantifierPrefix to obtain the two results: an integer min and an integer (or ∞ ) max.

2. Return the three results min , max, and false.

The production QuantifierPrefix :: * evaluates by returning the two results 0 and ∞.

The production QuantifierPrefix :: + evaluates by returning the two results 1 and ∞.

The production QuantifierPrefix :: ? evaluates by returning the two results 0 and 1.

The production QuantifierPrefix :: { DecimalDigits } evaluates as follows:

1. Let i be the MV of DecimalDigits (see 7.8.3).

2. Return the two results i and i.

The production QuantifierPrefix :: { DecimalDigits ,} evaluates as follows:

1. Let i be the MV of DecimalDigits.

2. Return the two results i and ∞.

The production QuantifierPrefix :: { DecimalDigits , DecimalDigits } evaluates as follows:

1. Let i be the MV of the first DecimalDigits.

2. Let j be the MV of the second DecimalDigits.

3. Return the two results i and j.

The production Atom :: PatternCharacter evaluates as follows:

1. Let ch be the character represented by PatternCharacter.

2. Let A be a one-element CharSet containing the character ch.

3. Call CharacterSetMatcher(A, false) and return its Matcher result.

The production Atom :: . evaluates as follows:

1. Let A be the set of all characters except the four line terminator characters <LF>, <CR>, <LS>, or <PS>.

2. Call CharacterSetMatcher(A, false) and return its Matcher result.

The production Atom :: \ AtomEscape evaluates by evaluating AtomEscape to obtain a Matcher and returning that Matcher.

The production Atom :: CharacterClass evaluates as follows:

1. Evaluate CharacterClass to obtain a CharSet A and a boolean invert.

2. Call CharacterSetMatcher(A, invert) and return its Matcher result.

The production Atom :: ( Disjunction ) evaluates as follows:

1. Evaluate Disjunction to obtain a Matcher m.

2. Let parenIndex be the number of left capturing parentheses in the entire regular expression that occur to the left of this production expansion's initial left parenthesis. This is the total number of times the Atom :: ( Disjunction ) production is expanded prior to this production's Atom plus the total number of Atom :: ( Disjunction ) productions enclosing this Atom.

3. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

2. Call m(x, d) and return its result. The production Atom :: (?: Disjunction ) evaluates by evaluating Disjunction to obtain a Matcher and returning that Matcher.

The production Atom :: (?= Disjunction ) evaluates as follows:

1. Evaluate Disjunction to obtain a Matcher m.

2. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

The production Atom :: (?! Disjunction ) evaluates as follows:

1. Evaluate Disjunction to obtain a Matcher m.

2. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

The internal helper function CharacterSetMatcher takes two arguments, a CharSet A and a boolean flag invert, and performs the following:

1. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

The internal helper function Canonicalize takes a character parameter ch and performs the following:

1. If IgnoreCase is false, return ch.

2. Let u be ch converted to upper case as if by calling String.prototype.toUpperCase on the one-character string ch.

3. If u does not consist of a single character, return ch.

4. Let cu be u's character.

5. If ch's code point value is greater than or equal to decimal 128 and cu's code point value is less than decimal 128, then return ch.

6. Return cu.

Informative comments: Parentheses of the form ( Disjunction ) serve both to group the components of the Disjunction pattern together and to save the result of the match. The result can be used either in a backreference (\ followed by a nonzero decimal number), referenced in a replace string, or returned as part of an array from the regular expression matching function. To inhibit the capturing behaviour of parentheses, use the form (?: Disjunction ) instead.

The form (?= Disjunction ) specifies a zero-width positive lookahead. In order for it to succeed, the pattern inside Disjunction must match at the current position, but the current position is not advanced before matching the sequel. If Disjunction can match at the current position in several ways, only the first one is tried. Unlike other regular expression operators, there is no backtracking into a (?= form (this unusual behaviour is inherited from Perl). This only matters when the Disjunction contains capturing parentheses and the sequel of the pattern contains backreferences to those captures.

For example,

/(?=(a+))/.exec("baaabac")

matches the empty string immediately after the first b and therefore returns the array:

["", "aaa"]

To illustrate the lack of backtracking into the lookahead, consider:

/(?=(a+))a*b\1/.exec("baaabac")

This expression returns

["aba", "a"]

and not:

["aaaba", "a"]

The form (?! Disjunction ) specifies a zero-width negative lookahead. In order for it to succeed, the pattern inside Disjunction must fail to match at the current position. The current position is not advanced before matching the sequel. Disjunction can contain capturing parentheses, but backreferences to them only make sense from within Disjunction itself. Backreferences to these capturing parentheses from elsewhere in the pattern always return undefined because the negative lookahead must fail for the pattern to succeed. For example,

/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")

looks for an a not immediately followed by some positive number n of a's, a b, another n a's (specified by the first \2) and a c. The second \2 is outside the negative lookahead, so it matches against undefined and therefore always succeeds. The whole expression returns the array:

["baaabaac", "ba", undefined, "abaac"]

In case-insignificant matches all characters are implicitly converted to upper case immediately before they are compared. However, if converting a character to upper case would expand that character into more than one character (such as converting "ß" ((u00DF) into" SS"), then the character is left as-is instead. The character is also left as-is if it is not an ASCII character but converting it to upper case would make it into an ASCII character. This prevents Unicode characters such as \u0131 and \u017F from matching regular expressions such as /[a-z]/i, which are only intended to match ASCII letters. Furthermore, if these conversions were allowed, then /[^\W]/i would match each of a, b,..., h, but not i or s.

The production AtomEscape :: DecimalEscape evaluates as follows:

1. Evaluate DecimalEscape to obtain an EscapeValue E.

2. If E is not a character then go to step 6.

3. Let ch be E's character.

4. Let A be a one-element CharSet containing the character ch.

5. Call CharacterSetMatcher(A, false) and return its Matcher result.

6. E must be an integer. Let n be that integer.

7. If n= 0 or n> NCapturingParens then throw a SyntaxError exception.

8. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and performs the following:

The production AtomEscape :: CharacterEscape evaluates as follows:

1. Evaluate CharacterEscape to obtain a character ch.

2. Let A be a one-element CharSet containing the character ch.

3. Call CharacterSetMatcher(A, false) and return its Matcher result.

The production AtomEscape :: CharacterClassEscape evaluates as follows:

1. Evaluate CharacterClassEscape to obtain a CharSet A.

2. Call CharacterSetMatcher(A, false) and return its Matcher result.

Informative comments: An escape sequence of the form \ followed by a nonzero decimal number n matches the result of the nth set of capturing parentheses (see 15.10.2.11). It is an error if the regular expression has fewer than n capturing parentheses. If the regular expression has n or more capturing parentheses but the nth one is undefined because it hasn't captured anything, then the backreference always succeeds.

The production CharacterEscape :: ControlEscape evaluates by returning the character according to the table below:

The production CharacterEscape :: c ControlLetter evaluates as follows:

1. Let ch be the character represented by ControlLetter.

2. Let i be ch's code point value.

3. Let j be the remainder of dividing i by 32.

4. Return the Unicode character numbered j.

The production CharacterEscape :: HexEscapeSequence evaluates by evaluating the CV of the HexEscapeSequence (see 7.8.4) and returning its character result.

The production CharacterEscape :: UnicodeEscapeSequence evaluates by evaluating the CV of the UnicodeEscapeSequence (see 7.8.4) and returning its character result.

The production CharacterEscape :: IdentityEscape evaluates by returning the character represented by IdentityEscape.

The production DecimalEscape :: DecimalIntegerLiteral [lookahead DecimalDigit] evaluates as follows.

1. Let i be the MV of DecimalIntegerLiteral.

2. If i is zero, return the EscapeValue consisting of a <NUL> character (Unicode value 0000).

3. Return the EscapeValue consisting of the integer i.

The definition of "the MV of DecimalIntegerLiteral" is in 7.8.3.

Informative comments: If \ is followed by a decimal number n whose first digit is not 0, then the escape sequence is considered to be a backreference. It is an error if n is greater than the total number of left capturing parentheses in the entire regular expression. \0 represents the NUL character and cannot be followed by a decimal digit.

The production CharacterClassEscape :: d evaluates by returning the ten-element set of characters containing the characters 0 through 9 inclusive.

The production CharacterClassEscape :: D evaluates by returning the set of all characters not included in the set returned by CharacterClassEscape :: d.

The production CharacterClassEscape :: s evaluates by returning the set of characters containing the characters that are on the right-hand side of the WhiteSpace (7.2) or LineTerminator (7.3) productions.

The production CharacterClassEscape :: S evaluates by returning the set of all characters not included in the set returned by CharacterClassEscape :: s.

The production CharacterClassEscape :: w evaluates by returning the set of characters containing the sixty-three characters:

a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9 _

The production CharacterClassEscape :: W evaluates by returning the set of all characters not included in the set returned by CharacterClassEscape :: w.

The production CharacterClass :: [ [lookahead {^}] ClassRanges ] evaluates by evaluating ClassRanges to obtain a CharSet and returning that CharSet and the boolean false.

The production CharacterClass :: [^ ClassRanges ] evaluates by evaluating ClassRanges to obtain a CharSet and returning that CharSet and the boolean true.

The production ClassRanges :: [empty] evaluates by returning the empty CharSet.

The production ClassRanges :: NonemptyClassRanges evaluates by evaluating NonemptyClassRanges to obtain a CharSet and returning that CharSet.

The production NonemptyClassRanges :: ClassAtom evaluates by evaluating ClassAtom to obtain a CharSet and returning that CharSet.

The production NonemptyClassRanges :: ClassAtom NonemptyClassRangesNoDash evaluates as follows:

1. Evaluate ClassAtom to obtain a CharSet A.

2. Evaluate NonemptyClassRangesNoDash to obtain a CharSet B.

3. Return the union of CharSets A and B.

The production NonemptyClassRanges :: ClassAtom - ClassAtom ClassRanges evaluates as follows:

1. Evaluate the first ClassAtom to obtain a CharSet A.

2. Evaluate the second ClassAtom to obtain a CharSet B.

3. Evaluate ClassRanges to obtain a CharSet C.

4. Call CharacterRange(A, B) and let D be the resulting CharSet.

5. Return the union of CharSets D and C.

The internal helper function CharacterRange takes two CharSet parameters A and B and performs the following:

1. If A does not contain exactly one character or B does not contain exactly one character then throw a SyntaxError exception.

2. Let a be the one character in CharSet A.

3. Let b be the one character in CharSet B.

4. Let i be the code point value of character a.

5. Let j be the code point value of character b.

6. If i > j then throw a SyntaxError exception.

7. Return the set containing all characters numbered i through j, inclusive.

The production NonemptyClassRangesNoDash :: ClassAtom evaluates by evaluating ClassAtom to obtain a CharSet and returning that CharSet.

The production NonemptyClassRangesNoDash :: ClassAtomNoDash NonemptyClassRangesNoDash evaluates as follows:

1. Evaluate ClassAtomNoDash to obtain a CharSet A.

2. Evaluate NonemptyClassRangesNoDash to obtain a CharSet B.

3. Return the union of CharSets A and B.

The production NonemptyClassRangesNoDash :: ClassAtomNoDash - ClassAtom ClassRanges evaluates as follows:

1. Evaluate ClassAtomNoDash to obtain a CharSet A.

2. Evaluate ClassAtom to obtain a CharSet B.

3. Evaluate ClassRanges to obtain a CharSet C.

4. Call CharacterRange(A, B) and let D be the resulting CharSet.

5. Return the union of CharSets D and C.

Informative comments: ClassRanges can expand into single ClassAtoms and/ or ranges of two ClassAtoms separated by dashes. In the latter case the ClassRanges includes all characters between the first ClassAtom and the second ClassAtom, inclusive; an error occurs if either ClassAtom does not represent a single character (for example, if one is \w) or if thefirstClassAtom's code point value is greater than the second ClassAtom's code point value.

Even if the pattern ignores case, the case of the two ends of a range is significant in determining which characters belong to the range. Thus, for example, the pattern /[E-F]/ i matches only the letters E, F, e, and f, while the pattern /[E-f]/ i matches all upper and lower-case ASCII letters as well as the symbols [, \, ], ^, _, and `.

A - character can be treated literally or it can denote a range. It is treated literally if it is the first or last character of ClassRanges, the beginning or end limit of a range specification, or immediately follows a range specification.

The production ClassAtom :: - evaluates by returning the CharSet containing the one character -.

The production ClassAtom :: ClassAtomNoDash evaluates by evaluating ClassAtomNoDash to obtain a CharSet and returning that CharSet.

The production ClassAtomNoDash :: SourceCharacter but not one of \ ] - evaluates by returning a one-element CharSet containing the character represented by SourceCharacter.

The production ClassAtomNoDash :: \ ClassEscape evaluates by evaluating ClassEscape to obtain a CharSet and returning that CharSet.

The production ClassEscape :: DecimalEscape evaluates as follows:

1. Evaluate DecimalEscape to obtain an EscapeValue E.

2. If E is not a character then throw a SyntaxError exception.

3. Let ch be E's character.

4. Return the one-element CharSet containing the character ch.

The production ClassEscape :: b evaluates by returning the CharSet containing the one character <BS> (Unicode value 0008).

The production ClassEscape :: CharacterEscape evaluates by evaluating CharacterEscape to obtain a character and returning a one-element CharSet containing that character.

The production ClassEscape :: CharacterClassEscape evaluates by evaluating CharacterClassEscape to obtain a CharSet and returning that CharSet.

Informative comments: A ClassAtom can use any of the escape sequences that are allowed in the rest of the regular expression except for \b, \B, and backreferences. Inside a CharacterClass, \b means the backspace character, while \B and backreferences raise errors. Using a backreference inside a ClassAtom causes an error.

If pattern is an object R whose [[Class]] property is "RegExp" and flags is undefined, then return R unchanged. Otherwise call the RegExp constructor (15.10.4.1), passing it the pattern and flags arguments and return the object constructed by that constructor.

When RegExp is called as part of a new expression, it is a constructor: it initialises the newly created object.

If pattern is an object R whose [[Class]] property is "RegExp" and flags is undefined, then let P be the pattern used to construct R and let F be the flags used to construct R. If pattern is an object R whose [[Class]] property is "RegExp" and flags is not undefined, then throw a TypeError exception. Otherwise, let P be the empty string if pattern is undefined and ToString(pattern) otherwise, and let F be the empty string if flags is undefined and ToString(flags) otherwise.

The global property of the newly constructed object is set to a Boolean value that is true if F contains the character "g" and false otherwise.

The ignoreCase property of the newly constructed object is set to a Boolean value that is true if F contains the character "i" and false otherwise.

The multiline property of the newly constructed object is set to a Boolean value that is true if F contains the character "m" and false otherwise.

If F contains any character other than "g", "i", or" m", or if it contains the same one more than once, then throw a SyntaxError exception.

If P's characters do not have the form Pattern, then throw a SyntaxError exception. Otherwise let the newly constructed object have a [[Match]] property obtained by evaluating ("compiling") Pattern. Note that evaluating Pattern may throw a SyntaxError exception. (Note: if pattern is a StringLiteral, the usual escape sequence substitutions are performed before the string is processed by RegExp. If pattern must contain an escape sequence to be recognised by RegExp, the"\" character must be escaped within the StringLiteral to prevent its being removed when the contents of the StringLiteral are formed.)

The source property of the newly constructed object is set to an implementation-defined string value in the form of a Pattern based on P.

The lastIndex property of the newly constructed object is set to 0.

The [[Prototype]] property of the newly constructed object is set to the original RegExp prototype object, the one that is the initial value of RegExp.prototype.

The [[Class]] property of the newly constructed object is set to "RegExp".

The value of the internal [[Prototype]] property of the RegExp constructor is the Function prototype object (15.3.4).

Besides the internal properties and the length property (whose value is 2), the RegExp constructor has the following properties:

The initial value of RegExp.prototype is the RegExp prototype object (15.10.6).

This property shall have the attributes { DontEnum, DontDelete, ReadOnly }.

The value of the internal [[Prototype]] property of the RegExp prototype object is the Object prototype. The value of the internal [[Class]] property of the RegExp prototype object is "Object".

The RegExp prototype object does not have a valueOf property of its own; however, it inherits the valueOf property from the Object prototype object.

In the following descriptions of functions that are properties of the RegExp prototype object, the phrase "this RegExp object" refers to the object that is the this value for the invocation of the function; a TypeError exception is thrown if the this value is not an object for which the value of the internal [[Class]] property is "RegExp".

The initial value of RegExp.prototype.constructor is the built-in RegExp constructor.

Performs a regular expression match of string against the regular expression and returns an Array object containing the results of the match, or null if the string did not match

The string ToString(string) is searched for an occurrence of the regular expression pattern as follows:

1. Let S be the value of ToString(string).

2. Let length be the length of S.

3. Let lastIndex be the value of the lastIndex property.

4. Let i be the value of ToInteger(lastIndex).

5. If the global property is false, let i =0.

6. If i <0 or i > length then set lastIndex to 0 and return null.

7. Call [[Match]], giving it the arguments S and i. If [[Match]] returned failure, go to step 8; otherwise let r be its State result and go to step 10.

8. Let i = i+ 1.

9. Go to step 6.

10. Let e be r's endIndex value.

11. If the global property is true, setlastIndex to e.

12. Let n be the length of r's captures array. (This is the same value as 15.10.2.1's NCapturingParens.)

13. Return a new array with the following properties:

• The index property is set to the position of the matched substring within the complete string S.
• The input property is set to S.
• The length property is set to n +1.
• The 0 property is set to the matched substring (i. e. the portion of S between offset i inclusive and offset e exclusive).
• For each integer i such that i >0 and i <= n, set the property named ToString(i) to the i^th element of r's captures array.

Equivalent to the expression RegExp.prototype.exec(string) != null.

Let src be a string in the form of a Pattern representing the current regular expression. src may or may not be identical to the source property or to the source code supplied to the RegExp constructor; however, if src were supplied to the RegExp constructor along with the current regular expression's flags, the resulting regular expression must behave identically to the current regular expression.

toString returns a string value formed by concatenating the strings "/", src, and "/"; plus "g" if the global property is true, "i" if the ignoreCase property is true, and" m" if the multiline property is true.

NOTE
An implementation may choose to take advantage of src being allowed to be different from the source passed to the RegExp constructor to escape special characters in src. For example, in the regular expression obtained from new RegExp("/"), src could be, among other possibilities, "/" or "\/". The latter would permit the entire result ("/\//") of the toString call to have the form RegularExpressionLiteral.

RegExp instances inherit properties from their [[Prototype]] object as specified above and also have the following properties.

The value of the source property is string in the form of a Pattern representing the current regular expression. This property shall have the attributes { DontDelete, ReadOnly, DontEnum }.

The value of the global property is a Boolean value indicating whether the flags contained the character "g". This property shall have the attributes { DontDelete, ReadOnly, DontEnum }.

The value of the ignoreCase property is a Boolean value indicating whether the flags contained the character "i". This property shall have the attributes { DontDelete, ReadOnly, DontEnum }.

The value of the multiline property is a Boolean value indicating whether the flags contained the character "m". This property shall have the attributes { DontDelete, ReadOnly, DontEnum }.

The value of the lastIndex property is an integer that specifies the string position at which to start the next match. This property shall have the attributes { DontDelete, DontEnum }.

Instances of Error objects are thrown as exceptions when runtime errors occur. The Error objects may also serve as base objects for user-defined exception classes.

When Error is called as a function rather than as a constructor, it creates and initialises a new Error object. Thus the function call Error(...) is equivalent to the object creation expression new Error(...) with the same arguments.

The [[Prototype]] property of the newly constructed object is set to the original Error prototype object, the one that is the initial value of Error.prototype (15.11.3.1).

The [[Class]] property of the newly constructed object is set to "Error".

If the argument message is not undefined, the message property of the newly constructed object is set to ToString(message).

When Error is called as part of a new expression, it is a constructor: it initialises the newly created object.

The [[Prototype]] property of the newly constructed object is set to the original Error prototype object, the one that is the initial value of Error.prototype (15.11.3.1).

The [[Class]] property of the newly constructed Error object is set to "Error".

If the argument message is not undefined, the message property of the newly constructed object is set to ToString(message).

The value of the internal [[Prototype]] property of the Error constructor is the Function prototype object (15.3.4).

Besides the internal properties and the length property (whose value is 1), the Error constructor has the following property:

The initial value of Error.prototype is the Error prototype object (15.11.4).

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

The Error prototype object is itself an Error object (its [[Class]] is "Error").

The value of the internal [[Prototype]] property of the Error prototype object is the Object prototype object (15.2.3.1).

The initial value of Error.prototype.constructor is the built-in Error constructor.

The initial value of Error.prototype.name is "Error".

The initial value of Error.prototype.message is an implementation-defined string.

Returns an implementation defined string.

Error instances have no special properties beyond those inherited from the Error prototype object.

One of the NativeError objects below is thrown when a runtime error is detected. All of these objects share the same structure, as described in 15.11.7.

Indicates that the global function eval was used in a way that is incompatible with its definition. See 15.1.2.1.

Indicates a numeric value has exceeded the allowable range. See 15.4.2.2, 15.4.5.1, 15.7.4.5, 15.7.4.6, and 15.7.4.7.

Indicate that an invalid reference value has been detected. See 8.7.1, and 8.7.2.

Indicates that a parsing error has occurred. See 15.1.2.1, 15.3.2.1, 15.10.2.5, 15.10.2.9, 15.10.2.15, 15.10.2.19, and 15.10.4.1.

Indicates the actual type of an operand is different than the expected type. See 8.6.2, 8.6.2.6, 9.9, 11.2.2, 11.2.3, 11.8.6, 11.8.7, 15.3.4.2, 15.3.4.3, 15.3.4.4, 15.3.5.3, 15.4.4.2, 15.4.4.3, 15.5.4.2, 15.5.4.3, 15.6.4, 15.6.4.2, 15.6.4.3, 15.7.4, 15.7.4.2, 15.7.4.4, 15.9.5, 15.9.5.9, 15.9.5.27, 15.10.4.1, and 15.10.6.

Indicates that one of the global URI handling functions was used in a way that is incompatible with its definition. See 15.1.3.

When an ECMAScript implementation detects a runtime error, it throws an instance of one of the NativeError objects defined in 15.11.6. Each of these objects has the structure described below, differing only in the name used as the constructor name instead of NativeError, in thename property of the prototype object, and in the implementation-defined message property of the prototype object.

For each error object, references to NativeError in the definition should be replaced with the appropriate error object name from 15.11.6.

When a NativeError constructor is called as a function rather than as a constructor, it creates and initialises a new object. A call of the object as a function is equivalent to calling it as a constructor with the same arguments.

The [[Prototype]] property of the newly constructed object is set to the prototype object for this error constructor. The [[Class]] property of the newly constructed object is set to "Error".

If the argument message is not undefined, the message property of the newly constructed object is set to ToString( message).

When a NativeError constructor is called as part of a new expression, it is a constructor: it initialises the newly created object.

The [[Prototype]] property of the newly constructed object is set to the prototype object for this NativeError constructor. The [[Class]] property of the newly constructed object is set to "Error".

If the argument message is not undefined, the message property of the newly constructed object is set to ToString( message).

The value of the internal [[Prototype]] property of a NativeError constructor is the Function prototype object (15.3.4).

Besides the internal properties and the length property (whose value is 1), each NativeError constructor has the following property:

The initial value of NativeError. prototype is a NativeError prototype object (15.11.7.7). Each NativeError constructor has a separate prototype object.

This property has the attributes { DontEnum, DontDelete, ReadOnly }.

Each NativeError prototype object is an Error object (its [[Class]] is "Error").

The value of the internal [[Prototype]] property of each NativeError prototype object is the Error prototype object (15.11.4).

The initial value of the constructor property of the prototype for a given NativeError constructor is the NativeError constructor function itself (15.11.7).

The initial value of the name property of the prototype for a given NativeError constructor is the name of the constructor (the name used instead of NativeError).

The initial value of the message property of the prototype for a given NativeError constructor is an implementation-defined string.

NOTE
The prototypes for the NativeError constructors do not themselves provide a toString function, but instances of errors will inherit it from the Error prototype object.

NativeError instances have no special properties beyond those inherited from the Error prototype object.