javascript_ecma_262_5th_ed.info-2

これは javascript_ecma_262_5th_ed.info、es5.texi より makeinfo
バージョン 4.8 によって作成されました。


File: javascript_ecma_262_5th_ed.info,  Node: 1163 Applying the Additive Operators to Numbers,  Next: 117 Bitwise Shift Operators,  Prev: 1162 The Subtraction Operator -,  Up: Top

190 11.6.3 (#sec-11.6.3) Applying the Additive Operators to Numbers
*******************************************************************

The `+' operator performs addition when applied to two operands of
numeric type, producing the sum of the operands. The `-' operator
performs subtraction, producing the difference of two numeric operands.

   Addition is a commutative operation, but not always associative.

   The result of an addition is determined using the rules of IEEE 754
binary double-precision arithmetic:

   * If either operand is NaN, the result is NaN.

   * The sum of two infinities of opposite sign is NaN.

   * The sum of two infinities of the same sign is the infinity of that
     sign.

   * The sum of an infinity and a finite value is equal to the infinite
     operand.

   * The sum of two negative zeros is −0. The sum of two positive
     zeros, or of two zeros of opposite sign, is +0.

   * The sum of a zero and a nonzero finite value is equal to the
     nonzero operand.

   * The sum of two nonzero finite values of the same magnitude and
     opposite sign is +0.

   * In the remaining cases, where neither an infinity, nor a zero, nor
     NaN is involved, and the operands have the same sign or have
     different magnitudes, the sum is computed and rounded to the
     nearest representable value using IEEE 754 round-to-nearest mode.
     If the magnitude is too large to represent, the operation
     overflows and the result is then an infinity of appropriate sign.
     The ECMAScript language requires support of gradual underflow as
     defined by IEEE 754.

   The `-' operator performs subtraction when applied to two operands
of numeric type, producing the difference of its operands; the left
operand is the minuend and the right operand is the subtrahend. Given
numeric operands a and b, it is always the case that
`<var>a</var>-<var>b</var>' produces the same result as `<var>a</var>
+(-<var>b</var>)'.


File: javascript_ecma_262_5th_ed.info,  Node: 117 Bitwise Shift Operators,  Next: 1171 The Left Shift Operator <<,  Prev: 1163 Applying the Additive Operators to Numbers,  Up: Top

191 11.7 (#sec-11.7) Bitwise Shift Operators
********************************************

* Menu:

* Syntax::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Up: 117 Bitwise Shift Operators

191.1 Syntax
============

ShiftExpression : AdditiveExpression ShiftExpression `<<'
AdditiveExpression ShiftExpression `>>' AdditiveExpression
ShiftExpression `>>>' AdditiveExpression


File: javascript_ecma_262_5th_ed.info,  Node: 1171 The Left Shift Operator <<,  Next: 1172 The Signed Right Shift Operator >>,  Prev: 117 Bitwise Shift Operators,  Up: Top

192 11.7.1 (#sec-11.7.1) The Left Shift Operator ( `<<' )
*********************************************************

Performs a bitwise left shift operation on the left operand by the
amount specified by the right operand.

  1. Let lref be the result of evaluating ShiftExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating AdditiveExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let lnum be ToInt32 (#sec-9.5)(lval).

  6. Let rnum be ToUint32 (#sec-9.6)(rval).

  7. Let shiftCount be the result of masking out all but the least
     significant 5 bits of rnum, that is, compute rnum & 0x1F.

  8. Return the result of left shifting lnum by shiftCount bits. The
     result is a signed 32-bit integer.


File: javascript_ecma_262_5th_ed.info,  Node: 1172 The Signed Right Shift Operator >>,  Next: 1173 The Unsigned Right Shift Operator >>>,  Prev: 1171 The Left Shift Operator <<,  Up: Top

193 11.7.2 (#sec-11.7.2) The Signed Right Shift Operator ( `>>' )
*****************************************************************

Performs a sign-filling bitwise right shift operation on the left
operand by the amount specified by the right operand.

   The production ShiftExpression : ShiftExpression `>>'
AdditiveExpression is evaluated as follows:

  1. Let lref be the result of evaluating ShiftExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating AdditiveExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let lnum be ToInt32 (#sec-9.5)(lval).

  6. Let rnum be ToUint32 (#sec-9.6)(rval).

  7. Let shiftCount be the result of masking out all but the least
     significant 5 bits of rnum, that is, compute rnum & 0x1F.

  8. Return the result of performing a sign-extending right shift of
     lnum by shiftCount bits. The most significant bit is propagated.
     The result is a signed 32-bit integer.


File: javascript_ecma_262_5th_ed.info,  Node: 1173 The Unsigned Right Shift Operator >>>,  Next: 118 Relational Operators,  Prev: 1172 The Signed Right Shift Operator >>,  Up: Top

194 11.7.3 (#sec-11.7.3) The Unsigned Right Shift Operator ( `>>>' )
********************************************************************

Performs a zero-filling bitwise right shift operation on the left
operand by the amount specified by the right operand.

   The production ShiftExpression : ShiftExpression `>>>'
AdditiveExpression is evaluated as follows:

  1. Let lref be the result of evaluating ShiftExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating AdditiveExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let lnum be ToUint32 (#sec-9.6)(lval).

  6. Let rnum be ToUint32 (#sec-9.6)(rval).

  7. Let shiftCount be the result of masking out all but the least
     significant 5 bits of rnum, that is, compute rnum & 0x1F.

  8. Return the result of performing a zero-filling right shift of lnum
     by shiftCount bits. Vacated bits are filled with zero. The result
     is an unsigned 32-bit integer.


File: javascript_ecma_262_5th_ed.info,  Node: 118 Relational Operators,  Next: 1181 The Less-than Operator <,  Prev: 1173 The Unsigned Right Shift Operator >>>,  Up: Top

195 11.8 (#sec-11.8) Relational Operators
*****************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 118 Relational Operators

195.1 Syntax
============

RelationalExpression : ShiftExpression RelationalExpression `<'
ShiftExpression RelationalExpression `>' ShiftExpression
RelationalExpression `<=' ShiftExpression RelationalExpression `>='
ShiftExpression RelationalExpression `instanceof' ShiftExpression
RelationalExpression `in' ShiftExpression RelationalExpressionNoIn :
ShiftExpression RelationalExpressionNoIn `<' ShiftExpression
RelationalExpressionNoIn `>' ShiftExpression RelationalExpressionNoIn
`<=' ShiftExpression RelationalExpressionNoIn `>=' ShiftExpression
RelationalExpressionNoIn `instanceof' ShiftExpression NOTE The
“NoIn” variants are needed to avoid confusing the `in' operator in
a relational expression with the `in' operator in a `for' statement.


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 118 Relational Operators

195.2 Semantics
===============

The result of evaluating a relational operator is always of type
Boolean, reflecting whether the relationship named by the operator
holds between its two operands.

   The RelationalExpressionNoIn productions are evaluated in the same
manner as the RelationalExpression productions except that the
contained RelationalExpressionNoIn is evaluated instead of the
contained RelationalExpression.


File: javascript_ecma_262_5th_ed.info,  Node: 1181 The Less-than Operator <,  Next: 1182 The Greater-than Operator >,  Prev: 118 Relational Operators,  Up: Top

196 11.8.1 (#sec-11.8.1) The Less-than Operator ( `<' )
*******************************************************

The production RelationalExpression : RelationalExpression `<'
ShiftExpression is evaluated as follows:

  1. Let lref be the result of evaluating RelationalExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating ShiftExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let r be the result of performing abstract relational comparison
     lval < rval. (see 11.8.5 (#sec-11.8.5))

  6. If r is undefined, return false. Otherwise, return r.


File: javascript_ecma_262_5th_ed.info,  Node: 1182 The Greater-than Operator >,  Next: 1183 The Less-than-or-equal Operator <=,  Prev: 1181 The Less-than Operator <,  Up: Top

197 11.8.2 (#sec-11.8.2) The Greater-than Operator ( `>' )
**********************************************************

The production RelationalExpression : RelationalExpression `>'
ShiftExpression is evaluated as follows:

  1. Let lref be the result of evaluating RelationalExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating ShiftExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let r be the result of performing abstract relational comparison
     rval < lval with LeftFirst equal to false. (see 11.8.5
     (#sec-11.8.5)).

  6. If r is undefined, return false. Otherwise, return r.


File: javascript_ecma_262_5th_ed.info,  Node: 1183 The Less-than-or-equal Operator <=,  Next: 1184 The Greater-than-or-equal Operator >=,  Prev: 1182 The Greater-than Operator >,  Up: Top

198 11.8.3 (#sec-11.8.3) The Less-than-or-equal Operator ( `<=' )
*****************************************************************

The production RelationalExpression : RelationalExpression `<='
ShiftExpression is evaluated as follows:

  1. Let lref be the result of evaluating RelationalExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating ShiftExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let r be the result of performing abstract relational comparison
     rval < lval with LeftFirst equal to false. (see 11.8.5
     (#sec-11.8.5)).

  6. If r is true or undefined, return false. Otherwise, return true.


File: javascript_ecma_262_5th_ed.info,  Node: 1184 The Greater-than-or-equal Operator >=,  Next: 1185 The Abstract Relational Comparison Algorithm,  Prev: 1183 The Less-than-or-equal Operator <=,  Up: Top

199 11.8.4 (#sec-11.8.4) The Greater-than-or-equal Operator ( `>=' )
********************************************************************

The production RelationalExpression : RelationalExpression `>='
ShiftExpression is evaluated as follows:

  1. Let lref be the result of evaluating RelationalExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating ShiftExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let r be the result of performing abstract relational comparison
     lval < rval. (see 11.8.5 (#sec-11.8.5))

  6. If r is true or undefined, return false. Otherwise, return true.


File: javascript_ecma_262_5th_ed.info,  Node: 1185 The Abstract Relational Comparison Algorithm,  Next: 1186 The instanceof operator,  Prev: 1184 The Greater-than-or-equal Operator >=,  Up: Top

200 11.8.5 (#sec-11.8.5) The Abstract Relational Comparison Algorithm
*********************************************************************

The comparison x < y, where x and y are values, produces true, false,
or undefined (which indicates that at least one operand is NaN). In
addition to x and y the algorithm takes a Boolean flag named LeftFirst
as a parameter. The flag is used to control the order in which
operations with potentially visible side-effects are performed upon x
and y. It is necessary because ECMAScript specifies left to right
evaluation of expressions. The default value of LeftFirst is true and
indicates that the x parameter corresponds to an expression that occurs
to the left of the y parameter’s corresponding expression. If
LeftFirst is false, the reverse is the case and operations must be
performed upon y before x. Such a comparison is performed as follows:

  1. If the LeftFirst flag is true, then
       1. Let px be the result of calling ToPrimitive (#sec-9.1)(x,
          hint Number).

       2. Let py be the result of calling ToPrimitive (#sec-9.1)(y,
          hint Number).

  2. Else the order of evaluation needs to be reversed to preserve left
     to right evaluation
       1. Let py be the result of calling ToPrimitive (#sec-9.1)(y,
          hint Number).

       2. Let px be the result of calling ToPrimitive (#sec-9.1)(x,
          hint Number).

  3. If it is not the case that both Type (#def-type)(px) is String and
     Type (#def-type)(py) is String, then
       1. Let nx be the result of calling ToNumber (#sec-9.3)(px).
          Because px and py are primitive values evaluation order is
          not important.

       2. Let ny be the result of calling ToNumber (#sec-9.3)(py).

       3. If nx is NaN, return undefined.

       4. If ny is NaN, return undefined.

       5. If nx and ny are the same Number value, return false.

       6. If nx is +0 and ny is −0, return false.

       7. If nx is −0 and ny is +0, return false.

       8. If nx is +∞, return false.

       9. If ny is +∞, return true.

      10. If ny is −∞, return false.

      11. If nx is −∞, return true.

      12. If the mathematical value of nx is less than the mathematical
          value of ny —note that these mathematical values are both
          finite and not both zero—return true. Otherwise, return
          false.

  4. Else, both px and py are Strings
       1. If py is a prefix of px, return false. (A String value p is a
          prefix of String value q if q can be the result of
          concatenating p and some other String r. Note that any String
          is a prefix of itself, because r may be the empty String.)

       2.       3. Let k be the smallest nonnegative integer such that the
          character at position k within px is different from the
          character at position k within py. (There must be such a k,
          for neither String is a prefix of the other.)

       4. Let m be the integer that is the code unit value for the
          character at position k within px.

       5. Let n be the integer that is the code unit value for the
          character at position k within py.

       6. If m < n, return true. Otherwise, return false.


   NOTE 1 Step 3 differs from step 7 in the algorithm for the addition
operator `+' (11.6.1 (#sec-11.6.1)) in using and instead of or.

   NOTE 2 The comparison of Strings uses a simple lexicographic
ordering on sequences of code unit values. There is no attempt to use
the more complex, semantically oriented definitions of character or
string equality and collating order defined in the Unicode
specification. Therefore String values that are canonically equal
according to the Unicode standard could test as unequal. In effect this
algorithm assumes that both Strings are already in normalised form.
Also, note that for strings containing supplementary characters,
lexicographic ordering on sequences of UTF-16 code unit values differs
from that on sequences of code point values.


File: javascript_ecma_262_5th_ed.info,  Node: 1186 The instanceof operator,  Next: 1187 The in operator,  Prev: 1185 The Abstract Relational Comparison Algorithm,  Up: Top

201 11.8.6 (#sec-11.8.6) The `instanceof' operator
**************************************************

The production RelationalExpression: RelationalExpression `instanceof'
ShiftExpression is evaluated as follows:

  1. Let lref be the result of evaluating RelationalExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating ShiftExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. If Type (#def-type)(rval) is not Object, throw a TypeError
     exception.

  6. If rval does not have a [[HasInstance]] internal method, throw a
     TypeError exception.

  7. Return the result of calling the [[HasInstance]] internal method
     of rval with argument lval.


File: javascript_ecma_262_5th_ed.info,  Node: 1187 The in operator,  Next: 119 Equality Operators,  Prev: 1186 The instanceof operator,  Up: Top

202 11.8.7 (#sec-11.8.7) The `in' operator
******************************************

The production RelationalExpression : RelationalExpression `in'
ShiftExpression is evaluated as follows:

  1. Let lref be the result of evaluating RelationalExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating ShiftExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. If Type (#def-type)(rval) is not Object, throw a TypeError
     exception.

  6. Return the result of calling the [[HasProperty]] internal method
     of rval with argument ToString (#sec-9.8)(lval).


File: javascript_ecma_262_5th_ed.info,  Node: 119 Equality Operators,  Next: 1191 The Equals Operator ==,  Prev: 1187 The in operator,  Up: Top

203 11.9 (#sec-11.9) Equality Operators
***************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 119 Equality Operators

203.1 Syntax
============

EqualityExpression : RelationalExpression EqualityExpression `=='
RelationalExpression EqualityExpression `!=' RelationalExpression
EqualityExpression `===' RelationalExpression EqualityExpression `!=='
RelationalExpression EqualityExpressionNoIn : RelationalExpressionNoIn
EqualityExpressionNoIn `==' RelationalExpressionNoIn
EqualityExpressionNoIn `!=' RelationalExpressionNoIn
EqualityExpressionNoIn `===' RelationalExpressionNoIn
EqualityExpressionNoIn `!==' RelationalExpressionNoIn


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 119 Equality Operators

203.2 Semantics
===============

The result of evaluating an equality operator is always of type
Boolean, reflecting whether the relationship named by the operator
holds between its two operands.

   The EqualityExpressionNoIn productions are evaluated in the same
manner as the EqualityExpression productions except that the contained
EqualityExpressionNoIn and RelationalExpressionNoIn are evaluated
instead of the contained EqualityExpression and RelationalExpression,
respectively.


File: javascript_ecma_262_5th_ed.info,  Node: 1191 The Equals Operator ==,  Next: 1192 The Does-not-equals Operator !=,  Prev: 119 Equality Operators,  Up: Top

204 11.9.1 (#sec-11.9.1) The Equals Operator ( `==' )
*****************************************************

The production EqualityExpression : EqualityExpression `=='
RelationalExpression is evaluated as follows:

  1. Let lref be the result of evaluating EqualityExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating RelationalExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Return the result of performing abstract equality comparison rval
     == lval. (see 11.9.3 (#sec-11.9.3)).


File: javascript_ecma_262_5th_ed.info,  Node: 1192 The Does-not-equals Operator !=,  Next: 1193 The Abstract Equality Comparison Algorithm,  Prev: 1191 The Equals Operator ==,  Up: Top

205 11.9.2 (#sec-11.9.2) The Does-not-equals Operator ( `!=' )
**************************************************************

The production EqualityExpression : EqualityExpression `!='
RelationalExpression is evaluated as follows:

  1. Let lref be the result of evaluating EqualityExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating RelationalExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let r be the result of performing abstract equality comparison
     rval == lval. (see 11.9.3 (#sec-11.9.3)).

  6. If r is true, return false. Otherwise, return true.


File: javascript_ecma_262_5th_ed.info,  Node: 1193 The Abstract Equality Comparison Algorithm,  Next: 1194 The Strict Equals Operator ===,  Prev: 1192 The Does-not-equals Operator !=,  Up: Top

206 11.9.3 (#sec-11.9.3) The Abstract Equality Comparison Algorithm
*******************************************************************

The comparison x == y, where x and y are values, produces true or
false. Such a comparison is performed as follows:

  1. If Type (#def-type)(x) is the same as Type (#def-type)(y), then
       1. If Type (#def-type)(x) is Undefined, return true.

       2. If Type (#def-type)(x) is Null, return true.

       3. If Type (#def-type)(x) is Number, then
            1. If x is NaN, return false.

            2. If y is NaN, return false.

            3. If x is the same Number value as y, return true.

            4. If x is +0 and y is −0, return true.

            5. If x is −0 and y is +0, return true.

            6. Return false.

       4. If Type (#def-type)(x) is String, then return true if x and y
          are exactly the same sequence of characters (same length and
          same characters in corresponding positions). Otherwise,
          return false.

       5. If Type (#def-type)(x) is Boolean, return true if x and y are
          both true or both false. Otherwise, return false.

       6. Return true if x and y refer to the same object. Otherwise,
          return false.

  2. If x is null and y is undefined, return true.

  3. If x is undefined and y is null, return true.

  4. If Type (#def-type)(x) is Number and Type (#def-type)(y) is
     String, return the result of the comparison x == ToNumber
     (#sec-9.3)(y).

  5. If Type (#def-type)(x) is String and Type (#def-type)(y) is
     Number, return the result of the comparison ToNumber (#sec-9.3)(x)
     == y.

  6. If Type (#def-type)(x) is Boolean, return the result of the
     comparison ToNumber (#sec-9.3)(x) == y.

  7. If Type (#def-type)(y) is Boolean, return the result of the
     comparison x == ToNumber (#sec-9.3)(y).

  8. If Type (#def-type)(x) is either String or Number and Type
     (#def-type)(y) is Object, return the result of the comparison x ==
     ToPrimitive (#sec-9.1)(y).

  9. If Type (#def-type)(x) is Object and Type (#def-type)(y) is either
     String or Number, return the result of the comparison ToPrimitive
     (#sec-9.1)(x) == y.

 10. Return false.

   NOTE 1 Given the above definition of equality:

   * String comparison can be forced by: `"" + a == "" +         b'.

   * Numeric comparison can be forced by: `+a ==         +b'.

   * Boolean comparison can be forced by: `!a ==         !b'.

   NOTE 2 The equality operators maintain the following invariants:

   * `<var>A</var> != <var>B</var>' is equivalent to `!(<var>A</var> ==
     <var>B</var>)'.

   * `<var>A</var> == <var>B</var>' is equivalent to `<var>B</var> ==
     <var>A</var>', except in the order of evaluation of A and B.

   NOTE 3 The equality operator is not always transitive. For example,
there might be two distinct String objects, each representing the same
String value; each String object would be considered equal to the
String value by the `==' operator, but the two String objects would not
be equal to each other.

   NOTE 4 Comparison of Strings uses a simple equality test on
sequences of code unit values. There is no attempt to use the more
complex, semantically oriented definitions of character or string
equality and collating order defined in the Unicode specification.
Therefore Strings values that are canonically equal according to the
Unicode standard could test as unequal. In effect this algorithm
assumes that both Strings are already in normalised form.


File: javascript_ecma_262_5th_ed.info,  Node: 1194 The Strict Equals Operator ===,  Next: 1195 The Strict Does-not-equal Operator !==,  Prev: 1193 The Abstract Equality Comparison Algorithm,  Up: Top

207 11.9.4 (#sec-11.9.4) The Strict Equals Operator ( `===' )
*************************************************************

The production EqualityExpression : EqualityExpression `==='
RelationalExpression is evaluated as follows:

  1. Let lref be the result of evaluating EqualityExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating RelationalExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Return the result of performing the strict equality comparison
     rval === lval. (See 11.9.6 (#sec-11.9.6))


File: javascript_ecma_262_5th_ed.info,  Node: 1195 The Strict Does-not-equal Operator !==,  Next: 1196 The Strict Equality Comparison Algorithm,  Prev: 1194 The Strict Equals Operator ===,  Up: Top

208 11.9.5 (#sec-11.9.5) The Strict Does-not-equal Operator ( `!==' )
*********************************************************************

The production EqualityExpression : EqualityExpression `!=='
RelationalExpression is evaluated as follows:

  1. Let lref be the result of evaluating EqualityExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating RelationalExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let r be the result of performing strict equality comparison rval
     === lval. (See 11.9.6 (#sec-11.9.6))

  6. If r is true, return false. Otherwise, return true.


File: javascript_ecma_262_5th_ed.info,  Node: 1196 The Strict Equality Comparison Algorithm,  Next: 1110 Binary Bitwise Operators,  Prev: 1195 The Strict Does-not-equal Operator !==,  Up: Top

209 11.9.6 (#sec-11.9.6) The Strict Equality Comparison Algorithm
*****************************************************************

The comparison x === y, where x and y are values, produces true or
false. Such a comparison is performed as follows:

  1. If Type (#def-type)(x) is different from Type (#def-type)(y),
     return false.

  2. If Type (#def-type)(x) is Undefined, return true.

  3. If Type (#def-type)(x) is Null, return true.

  4. If Type (#def-type)(x) is Number, then
       1. If x is NaN, return false.

       2. If y is NaN, return false.

       3. If x is the same Number value as y, return true.

       4. If x is +0 and y is −0, return true.

       5. If x is −0 and y is +0, return true.

       6. Return false.

  5. If Type (#def-type)(x) is String, then return true if x and y are
     exactly the same sequence of characters (same length and same
     characters in corresponding positions); otherwise, return false.

  6. If Type (#def-type)(x) is Boolean, return true if x and y are both
     true or both false; otherwise, return false.

  7. Return true if x and y refer to the same object. Otherwise, return
     false.

   NOTE This algorithm differs from the SameValue Algorithm (9.12)
(#sec-9.12) in its treatment of signed zeroes and NaNs.


File: javascript_ecma_262_5th_ed.info,  Node: 1110 Binary Bitwise Operators,  Next: 1111 Binary Logical Operators,  Prev: 1196 The Strict Equality Comparison Algorithm,  Up: Top

210 11.10 (#sec-11.10) Binary Bitwise Operators
***********************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1110 Binary Bitwise Operators

210.1 Syntax
============

BitwiseANDExpression : EqualityExpression BitwiseANDExpression `&'
EqualityExpression BitwiseANDExpressionNoIn : EqualityExpressionNoIn
BitwiseANDExpressionNoIn `&' EqualityExpressionNoIn
BitwiseXORExpression : BitwiseANDExpression BitwiseXORExpression `^'
BitwiseANDExpression BitwiseXORExpressionNoIn : BitwiseANDExpressionNoIn
BitwiseXORExpressionNoIn `^' BitwiseANDExpressionNoIn
BitwiseORExpression : BitwiseXORExpression BitwiseORExpression `|'
BitwiseXORExpression BitwiseORExpressionNoIn : BitwiseXORExpressionNoIn
BitwiseORExpressionNoIn `|' BitwiseXORExpressionNoIn


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1110 Binary Bitwise Operators

210.2 Semantics
===============

The production A : A @ B, where @ is one of the bitwise operators in
the productions above, is evaluated as follows:

  1. Let lref be the result of evaluating A.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating B.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let lnum be ToInt32 (#sec-9.5)(lval).

  6. Let rnum be ToInt32 (#sec-9.5)(rval).

  7. Return the result of applying the bitwise operator @ to lnum and
     rnum. The result is a signed 32 bit integer.


File: javascript_ecma_262_5th_ed.info,  Node: 1111 Binary Logical Operators,  Next: 1112 Conditional Operator ?,  Prev: 1110 Binary Bitwise Operators,  Up: Top

211 11.11 (#sec-11.11) Binary Logical Operators
***********************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1111 Binary Logical Operators

211.1 Syntax
============

LogicalANDExpression : BitwiseORExpression LogicalANDExpression `&&'
BitwiseORExpression LogicalANDExpressionNoIn : BitwiseORExpressionNoIn
LogicalANDExpressionNoIn `&&' BitwiseORExpressionNoIn

   LogicalORExpression : LogicalANDExpression LogicalORExpression `||'
LogicalANDExpression LogicalORExpressionNoIn : LogicalANDExpressionNoIn
LogicalORExpressionNoIn `||' LogicalANDExpressionNoIn


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1111 Binary Logical Operators

211.2 Semantics
===============

The production LogicalANDExpression : LogicalANDExpression `&&'
BitwiseORExpression is evaluated as follows:

  1. Let lref be the result of evaluating LogicalANDExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. If ToBoolean (#sec-9.2)(lval) is false, return lval.

  4. Let rref be the result of evaluating BitwiseORExpression.

  5. Return GetValue (#sec-8.7.1)(rref).

   The production LogicalORExpression : LogicalORExpression `||'
LogicalANDExpression is evaluated as follows:

  1. Let lref be the result of evaluating LogicalORExpression.

  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. If ToBoolean (#sec-9.2)(lval) is true, return lval.

  4. Let rref be the result of evaluating LogicalANDExpression.

  5. Return GetValue (#sec-8.7.1)(rref).

   The LogicalANDExpressionNoIn and LogicalORExpressionNoIn productions
are evaluated in the same manner as the LogicalANDExpression and
LogicalORExpression productions except that the contained
LogicalANDExpressionNoIn, BitwiseORExpressionNoIn and
LogicalORExpressionNoIn are evaluated instead of the contained
LogicalANDExpression, BitwiseORExpression and LogicalORExpression,
respectively.

   NOTE The value produced by a `&&' or `||' operator is not
necessarily of type Boolean. The value produced will always be the
value of one of the two operand expressions.


File: javascript_ecma_262_5th_ed.info,  Node: 1112 Conditional Operator ?,  Next: 1113 Assignment Operators,  Prev: 1111 Binary Logical Operators,  Up: Top

212 11.12 (#sec-11.12) Conditional Operator ( `?' `:' )
*******************************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1112 Conditional Operator ?

212.1 Syntax
============

ConditionalExpression : LogicalORExpression LogicalORExpression `?'
AssignmentExpression `:' AssignmentExpression ConditionalExpressionNoIn
: LogicalORExpressionNoIn LogicalORExpressionNoIn `?'
AssignmentExpression `:' AssignmentExpressionNoIn


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1112 Conditional Operator ?

212.2 Semantics
===============

The production ConditionalExpression : LogicalORExpression `?'
AssignmentExpression `:' AssignmentExpression is evaluated as follows:

  1. Let lref be the result of evaluating LogicalORExpression.

  2. If ToBoolean (#sec-9.2)(GetValue (#sec-8.7.1)(lref)) is true, then
       1. Let trueRef be the result of evaluating the first
          AssignmentExpression.

       2. Return GetValue (#sec-8.7.1)(trueRef).

  3. Else
       1. Let falseRef be the result of evaluating the second
          AssignmentExpression.

       2. Return GetValue (#sec-8.7.1)(falseRef).


   NOTE The grammar for a ConditionalExpression in ECMAScript is a
little bit different from that in C and Java, which each allow the
second subexpression to be an Expression but restrict the third
expression to be a ConditionalExpression. The motivation for this
difference in ECMAScript is to allow an assignment expression to be
governed by either arm of a conditional and to eliminate the confusing
and fairly useless case of a comma expression as the centre expression.


File: javascript_ecma_262_5th_ed.info,  Node: 1113 Assignment Operators,  Next: 11131 Simple Assignment =,  Prev: 1112 Conditional Operator ?,  Up: Top

213 11.13 (#sec-11.13) Assignment Operators
*******************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1113 Assignment Operators

213.1 Syntax
============

AssignmentExpression : ConditionalExpression LeftHandSideExpression
AssignmentOperator AssignmentExpression AssignmentExpressionNoIn :
ConditionalExpressionNoIn LeftHandSideExpression AssignmentOperator
AssignmentExpressionNoIn AssignmentOperator : one of `=    *=   /=   %=
 +=   -=   <<=  >>=  >>>= &=   ^=    |='


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1113 Assignment Operators

213.2 Semantics
===============

The AssignmentExpressionNoIn productions are evaluated in the same
manner as the AssignmentExpression productions except that the
contained ConditionalExpressionNoIn and AssignmentExpressionNoIn are
evaluated instead of the contained ConditionalExpression and
AssignmentExpression, respectively.


File: javascript_ecma_262_5th_ed.info,  Node: 11131 Simple Assignment =,  Next: 11132 Compound Assignment <var>op</var>=,  Prev: 1113 Assignment Operators,  Up: Top

214 11.13.1 (#sec-11.13.1) Simple Assignment ( `=' )
****************************************************

The production AssignmentExpression : LeftHandSideExpression `='
AssignmentExpression is evaluated as follows:

  1. Let lref be the result of evaluating LeftHandSideExpression.

  2. Let rref be the result of evaluating AssignmentExpression.

  3. Let rval be GetValue (#sec-8.7.1)(rref).

  4. Throw a SyntaxError exception if the following conditions are all
     true:
        * Type (#def-type)(lref) is Reference (#sec-8.7) is true

        * IsStrictReference (#def-IsStrictReference)(lref) is true

        * Type (#def-type)(GetBase (#def-GetBase)(lref)) is Enviroment
          Record

        * GetReferencedName (#def-GetReferencedName)(lref) is either
          "eval" or "arguments"

  5. Call PutValue (#sec-8.7.2)(lref, rval).

  6. Return rval.

   NOTE When an assignment occurs within strict mode code
(#sec-10.1.1), its LeftHandSide must not evaluate to an unresolvable
reference (#def-IsUnresolvableReference). If it does a ReferenceError
exception is thrown upon assignment. The LeftHandSide also may not be a
reference to a data property with the attribute value
{[[Writable]]:false}, to an accessor property with the attribute value
{[[Set]]:undefined}, nor to a non-existent property of an object whose
[[Extensible]] internal property has the value false. In these cases a
TypeError exception is thrown.


File: javascript_ecma_262_5th_ed.info,  Node: 11132 Compound Assignment <var>op</var>=,  Next: 1114 Comma Operator,  Prev: 11131 Simple Assignment =,  Up: Top

215 11.13.2 (#sec-11.13.2) Compound Assignment ( `<var>op</var>=' )
*******************************************************************

The production AssignmentExpression : LeftHandSideExpression @ `='
AssignmentExpression, where @ represents one of the operators indicated
above, is evaluated as follows:

  1.  2. Let lval be GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating AssignmentExpression.

  4. Let rval be GetValue (#sec-8.7.1)(rref).

  5. Let r be the result of applying operator @ to lval and rval.

  6. Throw a SyntaxError exception if the following conditions are all
     true:
        * Type (#def-type)(lref) is Reference (#sec-8.7) is true

        * IsStrictReference (#def-IsStrictReference)(lref) is true

        * Type (#def-type)(GetBase (#def-GetBase)(lref)) is Enviroment
          Record

        * GetReferencedName (#def-GetReferencedName)(lref) is either
          "eval" or "arguments"

  7. Call PutValue (#sec-8.7.2)(lref, r).

  8. Return r.

   NOTE See NOTE 11.13.1 (#sec-11.13.1).


File: javascript_ecma_262_5th_ed.info,  Node: 1114 Comma Operator,  Next: 12 Statements,  Prev: 11132 Compound Assignment <var>op</var>=,  Up: Top

216 11.14 (#sec-11.14) Comma Operator ( `,' )
*********************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1114 Comma Operator

216.1 Syntax
============

Expression : AssignmentExpression Expression `,' AssignmentExpression
ExpressionNoIn : AssignmentExpressionNoIn ExpressionNoIn `,'
AssignmentExpressionNoIn


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1114 Comma Operator

216.2 Semantics
===============

The production Expression : Expression `,' AssignmentExpression is
evaluated as follows:

  1. Let lref be the result of evaluating Expression.

  2. Call GetValue (#sec-8.7.1)(lref).

  3. Let rref be the result of evaluating AssignmentExpression.

  4. Return GetValue (#sec-8.7.1)(rref).

   The ExpressionNoIn production is evaluated in the same manner as the
Expression production except that the contained ExpressionNoIn and
AssignmentExpressionNoIn are evaluated instead of the contained
Expression and AssignmentExpression, respectively.

   NOTE GetValue (#sec-8.7.1) must be called even though its value is
not used because it may have observable side-effects.


File: javascript_ecma_262_5th_ed.info,  Node: 12 Statements,  Next: 121 Block,  Prev: 1114 Comma Operator,  Up: Top

217 12 (#sec-12) Statements
***************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 12 Statements

217.1 Syntax
============

Statement : Block VariableStatement EmptyStatement ExpressionStatement
IfStatement IterationStatement ContinueStatement BreakStatement
ReturnStatement WithStatement LabelledStatement SwitchStatement
ThrowStatement TryStatement DebuggerStatement


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 12 Statements

217.2 Semantics
===============

A Statement can be part of a LabelledStatement, which itself can be
part of a LabelledStatement, and so on. The labels introduced this way
are collectively referred to as the “current label set” when
describing the semantics of individual statements. A LabelledStatement
has no semantic meaning other than the introduction of a label to a
label set. The label set of an IterationStatement or a SwitchStatement
initially contains the single element empty. The label set of any other
statement is initially empty.

   NOTE Several widely used implementations of ECMAScript are known to
support the use of FunctionDeclaration as a Statement. However there
are significant and irreconcilable variations among the implementations
in the semantics applied to such FunctionDeclarations. Because of these
irreconcilable difference, the use of a FunctionDeclaration as a
Statement results in code that is not reliably portable among
implementations. It is recommended that ECMAScript implementations
either disallow this usage of FunctionDeclaration or issue a warning
when such a usage is encountered. Future editions of ECMAScript may
define alternative portable means for declaring functions in a
Statement context.


File: javascript_ecma_262_5th_ed.info,  Node: 121 Block,  Next: 122 Variable Statement,  Prev: 12 Statements,  Up: Top

218 12.1 (#sec-12.1) Block
**************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 121 Block

218.1 Syntax
============

Block : `{' StatementList_opt_ `}' StatementList : Statement
StatementList Statement


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 121 Block

218.2 Semantics
===============

The production Block : `{' `}' is evaluated as follows:

  1. Return (normal, empty, empty).

   The production Block : `{' StatementList `}' is evaluated as follows:

  1. Return the result of evaluating StatementList.

   The production StatementList : Statement is evaluated as follows:

  1.  2. If an exception was thrown, return (throw, V, empty) where V is
     the exception. (Execution now proceeds as if no exception were
     thrown.)

  3. Return s.

   The production StatementList : StatementList Statement is evaluated
as follows:

  1. Let sl be the result of evaluating StatementList.

  2. If sl is an abrupt completion (#sec-8.9), return sl.

  3. Let s be the result of evaluating Statement.

  4. If an exception was thrown, return (throw, V, empty) where V is
     the exception. (Execution now proceeds as if no exception were
     thrown.)

  5. If s.value is empty, let V = sl.value, otherwise let V = s.value.

  6. Return (s.type, V, s.target).


File: javascript_ecma_262_5th_ed.info,  Node: 122 Variable Statement,  Next: 1221 Strict Mode Restrictions,  Prev: 121 Block,  Up: Top

219 12.2 (#sec-12.2) Variable Statement
***************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 122 Variable Statement

219.1 Syntax
============

VariableStatement : `var' VariableDeclarationList `;'
VariableDeclarationList : VariableDeclaration VariableDeclarationList
`,' VariableDeclaration VariableDeclarationListNoIn :
VariableDeclarationNoIn VariableDeclarationListNoIn `,'
VariableDeclarationNoIn VariableDeclaration : Identifier
Initialiser_opt_ VariableDeclarationNoIn : Identifier
InitialiserNoIn_opt_ Initialiser : `=' AssignmentExpression
InitialiserNoIn : `=' AssignmentExpressionNoIn A variable statement
declares variables that are created as defined in 10.5 (#sec-10.5).
Variables are initialised to undefined when created. A variable with an
Initialiser is assigned the value of its AssignmentExpression when the
VariableStatement is executed, not when the variable is created.


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 122 Variable Statement

219.2 Semantics
===============

The production VariableStatement : `var' VariableDeclarationList `;' is
evaluated as follows:

  1. Evaluate VariableDeclarationList.

  2. Return (normal, empty, empty).

   The production VariableDeclarationList :VariableDeclaration is
evaluated as follows:

  1. Evaluate VariableDeclaration.

   The production VariableDeclarationList : VariableDeclarationList `,'
VariableDeclaration is evaluated as follows:

  1.  2. Evaluate VariableDeclaration.

   The production VariableDeclaration : Identifier is evaluated as
follows:

  1. Return a String value containing the same sequence of characters
     as in the Identifier.

   The production VariableDeclaration : Identifier Initialiser is
evaluated as follows:

  1. Let lhs be the result of evaluating Identifier as described in
     11.1.2 (#sec-11.1.2).

  2. Let rhs be the result of evaluating Initialiser.

  3. Let value be GetValue (#sec-8.7.1)(rhs).

  4. Call PutValue (#sec-8.7.2)(lhs, value).

  5. Return a String value containing the same sequence of characters
     as in the Identifier.

   NOTE The String value of a VariableDeclaration is used in the
evaluation of for-in statements (12.6.4 (#sec-12.6.4)).

   If a VariableDeclaration is nested within a with statement and the
Identifier in the VariableDeclaration is the same as a property name of
the binding object of the with statement’s object environment record,
then step 4 will assign value to the property instead of to the
VariableEnvironment binding of the Identifier.

   The production Initialiser : `=' AssignmentExpression is evaluated
as follows:

  1. Return the result of evaluating AssignmentExpression.

   The VariableDeclarationListNoIn, VariableDeclarationNoIn and
InitialiserNoIn productions are evaluated in the same manner as the
VariableDeclarationList, VariableDeclaration and Initialiser
productions except that the contained VariableDeclarationListNoIn,
VariableDeclarationNoIn, InitialiserNoIn and AssignmentExpressionNoIn
are evaluated instead of the contained VariableDeclarationList,
VariableDeclaration, Initialiser and AssignmentExpression, respectively.


File: javascript_ecma_262_5th_ed.info,  Node: 1221 Strict Mode Restrictions,  Next: 123 Empty Statement,  Prev: 122 Variable Statement,  Up: Top

220 12.2.1 (#sec-12.2.1) Strict Mode Restrictions
*************************************************

It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn
occurs within strict code (#sec-10.1.1) and its Identifier is either
"eval" or "arguments".


File: javascript_ecma_262_5th_ed.info,  Node: 123 Empty Statement,  Next: 124 Expression Statement,  Prev: 1221 Strict Mode Restrictions,  Up: Top

221 12.3 (#sec-12.3) Empty Statement
************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 123 Empty Statement

221.1 Syntax
============

EmptyStatement : `;'


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 123 Empty Statement

221.2 Semantics
===============

The production EmptyStatement : `;' is evaluated as follows:

  1. Return (normal, empty, empty).


File: javascript_ecma_262_5th_ed.info,  Node: 124 Expression Statement,  Next: 125 The if Statement,  Prev: 123 Empty Statement,  Up: Top

222 12.4 (#sec-12.4) Expression Statement
*****************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 124 Expression Statement

222.1 Syntax
============

ExpressionStatement : [lookahead ∉ (#def-lookahead-notin) {`{',
`function'}] Expression `;' NOTE An ExpressionStatement cannot start
with an opening curly brace because that might make it ambiguous with a
Block. Also, an ExpressionStatement cannot start with the `function'
keyword because that might make it ambiguous with a FunctionDeclaration.


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 124 Expression Statement

222.2 Semantics
===============

The production ExpressionStatement : [lookahead ∉
(#def-lookahead-notin) {`{', `function'}] Expression `;' is evaluated
as follows:

  1. Let exprRef be the result of evaluating Expression.

  2. Return (normal, GetValue (#sec-8.7.1)(exprRef), empty).


File: javascript_ecma_262_5th_ed.info,  Node: 125 The if Statement,  Next: 126 Iteration Statements,  Prev: 124 Expression Statement,  Up: Top

223 12.5 (#sec-12.5) The `if' Statement
***************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 125 The if Statement

223.1 Syntax
============

IfStatement : `if' `(' Expression `)' Statement `else' Statement `if'
`(' Expression `)' Statement Each `else' for which the choice of
associated `if' is ambiguous shall be associated with the nearest
possible `if' that would otherwise have no corresponding `else'.


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 125 The if Statement

223.2 Semantics
===============

The production IfStatement : `if' `(' Expression `)' Statement `else'
Statement is evaluated as follows:

  1. Let exprRef be the result of evaluating Expression.

  2. If ToBoolean (#sec-9.2)(GetValue (#sec-8.7.1)(exprRef)) is true,
     then
       1. Return the result of evaluating the first Statement.

  3. Else,
       1. Return the result of evaluating the second Statement.


   The production IfStatement : `if' `(' Expression `)' Statement is
evaluated as follows:

  1. Let exprRef be the result of evaluating Expression.

  2. If ToBoolean (#sec-9.2)(GetValue (#sec-8.7.1)(exprRef)) is false,
     return (normal, empty, empty).

  3. Return the result of evaluating Statement.


File: javascript_ecma_262_5th_ed.info,  Node: 126 Iteration Statements,  Next: 1261 The do–while Statement,  Prev: 125 The if Statement,  Up: Top

224 12.6 (#sec-12.6) Iteration Statements
*****************************************

* Menu:

* Syntax::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Up: 126 Iteration Statements

224.1 Syntax
============

IterationStatement : `do' Statement `while' `(' Expression `)' `;'
`while' `(' Expression `)' Statement `for' `('ExpressionNoIn_opt_`;'
Expression_opt_ `;' Expression_opt_ `)' Statement `for' `(' `var'
VariableDeclarationListNoIn `;' Expression_opt_ `;' Expression_opt_ `)'
Statement `for' `(' LeftHandSideExpression `in' Expression `)' Statement
`for' `(' `var' VariableDeclarationNoIn `in' Expression `)' Statement


File: javascript_ecma_262_5th_ed.info,  Node: 1261 The do–while Statement,  Next: 1262 The while Statement,  Prev: 126 Iteration Statements,  Up: Top

225 12.6.1 (#sec-12.6.1) The `do'–`while' Statement
*****************************************************

The production `do' Statement `while' `(' Expression `)' `;' is
evaluated as follows:

  1. Let V = empty.

  2. Let iterating be true.

  3. Repeat, while iterating is true
       1. Let stmt be the result of evaluating Statement.

       2. If stmt.value is not empty, let V = stmt.value .

       3. If stmt.type is not continue || stmt.target is not in the
          current label set, then
            1. If stmt.type is break and stmt.target is in the current
               label set, return (normal, V, empty).

            2. If stmt is an abrupt completion (#sec-8.9), return stmt.

       4. Let exprRef be the result of evaluating Expression.

       5. If ToBoolean (#sec-9.2)(GetValue (#sec-8.7.1)(exprRef)) is
          false, set iterating to false.

  4. Return (normal, V, empty);


File: javascript_ecma_262_5th_ed.info,  Node: 1262 The while Statement,  Next: 1263 The for Statement,  Prev: 1261 The do–while Statement,  Up: Top

226 12.6.2 (#sec-12.6.2) The `while' Statement
**********************************************

The production IterationStatement : `while' `(' Expression `)'
Statement is evaluated as follows:

  1. Let V = empty.

  2. Repeat
       1. Let exprRef be the result of evaluating Expression.

       2. If ToBoolean (#sec-9.2)(GetValue (#sec-8.7.1)(exprRef)) is
          false, return (normal, V, empty).

       3. Let stmt be the result of evaluating Statement.

       4. If stmt.value is not empty, let V = stmt.value.

       5. If stmt.type is not continue || stmt.target is not in the
          current label set, then
            1. If stmt.type is break and stmt.target is in the current
               label set, then
                 1. Return (normal, V, empty).

            2. If stmt is an abrupt completion (#sec-8.9), return stmt.




File: javascript_ecma_262_5th_ed.info,  Node: 1263 The for Statement,  Next: 1264 The for–in Statement,  Prev: 1262 The while Statement,  Up: Top

227 12.6.3 (#sec-12.6.3) The `for' Statement
********************************************

The production IterationStatement : `for' `(' ExpressionNoIn_opt_ `;'
Expression_opt_ `;' Expression_opt_`)' Statement is evaluated as
follows:

  1. If ExpressionNoIn is present, then.
       1. Let exprRef be the result of evaluating ExpressionNoIn.

       2. Call GetValue (#sec-8.7.1)(exprRef). (This value is not used.)

  2. Let V = empty.

  3. Repeat
       1. If the first Expression is present, then
            1. Let testExprRef be the result of evaluating the first
               Expression.

            2. If GetValue (#sec-8.7.1)(testExprRef) is false, return
               (normal, V, empty).

       2. Let stmt be the result of evaluating Statement.

       3. If stmt.value is not empty, let V = stmt.value

       4. If stmt.type is break and stmt.target is in the current label
          set, return (normal, V, empty).

       5. If stmt.type is not continue || stmt.target is not in the
          current label set, then
            1. If stmt is an abrupt completion (#sec-8.9), return stmt.

       6. If the second Expression is present, then
            1. Let incExprRef be the result of evaluating the second
               Expression.

            2. Call GetValue (#sec-8.7.1)(incExprRef). (This value is
               not used.)



   The production IterationStatement : `for' `(' `var'
VariableDeclarationListNoIn `;' Expression_opt_ `;' Expression_opt_ `)'
Statement is evaluated as follows:

  1. Evaluate VariableDeclarationListNoIn.

  2. Let V = empty.

  3. Repeat
       1. If the first Expression is present, then
            1. Let testExprRef be the result of evaluating the first
               Expression.

            2. If GetValue (#sec-8.7.1)(testExprRef) is false, then
               return (normal, V, empty).

       2. Let stmt be the result of evaluating Statement.

       3. If stmt.value is not empty, let V = stmt.value.

       4. If stmt.type is break and stmt.target is in the current label
          set, return (normal, V, empty).

       5. If stmt.type is not continue || stmt.target is not in the
          current label set, then
            1. If stmt is an abrupt completion (#sec-8.9), return stmt.

       6. If the second Expression is present, then.
            1. Let incExprRef be the result of evaluating the second
               Expression.

            2. Call GetValue (#sec-8.7.1)(incExprRef). (This value is
               not used.)




File: javascript_ecma_262_5th_ed.info,  Node: 1264 The for–in Statement,  Next: 127 The continue Statement,  Prev: 1263 The for Statement,  Up: Top

228 12.6.4 (#sec-12.6.4) The `for'–`in' Statement
***************************************************

The production IterationStatement : `for' `(' LeftHandSideExpression
`in' Expression `)' Statement is evaluated as follows:

  1. Let exprRef be the result of evaluating the Expression.

  2. Let experValue be GetValue (#sec-8.7.1)(exprRef).

  3. If experValue is null or undefined, return (normal, empty, empty).

  4. Let obj be ToObject (#sec-9.9)(experValue).

  5. Let V = empty.

  6. Repeat
       1. Let P be the name of the next property of obj whose
          [[Enumerable]] attribute is true. If there is no such
          property, return (normal, V, empty).

       2. Let lhsRef be the result of evaluating the
          LeftHandSideExpression ( it may be evaluated repeatedly).

       3. Call PutValue (#sec-8.7.2)(lhsRef, P).

       4. Let stmt be the result of evaluating Statement.

       5. If stmt.value is not empty, let V = stmt.value.

       6. If stmt.type is break and stmt.target is in the current label
          set, return (normal, V, empty).

       7. If stmt.type is not continue || stmt.target is not in the
          current label set, then
            1. If stmt is an abrupt completion (#sec-8.9), return stmt.



   The production IterationStatement : `for' `(' `var'
VariableDeclarationNoIn `in' Expression `)' Statement is evaluated as
follows:

  1. Let varName be the result of evaluating VariableDeclarationNoIn.

  2. Let exprRef be the result of evaluating the Expression.

  3. Let experValue be GetValue (#sec-8.7.1)(exprRef).

  4. If experValue is null or undefined, return (normal, empty, empty).

  5. Let obj be ToObject (#sec-9.9)(experValue).

  6. Let V = empty.

  7. Repeat
       1. Let P be the name of the next property of obj whose
          [[Enumerable]] attribute is true. If there is no such
          property, return (normal, V, empty).

       2. Let varRef be the result of evaluating varName as if it were
          an Identifier Reference (11.1.2 (#sec-11.1.2)); it may be
          evaluated repeatedly.

       3. Call PutValue (#sec-8.7.2)(varRef, P).

       4. Let stmt be the result of evaluating Statement.

       5. If stmt.value is not empty, let V = stmt.value.

       6. If stmt.type is break and stmt.target is in the current label
          set, return (normal, V, empty).

       7. If stmt.type is not continue || stmt.target is not in the
          current label set, then
            1. If stmt is an abrupt completion (#sec-8.9), return stmt.



   The mechanics and order of enumerating the properties (step 6.a in
the first algorithm, step 7.a in the second) is not specified.
Properties of the object being enumerated may be deleted during
enumeration. If a property that has not yet been visited during
enumeration is deleted, then it will not be visited. If new properties
are added to the object being enumerated during enumeration, the newly
added properties are not guaranteed to be visited in the active
enumeration. A property name must not be visited more than once in any
enumeration.

   Enumerating the properties of an object includes enumerating
properties of its prototype, and the prototype of the prototype, and so
on, recursively; but a property of a prototype is not enumerated if it
is “shadowed” because some previous object in the prototype chain
has a property with the same name. The values of [[Enumerable]]
attributes are not considered when determining if a property of a
prototype object is shadowed by a previous object on the prototype
chain.

   NOTE See NOTE 11.13.1 (#sec-11.13.1).


File: javascript_ecma_262_5th_ed.info,  Node: 127 The continue Statement,  Next: 128 The break Statement,  Prev: 1264 The for–in Statement,  Up: Top

229 12.7 (#sec-12.7) The `continue' Statement
*********************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 127 The continue Statement

229.1 Syntax
============

ContinueStatement : `continue' [no LineTerminator here]
(#def-restricted-production) Identifier_opt_ `;'


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 127 The continue Statement

229.2 Semantics
===============

A program is considered syntactically incorrect if either of the
following is true:

   * The program contains a `continue' statement without the optional
     Identifier, which is not nested, directly or indirectly (but not
     crossing function boundaries), within an IterationStatement.

   * The program contains a `continue' statement with the optional
     Identifier, where Identifier does not appear in the label set of
     an enclosing (but not crossing function boundaries)
     IterationStatement.

   A ContinueStatement without an Identifier is evaluated as follows:

  1. Return (continue, empty, empty).

   A ContinueStatement with the optional Identifier is evaluated as
follows:

  1. Return (continue, empty, Identifier).


File: javascript_ecma_262_5th_ed.info,  Node: 128 The break Statement,  Next: 129 The return Statement,  Prev: 127 The continue Statement,  Up: Top

230 12.8 (#sec-12.8) The `break' Statement
******************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 128 The break Statement

230.1 Syntax
============

BreakStatement : `break' [no LineTerminator here]
(#def-restricted-production) Identifier_opt_ `;'


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 128 The break Statement

230.2 Semantics
===============

A program is considered syntactically incorrect if either of the
following is true:

   * The program contains a `break' statement without the optional
     Identifier, which is not nested, directly or indirectly (but not
     crossing function boundaries), within an IterationStatement or a
     SwitchStatement.

   * The program contains a `break' statement with the optional
     Identifier, where Identifier does not appear in the label set of
     an enclosing (but not crossing function boundaries) Statement.

   A BreakStatement without an Identifier is evaluated as follows:

  1. Return (break, empty, empty).

   A BreakStatement with an Identifier is evaluated as follows:

  1. Return (break, empty, Identifier).


File: javascript_ecma_262_5th_ed.info,  Node: 129 The return Statement,  Next: 1210 The with Statement,  Prev: 128 The break Statement,  Up: Top

231 12.9 (#sec-12.9) The `return' Statement
*******************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 129 The return Statement

231.1 Syntax
============

ReturnStatement : `return' [no LineTerminator here]
(#def-restricted-production) Expression_opt_ `;'


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 129 The return Statement

231.2 Semantics
===============

An ECMAScript program is considered syntactically incorrect if it
contains a `return' statement that is not within a FunctionBody. A
`return' statement causes a function to cease execution and return a
value to the caller. If Expression is omitted, the return value is
undefined. Otherwise, the return value is the value of Expression.

   The production ReturnStatement : `return' [no LineTerminator here]
(#def-restricted-production) Expression_opt_ `;' is evaluated as:

  1. If the Expression is not present, return (return, undefined,
     empty).

  2. Let exprRef be the result of evaluating Expression.

  3. Return (return, GetValue (#sec-8.7.1)(exprRef), empty).


File: javascript_ecma_262_5th_ed.info,  Node: 1210 The with Statement,  Next: 12101 Strict Mode Restrictions,  Prev: 129 The return Statement,  Up: Top

232 12.10 (#sec-12.10) The `with' Statement
*******************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1210 The with Statement

232.1 Syntax
============

WithStatement : `with' `(' Expression `)' Statement The `with'
statement adds an object environment record for a computed object to
the lexical environment (#sec-10.2) of the current execution context.
It then executes a statement using this augmented lexical environment.
Finally, it restores the original lexical environment.


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1210 The with Statement

232.2 Semantics
===============

The production WithStatement : `with' `(' Expression `)' Statement is
evaluated as follows:

  1. Let val be the result of evaluating Expression.

  2. Let obj be ToObject (#sec-9.9)(GetValue (#sec-8.7.1)(val)).

  3. Let oldEnv be the running execution context’s LexicalEnvironment.

  4. Let newEnv be the result of calling NewObjectEnvironment
     (#sec-10.2.2.3) passing obj and oldEnv as the arguments.

  5. Set the provideThis flag of newEnv to true.

  6. Set the running execution context’s LexicalEnvironment to newEnv.

  7. Let C be the result of evaluating Statement but if an exception is
     thrown during the evaluation, let C be (throw, V, empty), where V
     is the exception. (Execution now proceeds as if no exception were
     thrown.)

  8. Set the running execution context’s Lexical Environment
     (#sec-10.2) to oldEnv.

  9. Return C.

   NOTE No matter how control leaves the embedded Statement, whether
normally or by some form of abrupt completion (#sec-8.9) or exception,
the LexicalEnvironment is always restored to its former state.


File: javascript_ecma_262_5th_ed.info,  Node: 12101 Strict Mode Restrictions,  Next: 1211 The switch Statement,  Prev: 1210 The with Statement,  Up: Top

233 12.10.1 (#sec-12.10.1) Strict Mode Restrictions
***************************************************

Strict mode code (#sec-10.1.1) may not include a WithStatement. The
occurrence of a WithStatement in such a context is treated as a
SyntaxError.


File: javascript_ecma_262_5th_ed.info,  Node: 1211 The switch Statement,  Next: 1212 Labelled Statements,  Prev: 12101 Strict Mode Restrictions,  Up: Top

234 12.11 (#sec-12.11) The `switch' Statement
*********************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1211 The switch Statement

234.1 Syntax
============

SwitchStatement : `switch' `(' Expression `)' CaseBlock CaseBlock : `{'
CaseClauses_opt_ `}' `{' CaseClauses_opt_ DefaultClause
CaseClauses_opt_ `}'

   CaseClauses : CaseClause CaseClauses CaseClause CaseClause : `case'
Expression `:' StatementList_opt_ DefaultClause : `default' `:'
StatementList_opt_


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1211 The switch Statement

234.2 Semantics
===============

The production SwitchStatement : `switch' `(' Expression `)' CaseBlock
is evaluated as follows:

  1. Let exprRef be the result of evaluating Expression.

  2. Let R be the result of evaluating CaseBlock, passing it GetValue
     (#sec-8.7.1)(exprRef) as a parameter.

  3. If R.type is break and R.target is in the current label set,
     return (normal, R.value, empty).

  4. Return R.

   The production CaseBlock : `{' CaseClauses_opt_ `}' is given an
input parameter, input, and is evaluated as follows:

  1. Let V = empty.

  2. Let A be the list of CaseClause items in source text order.

  3. Let searching be true.

  4. Repeat, while searching is true
       1. Let C be the next CaseClause in A. If there is no such
          CaseClause, return (normal, V, empty).

       2. Let clauseSelector be the result of evaluating C.

       3. If input is equal to clauseSelector as defined by the ===
          operator, then
            1. Set searching to false.

            2. If C has a StatementList, then
                 1. Evaluate C’s StatementList and let R be the
                    result.

                 2. If R is an abrupt completion (#sec-8.9), then
                    return R.

                 3. Let V = R.value.



  5. Repeat
       1. Let C be the next CaseClause in A. If there is no such
          CaseClause, return (normal, V, empty).

       2. If C has a StatementList, then
            1. Evaluate C’s StatementList and let R be the result.

            2. If R.value is not empty, then let V = R.value.

            3. If R is an abrupt completion (#sec-8.9), then return
               (R.type, V, R.target).



   The production CaseBlock : { CaseClauses_opt_ DefaultClause
CaseClauses_opt_ } is given an input parameter, input, and is evaluated
as follows:

  1. Let V = empty.

  2. Let A be the list of CaseClause items in the first CaseClauses, in
     source text order.

  3. Let B be the list of CaseClause items in the second CaseClauses,
     in source text order.

  4. Let found be false.

  5. Repeat letting C be in order each CaseClause in A
       1. If found is false, then
            1. Let clauseSelector be the result of evaluating C.

            2. If input is equal to clauseSelector as defined by the
               === operator, then set found to true.

       2. If found is true, then
            1. If C has a StatementList, then
                 1. Evaluate C’s StatementList and let R be the
                    result.

                 2. If R.value is not empty, then let V = R.value.

                 3. R is an abrupt completion (#sec-8.9), then return
                    (R.type, V, R.target).



  6. Let foundInB be false.

  7. If found is false, then
       1. Repeat, while foundInB is false and all elements of B have
          not been processed
            1.            2. Let clauseSelector be the result of evaluating C.

            3. If input is equal to clauseSelector as defined by the
               === operator, then
                 1. Set foundInB to true.

                 2. If C has a StatementList, then
                      1. Evaluate C’s StatementList and let R be the
                         result.

                      2. If R.value is not empty, then let V = R.value.

                      3. R is an abrupt completion (#sec-8.9), then
                         return (R.type, V, R.target).




  8. If foundInB is false and the DefaultClause has a StatementList,
     then
       1. Evaluate the DefaultClause’s StatementList and let R be the
          result.

       2. If R.value is not empty, then let V = R.value.

       3. If R is an abrupt completion (#sec-8.9), then return (R.type,
          V, R.target).

  9. Repeat (Note that if step 7.a.i has been performed this loop does
     not start at the beginning of B)
       1. Let C be the next CaseClause in B. If there is no such
          CaseClause, return (normal, V, empty).

       2. If C has a StatementList, then
            1. Evaluate C’s StatementList and let R be the result.

            2. If R.value is not empty, then let V = R.value.

            3. If R is an abrupt completion (#sec-8.9), then return
               (R.type, V, R.target).



   The production CaseClause : `case' Expression `:' StatementList_opt_
is evaluated as follows:

  1. Let exprRef be the result of evaluating Expression.

  2. Return GetValue (#sec-8.7.1)(exprRef).

   NOTE Evaluating CaseClause does not execute the associated
StatementList. It simply evaluates the Expression and returns the
value, which the CaseBlock algorithm uses to determine which
StatementList to start executing.


File: javascript_ecma_262_5th_ed.info,  Node: 1212 Labelled Statements,  Next: 1213 The throw Statement,  Prev: 1211 The switch Statement,  Up: Top

235 12.12 (#sec-12.12) Labelled Statements
******************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1212 Labelled Statements

235.1 Syntax
============

LabelledStatement : Identifier `:' Statement


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1212 Labelled Statements

235.2 Semantics
===============

A Statement may be prefixed by a label. Labelled statements are only
used in conjunction with labelled `break' and `continue' statements.
ECMAScript has no `goto' statement.

   An ECMAScript program is considered syntactically incorrect if it
contains a LabelledStatement that is enclosed by a LabelledStatement
with the same Identifier as label. This does not apply to labels
appearing within the body of a FunctionDeclaration that is nested,
directly or indirectly, within a labelled statement.

   The production Identifier `:' Statement is evaluated by adding
Identifier to the label set of Statement and then evaluating Statement.
If the LabelledStatement itself has a non-empty label set, these labels
are also added to the label set of Statement before evaluating it. If
the result of evaluating Statement is (break, V, L) where L is equal to
Identifier, the production results in (normal, V, empty).

   Prior to the evaluation of a LabelledStatement, the contained
Statement is regarded as possessing an empty label set, unless it is an
IterationStatement or a SwitchStatement, in which case it is regarded
as possessing a label set consisting of the single element, empty.


File: javascript_ecma_262_5th_ed.info,  Node: 1213 The throw Statement,  Next: 1214 The try Statement,  Prev: 1212 Labelled Statements,  Up: Top

236 12.13 (#sec-12.13) The `throw' Statement
********************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1213 The throw Statement

236.1 Syntax
============

ThrowStatement : `throw' [no LineTerminator here]
(#def-restricted-production) Expression `;'


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1213 The throw Statement

236.2 Semantics
===============

The production ThrowStatement : `throw' [no LineTerminator here]
(#def-restricted-production) Expression `;' is evaluated as:

  1. Let exprRef be the result of evaluating Expression.

  2. Return (throw, GetValue (#sec-8.7.1)(exprRef), empty).


File: javascript_ecma_262_5th_ed.info,  Node: 1214 The try Statement,  Next: 12141 Strict Mode Restrictions,  Prev: 1213 The throw Statement,  Up: Top

237 12.14 (#sec-12.14) The `try' Statement
******************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1214 The try Statement

237.1 Syntax
============

TryStatement : `try' Block Catch `try' Block Finally `try' Block Catch
Finally Catch : `catch' `(' Identifier `)' Block Finally : `finally'
Block The `try' statement encloses a block of code in which an
exceptional condition can occur, such as a runtime error or a `throw'
statement. The `catch' clause provides the exception-handling code.
When a catch clause catches an exception, its Identifier is bound to
that exception.


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1214 The try Statement

237.2 Semantics
===============

The production TryStatement : `try' Block Catch is evaluated as follows:

  1. Let B be the result of evaluating Block.

  2. If B.type is not throw, return B.

  3. Return the result of evaluating Catch with parameter B.

   The production TryStatement : `try' Block Finally is evaluated as
follows:

  1. Let B be the result of evaluating Block.

  2. Let F be the result of evaluating Finally.

  3. If F.type is normal, return B.

  4. Return F.

   The production TryStatement : `try' Block Catch Finally is evaluated
as follows:

  1. Let B be the result of evaluating Block.

  2. If B.type is throw, then
       1. Let C be the result of evaluating Catch with parameter B.

  3. Else, B.type is not throw,
       1. Let C be B.

  4. Let F be the result of evaluating Finally.

  5. If F.type is normal, return C.

  6. Return F.

   The production Catch : `catch' `(' Identifier `)' Block is evaluated
as follows:

  1. Let C be the parameter that has been passed to this production.

  2. Let oldEnv be the running execution context’s LexicalEnvironment.

  3. Let catchEnv be the result of calling NewDeclarativeEnvironment
     (#sec-10.2.2.2) passing oldEnv as the argument.

  4. Call the CreateMutableBinding concrete method of catchEnv passing
     the Identifier String value as the argument.

  5. Call the SetMutableBinding concrete method of catchEnv passing the
     Identifier, C, and false as arguments. Note that the last argument
     is immaterial in this situation.

  6. Set the running execution context’s LexicalEnvironment to
     catchEnv.

  7. Let B be the result of evaluating Block.

  8. Set the running execution context’s LexicalEnvironment to oldEnv.

  9. Return B.

   NOTE No matter how control leaves the Block the LexicalEnvironment
is always restored to its former state.

   The production Finally : `finally' Block is evaluated as follows:

  1. Return the result of evaluating Block.


File: javascript_ecma_262_5th_ed.info,  Node: 12141 Strict Mode Restrictions,  Next: 1215 The debugger statement,  Prev: 1214 The try Statement,  Up: Top

238 12.14.1 (#sec-12.14.1) Strict Mode Restrictions
***************************************************

It is a SyntaxError if a TryStatement with a Catch occurs within strict
code (#sec-10.1.1) and the Identifier of the Catch production is either
"eval" or "arguments".


File: javascript_ecma_262_5th_ed.info,  Node: 1215 The debugger statement,  Next: 13 Function Definition,  Prev: 12141 Strict Mode Restrictions,  Up: Top

239 12.15 (#sec-12.15) The `debugger' statement
***********************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 1215 The debugger statement

239.1 Syntax
============

DebuggerStatement : debugger `;'


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 1215 The debugger statement

239.2 Semantics
===============

Evaluating the DebuggerStatement production may allow an implementation
to cause a breakpoint when run under a debugger. If a debugger is not
present or active this statement has no observable effect.

   The production DebuggerStatement : `debugger' `;' is evaluated as
follows:

  1. If an implementation defined debugging facility is available and
     enabled, then
       1. Perform an implementation defined debugging action.

       2. Let result be an implementation defined Completion (#sec-8.9)
          value.

  2. Else
       1. Let result be (normal, empty, empty).

  3. Return result.


File: javascript_ecma_262_5th_ed.info,  Node: 13 Function Definition,  Next: 131 Strict Mode Restrictions,  Prev: 1215 The debugger statement,  Up: Top

240 13 (#sec-13) Function Definition
************************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 13 Function Definition

240.1 Syntax
============

FunctionDeclaration : `function' Identifier `('
FormalParameterList_opt_ `)' `{' FunctionBody `}' FunctionExpression :
`function' Identifier_opt_ `(' FormalParameterList_opt_ `)' `{'
FunctionBody `}' FormalParameterList : Identifier FormalParameterList
`,' Identifier FunctionBody : SourceElements_opt_


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 13 Function Definition

240.2 Semantics
===============

The production FunctionDeclaration : `function' Identifier `('
FormalParameterList_opt_ `)' `{' FunctionBody `}' is instantiated as
follows during Declaration Binding instantiation (10.5) (#sec-10.5):

   Return the result of creating a new Function object as specified in
13.2 (#sec-13.2) with parameters specified by FormalParameterList sub
class="gopt">opt, and body specified by FunctionBody. Pass in the
VariableEnvironment of the running execution context as the Scope. Pass
in true as the Strict flag if the FunctionDeclaration is contained in
strict code (#sec-10.1.1) or if its FunctionBody is strict code
(#sec-10.1.1).  The production FunctionExpression : `function' `('
FormalParameterList_opt_ `)' `{' FunctionBody `}' is evaluated as
follows:

  1. Return the result of creating a new Function object as specified
     in 13.2 (#sec-13.2) with parameters specified by
     FormalParameterList_opt_ and body specified by FunctionBody. Pass
     in the LexicalEnvironment of the running execution context as the
     Scope. Pass in true as the Strict flag if the FunctionExpression
     is contained in strict code (#sec-10.1.1) or if its FunctionBody
     is strict code (#sec-10.1.1).

   The production FunctionExpression : `function' Identifier `('
FormalParameterList_opt_ `)' `{' FunctionBody `}' is evaluated as
follows:

  1. Let funcEnv be the result of calling NewDeclarativeEnvironment
     (#sec-10.2.2.2) passing the running execution context’s Lexical
     Environment (#sec-10.2) as the argument

  2. Let envRec be funcEnv’s environment record.

  3. Call the CreateImmutableBinding(N) (#sec-10.2.1.1.7) concrete
     method of envRec passing the String value of Identifier as the
     argument.

  4. Let closure be the result of creating a new Function object as
     specified in 13.2 (#sec-13.2) with parameters specified by
     FormalParameterList_opt_ and body specified by FunctionBody. Pass
     in funcEnv as the Scope. Pass in true as the Strict flag if the
     FunctionExpression is contained in strict code (#sec-10.1.1) or if
     its FunctionBody is strict code (#sec-10.1.1).

  5. Call the InitializeImmutableBinding(N, V) (#sec-10.2.1.1.8)
     concrete method of envRec passing the String value of Identifier
     and closure as the arguments.

  6. Return closure.

   NOTE The Identifier in a FunctionExpression can be referenced from
inside the FunctionExpression’s FunctionBody to allow the function to
call itself recursively. However, unlike in a FunctionDeclaration, the
Identifier in a FunctionExpression cannot be referenced from and does
not affect the scope enclosing the FunctionExpression.

   The production FunctionBody : SourceElements_opt_ is evaluated as
follows:

  1. The code of this FunctionBody is strict mode code (#sec-10.1.1) if
     it is part of a FunctionDeclaration or FunctionExpression that is
     contained in strict mode code (#sec-10.1.1) or if the Directive
     Prologue (14.1 (#sec-14.1)) of its SourceElements contains a Use
     Strict Directive or if any of the conditions in 10.1.1
     (#sec-10.1.1) apply. If the code of this FunctionBody is strict
     mode code (#sec-10.1.1), SourceElements is evaluated in the
     following steps as strict mode code (#sec-10.1.1). Otherwise,
     SourceElements is evaluated in the following steps as non-strict
     mode code.

  2. If SourceElements is present return the result of evaluating
     SourceElements.

  3. Else return (normal, undefined, empty).


File: javascript_ecma_262_5th_ed.info,  Node: 131 Strict Mode Restrictions,  Next: 132 Creating Function Objects,  Prev: 13 Function Definition,  Up: Top

241 13.1 (#sec-13.1) Strict Mode Restrictions
*********************************************

It is a SyntaxError if any Identifier value occurs more than once
within a FormalParameterList of a strict mode FunctionDeclaration or
FunctionExpression.

   It is a SyntaxError if the Identifier "eval" or the Identifier
"arguments" occurs within a FormalParameterList of a strict mode
FunctionDeclaration or FunctionExpression.


File: javascript_ecma_262_5th_ed.info,  Node: 132 Creating Function Objects,  Next: 1321 [[Call]],  Prev: 131 Strict Mode Restrictions,  Up: Top

242 13.2 (#sec-13.2) Creating Function Objects
**********************************************

Given an optional parameter list specified by FormalParameterList, a
body specified by FunctionBody, a Lexical Environment (#sec-10.2)
specified by Scope, and a Boolean flag Strict, a Function object is
constructed as follows:

  1. Create a new native ECMAScript object and let F be that object.

  2. Set all the internal methods, except for [[Get]], of F as
     described in 8.12 (#sec-8.12).

  3. Set the [[Class]] internal property of F to "Function".

  4. Set the [[Prototype]] internal property of F to the standard
     built-in Function prototype object as specified in 15.3.3.1
     (#sec-15.3.3.1).

  5. Set the [[Get]] internal property of F as described in 15.3.5.4
     (#sec-15.3.5.4).

  6. Set the [[Call]] internal property of F as described in 13.2.1
     (#sec-13.2.1).

  7. Set the [[Construct]] internal property of F as described in
     13.2.2 (#sec-13.2.2).

  8. Set the [[HasInstance]] internal property of F as described in
     15.3.5.3 (#sec-15.3.5.3).

  9. Set the [[Scope]] internal property of F to the value of Scope.

 10. Let names be a List (#sec-8.8) containing, in left to right
     textual order, the Strings corresponding to the identifiers of
     FormalParameterList.

 11. Set the [[FormalParameters]] internal property of F to names.

 12. Set the [[Code]] internal property of F to FunctionBody.

 13. Set the [[Extensible]] internal property of F to true.

 14. Let len be the number of formal parameters specified in
     FormalParameterList. If no parameters are specified, let len be 0.

 15. Call the [[DefineOwnProperty]] internal method of F with arguments
     "length", Property Descriptor (#sec-8.10) {[[Value]]: len,
     [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]:
     false}, and false.

 16. Let proto be the result of creating a new object as would be
     constructed by the expression `new Object()' where Object is the
     standard built-in constructor with that name (#sec-15.2).

 17. Call the [[DefineOwnProperty]] internal method of proto with
     arguments "constructor", Property Descriptor (#sec-8.10)
     {[[Value]]: F, { [[Writable]]: true, [[Enumerable]]: false,
     [[Configurable]]: true}, and false.

 18. Call the [[DefineOwnProperty]] internal method of F with arguments
     "prototype", Property Descriptor (#sec-8.10) {[[Value]]: proto, {
     [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]:
     false}, and false.

 19. If Strict is true, then
       1. Let thrower be the [[ThrowTypeError]] function Object (13.2.3
          (#sec-13.2.3)).

       2. Call the [[DefineOwnProperty]] internal method of F with
          arguments "caller", PropertyDescriptor {[[Get]]: thrower,
          [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]:
          false}, and false.

       3. Call the [[DefineOwnProperty]] internal method of F with
          arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
          [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]:
          false}, and false.

 20. Return F.

   NOTE A `prototype' property is automatically created for every
function, to allow for the possibility that the function will be used
as a constructor.


File: javascript_ecma_262_5th_ed.info,  Node: 1321 [[Call]],  Next: 1322 [[Construct]],  Prev: 132 Creating Function Objects,  Up: Top

243 13.2.1 (#sec-13.2.1) [[Call]]
*********************************

When the [[Call]] internal method for a Function object F is called
with a this value and a list of arguments, the following steps are
taken:

  1. Let funcCtx be the result of establishing a new execution context
     for function code using the value of F’s [[FormalParameters]]
     internal property, the passed arguments List (#sec-8.8) args, and
     the this value as described in 10.4.3 (#sec-10.4.3).

  2. Let result be the result of evaluating the FunctionBody that is
     the value of F’s [[Code]] internal property. If F does not have
     a [[Code]] internal property or if its value is an empty
     FunctionBody, then result is (normal, undefined, empty).

  3. Exit the execution context funcCtx, restoring the previous
     execution context.

  4. If result.type is throw then throw result.value.

  5. If result.type is return then return result.value.

  6. Otherwise result.type must be normal. Return undefined.


File: javascript_ecma_262_5th_ed.info,  Node: 1322 [[Construct]],  Next: 1323 The [[ThrowTypeError]] Function Object,  Prev: 1321 [[Call]],  Up: Top

244 13.2.2 (#sec-13.2.2) [[Construct]]
**************************************

When the [[Construct]] internal method for a Function object F is
called with a possibly empty list of arguments, the following steps are
taken:

  1. Let obj be a newly created native ECMAScript object.

  2. Set all the internal methods of obj as specified in 8.12
     (#sec-8.12).

  3. Set the [[Class]] internal property of obj to "Object".

  4. Set the [[Extensible]] internal property of obj to true.

  5. Let proto be the value of calling the [[Get]] internal property of
     F with argument "prototype".

  6. If Type (#def-type)(proto) is Object, set the [[Prototype]]
     internal property of obj to proto.

  7. If Type (#def-type)(proto) is not Object, set the [[Prototype]]
     internal property of obj to the standard built-in Object prototype
     object as described in 15.2.4 (#sec-15.2.4).

  8. Let result be the result of calling the [[Call]] internal property
     of F, providing obj as the this value and providing the argument
     list passed into [[Construct]] as args.

  9. If Type (#def-type)(result) is Object then return result.

 10. Return obj.


File: javascript_ecma_262_5th_ed.info,  Node: 1323 The [[ThrowTypeError]] Function Object,  Next: 14 Program,  Prev: 1322 [[Construct]],  Up: Top

245 13.2.3 (#sec-13.2.3) The [[ThrowTypeError]] Function Object
***************************************************************

  1. The [[ThrowTypeError]] object is a unique function object that is
     defined once as follows:

  2. Create a new native ECMAScript object and let F be that object.

  3. Set all the internal methods of F as described in 8.12 (#sec-8.12).

  4. Set the [[Class]] internal property of F to "Function".

  5. Set the [[Prototype]] internal property of F to the standard
     built-in Function prototype object as specified in 15.3.3.1
     (#sec-15.3.3.1).

  6. Set the [[Call]] internal property of F as described in 13.2.1
     (#sec-13.2.1).

  7. Set the [[Scope]] internal property of F to the Global Environment.

  8. Set the [[FormalParameters]] internal property of F to an empty
     List (#sec-8.8).

  9. Set the [[Code]] internal property of F to be a FunctionBody that
     unconditionally throws a TypeError exception and performs no other
     action.

 10. Call the [[DefineOwnProperty]] internal method of F with arguments
     "length", Property Descriptor (#sec-8.10) {[[Value]]: 0,
     [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]:
     false}, and false.

 11. Set the [[Extensible]] internal property of F to false.

 12. Let [[ThrowTypeError]] be F.


File: javascript_ecma_262_5th_ed.info,  Node: 14 Program,  Next: 141 Directive Prologues and the Use Strict Directive,  Prev: 1323 The [[ThrowTypeError]] Function Object,  Up: Top

246 14 (#sec-14) Program
************************

* Menu:

* Syntax::
* Semantics::


File: javascript_ecma_262_5th_ed.info,  Node: Syntax,  Next: Semantics,  Up: 14 Program

246.1 Syntax
============

Program : SourceElements_opt_ SourceElements : SourceElement
SourceElements SourceElement SourceElement : Statement
FunctionDeclaration


File: javascript_ecma_262_5th_ed.info,  Node: Semantics,  Prev: Syntax,  Up: 14 Program

246.2 Semantics
===============

The production Program : SourceElements_opt_ is evaluated as follows:

  1. The code of this Program is strict mode code (#sec-10.1.1) if the
     Directive Prologue (14.1 (#sec-14.1)) of its SourceElements
     contains a Use Strict Directive or if any of the conditions of
     10.1.1 (#sec-10.1.1) apply. If the code of this Program is strict
     mode code (#sec-10.1.1), SourceElements is evaluated in the
     following steps as strict mode code (#sec-10.1.1). Otherwise
     SourceElements is evaluated in the following steps as non-strict
     mode code.

  2. If SourceElements is not present, return (normal, empty, empty).

  3. Let progCxt be a new execution context for global code
     (#def-global-code) as described in 10.4.1 (#sec-10.4.1).

  4. Let result be the result of evaluating SourceElements.

  5. Exit the execution context progCxt.

  6. Return result.

   NOTE The processes for initiating the evaluation of a Program and
for dealing with the result of such an evaluation are defined by an
ECMAScript implementation and not by this specification.

   The production SourceElements : SourceElements SourceElement is
evaluated as follows:

  1. Let headResult be the result of evaluating SourceElements.

  2. If headResult is an abrupt completion (#sec-8.9), return
     headResult.

  3. Let tailResult be result of evaluating SourceElement.

  4. If tailResult.value is empty, let V = headResult.value, otherwise
     let V = tailResult.value.

  5. Return (tailResult.type, V, tailResult.target).

   The production SourceElement : Statement is evaluated as follows:

  1. Return the result of evaluating Statement.

   The production SourceElement : FunctionDeclaration is evaluated as
follows:

  1. Return (normal, empty, empty).


File: javascript_ecma_262_5th_ed.info,  Node: 141 Directive Prologues and the Use Strict Directive,  Next: 15 Standard Built-in ECMAScript Objects,  Prev: 14 Program,  Up: Top

247 14.1 (#sec-14.1) Directive Prologues and the Use Strict Directive
*********************************************************************

A Directive Prologue is the longest sequence of ExpressionStatement
productions occurring as the initial SourceElement productions of a
Program or FunctionBody and where each ExpressionStatement in the
sequence consists entirely of a StringLiteral token followed a
semicolon. The semicolon may appear explicitly or may be inserted by
automatic semicolon insertion. A Directive Prologue may be an empty
sequence.

   A Use Strict Directive is an ExpressionStatement in a Directive
Prologue whose StringLiteral is either the exact character sequences
`"use strict"' or `'use strict''. A Use Strict Directive may not
contain an EscapeSequence or LineContinuation.

   A Directive Prologue may contain more than one Use Strict Directive.
However, an implementation may issue a warning if this occurs.

   NOTE The ExpressionStatement productions of a Directive Prologue are
evaluated normally during evaluation of the containing SourceElements
production. Implementations may define implementation specific meanings
for ExpressionStatement productions which are not a Use Strict
Directive and which occur in a Directive Prologue. If an appropriate
notification mechanism exists, an implementation should issue a warning
if it encounters in a Directive Prologue an ExpressionStatement that is
not a Use Strict Directive or which does not have a meaning defined by
the implementation.


File: javascript_ecma_262_5th_ed.info,  Node: 15 Standard Built-in ECMAScript Objects,  Next: 151 The Global Object,  Prev: 141 Directive Prologues and the Use Strict Directive,  Up: Top

248 15 (#sec-15) Standard Built-in ECMAScript Objects
*****************************************************

There are certain built-in objects available whenever an ECMAScript
program begins execution. One, the global object (#sec-15.1), is part
of the lexical environment (#sec-10.2) of the executing program. Others
are accessible as initial properties of the global object.

   Unless specified otherwise, the [[Class]] internal property of a
built-in object is "Function" if that built-in object has a [[Call]]
internal property, or "Object" if that built-in object does not have a
[[Call]] internal property. Unless specified otherwise, the
[[Extensible]] internal property of a built-in object initially has the
value true.

   Many built-in objects are functions: they can be invoked with
arguments. Some of them furthermore are constructors: they are
functions intended for use with the `new' operator. For each built-in
function, this

   Unless otherwise specified in the description of a particular
function, if a function or constructor described in this clause is
given fewer arguments than the function is specified to require, the
function or constructor shall behave exactly as if it had been given
sufficient additional arguments, each such argument being the undefined
value.

   Unless otherwise specified in the description of a particular
function, if a function or constructor described in this clause is
given more arguments than the function is specified to allow, the extra
arguments are evaluated by the call and then ignored by the function.
However, an implementation may define implementation specific behaviour
relating to such arguments as long as the behaviour is not the throwing
of a TypeError exception that is predicated simply on the presence of
an extra argument.

   NOTE Implementations that add additional capabilities to the set of
built-in functions are encouraged to do so by adding new functions
rather than adding new parameters to existing functions.

   Every built-in function and every built-in constructor has the
Function prototype object (#sec-15.3.4), which is the initial value of
the expression `Function.prototype' (15.3.4 (#sec-15.3.4)), as the
value of its [[Prototype]] internal property.

   Unless otherwise specified every built-in prototype object has the
Object prototype object, which is the initial value of the expression
`Object.prototype' (15.2.4 (#sec-15.2.4)), as the value of its
[[Prototype]] internal property, except the Object prototype object
itself.

   None of the built-in functions described in this clause that are not
constructors shall implement the [[Construct]] internal method unless
otherwise specified in the description of a particular function. None
of the built-in functions described in this clause shall have a
`prototype' property unless otherwise specified in the description of a
particular function.

   This clause generally describes distinct behaviours for when a
constructor is “called as a function” and for when it is “called
as part of a `new' expression”. The “called as a function”
behaviour corresponds to the invocation of the constructor’s [[Call]]
internal method and the “called as part of a new expression”
behaviour corresponds to the invocation of the constructor’s
[[Construct]] internal method.

   Every built-in Function object described in this clause—whether as
a constructor, an ordinary function, or both—has a `length' property
whose value is an integer. Unless otherwise specified, this value is
equal to the largest number of named arguments shown in the subclause
headings for the function description, including optional parameters.

   NOTE For example, the Function object that is the initial value of
the `slice' property of the String prototype object is described under
the subclause heading “String.prototype.slice (start, end)” which
shows the two named arguments start and end; therefore the value of the
`length' property of that Function object is 2.

   In every case, the `length' property of a built-in Function object
described in this clause has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: false }. Every other property
described in this clause has the attributes { [[Writable]]: true,
[[Enumerable]]: false, [[Configurable]]: true } unless otherwise
specified.


File: javascript_ecma_262_5th_ed.info,  Node: 151 The Global Object,  Next: 1511 Value Properties of the Global Object,  Prev: 15 Standard Built-in ECMAScript Objects,  Up: Top

249 15.1 (#sec-15.1) The Global Object
**************************************

The unique global object is created before control enters any execution
context.

   Unless otherwise specified, the standard built-in properties of the
global object have attributes {[[Writable]]: true, [[Enumerable]]:
false, [[Configurable]]: true}.

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

   The values of the [[Prototype]] and [[Class]] internal properties of
the global object are implementation-dependent.

   In addition to the properties defined in this specification the
global object may have additional host defined properties. This may
include a property whose value is the global object itself; for
example, in the HTML document object model the `window' property of the
global object is the global object itself.


File: javascript_ecma_262_5th_ed.info,  Node: 1511 Value Properties of the Global Object,  Next: 15111 NaN,  Prev: 151 The Global Object,  Up: Top

250 15.1.1 (#sec-15.1.1) Value Properties of the Global Object
**************************************************************


File: javascript_ecma_262_5th_ed.info,  Node: 15111 NaN,  Next: 15112 Infinity,  Prev: 1511 Value Properties of the Global Object,  Up: Top

251 15.1.1.1 (#sec-15.1.1.1) NaN
********************************

The value of NaN is NaN (see 8.5 (#sec-8.5)). This property has the
attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 15112 Infinity,  Next: 15113 undefined,  Prev: 15111 NaN,  Up: Top

252 15.1.1.2 (#sec-15.1.1.2) Infinity
*************************************

The value of Infinity is +∞ (see 8.5 (#sec-8.5)). This property has
the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 15113 undefined,  Next: 1512 Function Properties of the Global Object,  Prev: 15112 Infinity,  Up: Top

253 15.1.1.3 (#sec-15.1.1.3) undefined
**************************************

The value of undefined is undefined (see 8.1 (#sec-8.1)). This property
has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 1512 Function Properties of the Global Object,  Next: 15121 eval x,  Prev: 15113 undefined,  Up: Top

254 15.1.2 (#sec-15.1.2) Function Properties of the Global Object
*****************************************************************


File: javascript_ecma_262_5th_ed.info,  Node: 15121 eval x,  Next: 151211 Direct Call to Eval,  Prev: 1512 Function Properties of the Global Object,  Up: Top

255 15.1.2.1 (#sec-15.1.2.1) eval (x)
*************************************

When the eval function is called with one argument x, the following
steps are taken:

  1. If Type (#def-type)(x) is not String, return x.

  2. Let prog be the ECMAScript code that is the result of parsing x as
     a Program. If the parse fails, throw a SyntaxError exception (but
     see also clause 16 (#sec-16)).

  3. Let evalCtx be the result of establishing a new execution context
     (10.4.2 (#sec-10.4.2)) for the eval code (#def-eval-code) prog.

  4. Let result be the result of evaluating the program prog.

  5. Exit the running execution context evalCtx, restoring the previous
     execution context.

  6. If result.type is normal and its completion value is a value V,
     then return the value V.

  7. If result.type is normal and its completion value is empty, then
     return the value undefined.

  8. Otherwise, result.type must be throw. Throw result.value as an
     exception.


File: javascript_ecma_262_5th_ed.info,  Node: 151211 Direct Call to Eval,  Next: 15122 parseInt string radix,  Prev: 15121 eval x,  Up: Top

256 15.1.2.1.1 (#sec-15.1.2.1.1) Direct Call to Eval
****************************************************

A direct call to the eval function is one that is expressed as a
CallExpression that meets the following two conditions:

   The Reference (#sec-8.7) that is the result of evaluating the
MemberExpression in the CallExpression has an environment record as its
base value and its reference name is "eval".

   The result of calling the abstract operation GetValue (#sec-8.7.1)
with that Reference (#sec-8.7) as the argument is the standard built-in
function defined in 15.1.2.1 (#sec-15.1.2.1).


File: javascript_ecma_262_5th_ed.info,  Node: 15122 parseInt string radix,  Next: 15123 parseFloatstring,  Prev: 151211 Direct Call to Eval,  Up: Top

257 15.1.2.2 (#sec-15.1.2.2) parseInt (string , radix)
******************************************************

The parseInt function produces an integer value dictated by
interpretation of the contents of the string argument according to the
specified radix. Leading white space in string is ignored. If radix is
undefined or 0, it is assumed to be 10 except when the number begins
with the character pairs `0x' or `0X', in which case a radix of 16 is
assumed. If radix is 16, the number may also optionally begin with the
character pairs `0x' or `0X'.

   When the parseInt function is called, the following steps are taken:

  1. Let inputString be ToString (#sec-9.8)(string).

  2. Let S be a newly created substring of inputString consisting of
     the first character that is not a StrWhiteSpaceChar and all
     characters following that character. (In other words, remove
     leading white space.)

  3. Let sign be 1.

  4. If S is not empty and the first character of S is a minus sign
     `-', let sign be −1.

  5. If S is not empty and the first character of S is a plus sign `+'
     or a minus sign `-', then remove the first character from S.

  6. Let R = ToInt32 (#sec-9.5)(radix).

  7. Let stripPrefix be true.

  8. If R ≠ 0, then
       1. If R < 2 or R > 36, then return NaN.

       2. If R 16, let stripPrefix be false.

  9. Else, R = 0
       1. Let R = 10.

 10. If stripPrefix is true, then
       1. If the length of S is at least 2 and the first two characters
          of S are either “`0x'” or “`0X'”, then remove the
          first two characters from S and let R = 16.

 11. If S contains any character that is not a radix-R digit, then let
     Z be the substring of S consisting of all characters before the
     first such character; otherwise, let Z be S.

 12. If Z is empty, return NaN.

 13. Let mathInt be the mathematical integer value that is represented
     by Z in radix-R notation, using the letters `A'–`Z' and
     `a'–`z' for digits with values 10 through 35. (However, if R is
     10 and Z contains more than 20 significant digits, every
     significant digit after the 20th may be replaced by a `0' digit,
     at the option of the implementation; and if R is not 2, 4, 8, 10,
     16, or 32, then mathInt may be an implementation-dependent
     approximation to the mathematical integer value that is
     represented by Z in radix-R notation.)

 14. Let number be the Number value for mathInt.

 15. Return sign × number.

   NOTE parseInt may interpret only a leading portion of string as an
integer value; it ignores any characters that cannot be interpreted as
part of the notation of an integer, and no indication is given that any
such characters were ignored.


File: javascript_ecma_262_5th_ed.info,  Node: 15123 parseFloatstring,  Next: 15124 isNaN number,  Prev: 15122 parseInt string radix,  Up: Top

258 15.1.2.3 (#sec-15.1.2.3) parseFloat(string)
***********************************************

The parseFloat function produces a Number value dictated by
interpretation of the contents of the string argument as a decimal
literal.

   When the parseFloat function is called, the following steps are
taken:

  1. Let inputString be ToString (#sec-9.8)(string).

  2. Let trimmedString be a substring of inputString consisting of the
     leftmost character that is not a StrWhiteSpaceChar and all
     characters to the right of that character.(In other words, remove
     leading white space.)

  3. If neither trimmedString nor any prefix of trimmedString satisfies
     the syntax of a StrDecimalLiteral (see 9.3.1 (#sec-9.3.1)), return
     NaN.

  4. Let numberString be the longest prefix of trimmedString, which
     might be trimmedString itself, that satisfies the syntax of a
     StrDecimalLiteral.

  5. Return the Number value for the MV of numberString.


File: javascript_ecma_262_5th_ed.info,  Node: 15124 isNaN number,  Next: 15125 isFinitenumber,  Prev: 15123 parseFloatstring,  Up: Top

259 15.1.2.4 (#sec-15.1.2.4) isNaN (number)
*******************************************

Returns true if the argument coerces to NaN, and otherwise returns
false.

  1. If ToNumber (#sec-9.3)(number) is NaN, return true.

  2. Otherwise, return false.

   NOTE A reliable way for ECMAScript code to test if a value X is a
NaN is an expression of the form `X !== X'. The result will be true if
and only if X is a NaN.


File: javascript_ecma_262_5th_ed.info,  Node: 15125 isFinitenumber,  Next: 1513 URI Handling Function Properties,  Prev: 15124 isNaN number,  Up: Top

260 15.1.2.5 (#sec-15.1.2.5) isFinite(number)
*********************************************

Returns false if the argument coerces to NaN, +∞, or −∞, and
otherwise returns true.

  1. If ToNumber (#sec-9.3)(number) is NaN, +∞, or −∞, return
     false.

  2. Otherwise, return true.


File: javascript_ecma_262_5th_ed.info,  Node: 1513 URI Handling Function Properties,  Next: 15131 decodeURI encodedURI,  Prev: 15125 isFinitenumber,  Up: Top

261 15.1.3 (#sec-15.1.3) URI Handling Function Properties
*********************************************************

Uniform Resource Identifiers, or URIs, are Strings that identify
resources (e.g. web pages or files) and transport protocols by which to
access them (e.g. HTTP or FTP) on the Internet. The ECMAScript language
itself does not provide any support for using URIs except for functions
that encode and decode URIs as described in 15.1.3.1 (#sec-15.1.3.1),
15.1.3.2 (#sec-15.1.3.2), 15.1.3.3 (#sec-15.1.3.3) and 15.1.3.4
(#sec-15.1.3.4).

   NOTE Many implementations of ECMAScript provide additional functions
and methods that manipulate web pages; these functions are beyond the
scope of this standard.

   A URI is composed of a sequence of components separated by component
separators. The general form is:

   Scheme `:' First `/' Second `;' Third `?' Fourth where the
italicised names represent components and “`:'”, “`/'”,
“`;'” and “`?'” are reserved characters used as separators. The
encodeURI (#sec-15.1.3.3) and decodeURI (#sec-15.1.3.1) functions are
intended to work with complete URIs; they assume that any reserved
characters in the URI are intended to have special meaning and so are
not encoded. The encodeURIComponent (#sec-15.1.3.4) and
decodeURIComponent (#sec-15.1.3.2) functions are intended to work with
the individual component parts of a URI; they assume that any reserved
characters represent text and so must be encoded so that they are not
interpreted as reserved characters when the component is part of a
complete URI.

   The following lexical grammar specifies the form of encoded URIs.

   uri ::: uriCharacters_opt_ uriCharacters ::: uriCharacter
uriCharacters_opt_ uriCharacter ::: uriReserved uriUnescaped uriEscaped
uriReserved ::: one of `;  /  ?  :  @  &  =  +  $  ,'

   uriUnescaped ::: uriAlpha DecimalDigit uriMark uriEscaped ::: `%'
HexDigit HexDigit uriAlpha ::: 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' uriMark ::: one of
`-  _  .  !  ~  *  ?  (  )' When a character to be included in a URI is
not listed above or is not intended to have the special meaning
sometimes given to the reserved characters, that character must be
encoded. The character is transformed into its UTF-8 encoding, with
surrogate pairs first converted from UTF-16 to the corresponding code
point value. (Note that for code units in the range [0,127] this
results in a single octet with the same value.) The resulting sequence
of octets is then transformed into a String with each octet represented
by an escape sequence of the form "%xx".

   The encoding and escaping process is described by the abstract
operation Encode taking two String arguments string and unescapedSet.

  1. Let strLen be the number of characters in string.

  2. Let R be the empty String.

  3. Let k be 0.

  4. Repeat
       1. If k equals strLen, return R.

       2. Let C be the character at position k within string.

       3. If C is in unescapedSet, then
            1. Let S be a String containing only the character C.

            2. Let R be a new String value computed by concatenating
               the previous value of R and S.

       4. Else, C is not in unescapedSet
            1. If the code unit value of C is not less than 0xDC00 and
               not greater than 0xDFFF, throw a URIError exception.

            2. If the code unit value of C is less than 0xD800 or
               greater than 0xDBFF, then
                 1. Let V be the code unit value of C.

            3. Else,
                 1. Increase k by 1.

                 2. If k equals strLen, throw a URIError exception.

                 3. Let kChar be the code unit value of the character
                    at position k within string.

                 4. If kChar is less than 0xDC00 or greater than
                    0xDFFF, throw a URIError exception.

                 5. Let V be (((the code unit value of C) − 0xD800)
                    × 0x400 + (kChar − 0xDC00) + 0x10000).

            4. Let Octets be the array of octets resulting by applying
               the UTF-8 transformation to V, and let L be the array
               size.

            5. Let j be 0.

            6. Repeat, while j < L
                 1. Let jOctet be the value at position j within Octets.

                 2. Let S be a String containing three characters "%XY"
                    where XY are two uppercase hexadecimal digits
                    encoding the value of jOctet.

                 3. Let R be a new String value computed by
                    concatenating the previous value of R and S.

                 4. Increase j by 1.


       5. Increase k by 1.


  1. Let strLen be the number of characters in string.

  2. Let R be the empty String.

  3. Let k be 0.

  4. Repeat
       1. If k equals strLen, return R.

       2. Let C be the character at position k within string.

       3. If C is not ‘`%'’, then
            1. Let S be the String containing only the character C.

       4. Else, C is ‘`%'’
            1. Let start be k.

            2. If k + 2 is greater than or equal to strLen, throw a
               URIError exception.

            3. If the characters at position (k+1) and (k + 2) within
               string do not represent hexadecimal digits, throw a
               URIError exception.

            4. Let B be the 8-bit value represented by the two
               hexadecimal digits at position (k + 1) and (k + 2).

            5. Increment k by 2.

            6. If the most significant bit in B is 0, then
                 1. Let C be the character with code unit value B.

                 2. If C is not in reservedSet, then
                      1. Let S be the String containing only the
                         character C.

                 3. Else, C is in reservedSet
                      1. Let S be the substring of string from position
                         start to position k included.


            7. Else, the most significant bit in B is 1
                 1. Let n be the smallest non-negative number such that
                    (B << n) & 0x80 is equal to 0.

                 2. If n equals 1 or n is greater than 4, throw a
                    URIError exception.

                 3. Let Octets be an array of 8-bit integers of size n.

                 4. Put B into Octets at position 0.

                 5. If k + (3 × (n − 1)) is greater than or equal to
                    strLen, throw a URIError exception.

                 6. Let j be 1.

                 7. Repeat, while j < n
                      1. Increment k by 1.

                      2. If the character at position k is not
                         ‘`%'’, throw a URIError exception.

                      3. If the characters at position (k + 1) and (k +
                         2) within string do not represent hexadecimal
                         digits, throw a URIError exception.

                      4. Let B be the 8-bit value represented by the
                         two hexadecimal digits at position (k + 1) and
                         (k + 2).

                      5. If the two most significant bits in B are not
                         10, throw a URIError exception.

                      6. Increment k by 2.

                      7. Put B into Octets at position j.

                      8. Increment j by 1.

                 8. Let V be the value obtained by applying the UTF-8
                    transformation to Octets, that is, from an array of
                    octets into a 32-bit value. If Octets does not
                    contain a valid UTF-8 encoding of a Unicode code
                    point throw a URIError exception.

                 9. If V is less than 0x10000, then
                      1. Let C be the character with code unit value V.

                      2. If C is not in reservedSet, then
                           1. Let S be the String containing only the
                              character C.

                      3. Else, C is in reservedSet
                           1. Let S be the substring of string from
                              position start to position k included.


                10. Else, V is ≥ 0x10000
                      1. If V is greater than 0x10FFFF, throw a
                         URIError exception.

                      2. Let L be (((V − 0x10000) & 0x3FF) + 0xDC00).

                      3. Let H be ((((V − 0x10000) >> 10) & 0x3FF) +
                         0xD800).

                      4. Let S be the String containing the two
                         characters with code unit values H and L.



       5.       6. Increase k by 1.


   NOTE The syntax of Uniform Resource Identifiers is given in RFC
2396. A formal description and implementation of UTF-8 is given in RFC
3629.

   In UTF-8, characters are encoded using sequences of 1 to 6 octets.
The only octet of a “sequence” of one has the higher-order bit set
to 0, the remaining 7 bits being used to encode the character value. In
a sequence of n octets, n>1, the initial octet has the n higher-order
bits set to 1, followed by a bit set to 0. The remaining bits of that
octet contain bits from the value of the character to be encoded. The
following octets all have the higher-order bit set to 1 and the
following bit set to 0, leaving 6 bits in each to contain bits from the
character to be encoded. The possible UTF-8 encodings of ECMAScript
characters are specified in Table 21.

   Table 21 — UTF-8 Encodings Code Unit Value Representation 1st Octet
2nd Octet 3rd Octet 4th Octet *0x0000 - 0x007F* *00000000* `0'zzzzzzz
`0'zzzzzzz *0x0080 - 0x07FF* *00000*yyy yyzzzzzz *110*yyyyy *10*zzzzzz
*0x0800 - 0xD7FF* xxxxyyyy yyzzzzzz *1110*xxxx *10*yyyyyy *10*zzzzzz
*0xD800 - 0xDBFF* _followed by_ *0xDC00 - 0xDFFF* *110110*vv vvwwwwxx
_followed by_ *110111*yy yyzzzzzz *11110*uuu *10*uuwwww *10*xxyyyy
*10*zzzzzz *0xD800 - 0xDBFF* _not followed by_ *0xDC00 - 0xDFFF*
_causes_ URIError *0xDC00 - 0xDFFF* _causes_ URIError *0xE000 - 0xFFFF*
xxxxyyyy yyzzzzzz *1110*xxxx *10*yyyyyy *10*zzzzzz Where

   uuuuu = vvvv + 1 to account for the addition of 0x10000 as in
Surrogates, section 3.7, of the Unicode Standard.

   The range of code unit values 0xD800-0xDFFF is used to encode
surrogate pairs; the above transformation combines a UTF-16 surrogate
pair into a UTF-32 representation and encodes the resulting 21-bit
value in UTF-8. Decoding reconstructs the surrogate pair.

   RFC 3629 prohibits the decoding of invalid UTF-8 octet sequences.
For example, the invalid sequence C0 80 must not decode into the
character U+0000. Implementations of the Decode algorithm are required
to throw a URIError when encountering such invalid sequences.


File: javascript_ecma_262_5th_ed.info,  Node: 15131 decodeURI encodedURI,  Next: 15132 decodeURIComponent encodedURIComponent,  Prev: 1513 URI Handling Function Properties,  Up: Top

262 15.1.3.1 (#sec-15.1.3.1) decodeURI (encodedURI)
***************************************************

The decodeURI function computes a new version of a URI in which each
escape sequence and UTF-8 encoding of the sort that might be introduced
by the encodeURI function is replaced with the character that it
represents. Escape sequences that could not have been introduced by
encodeURI are not replaced.

   When the decodeURI function is called with one argument encodedURI,
the following steps are taken:

  1. Let uriString be ToString (#sec-9.8)(encodedURI).

  2. Let reservedURISet be a String containing one instance of each
     character valid in uriReserved plus "#".

  3. Return the result of calling Decode(uriString, reservedURISet)

   NOTE The character “`#'” is not decoded from escape sequences
even though it is not a reserved URI character.


File: javascript_ecma_262_5th_ed.info,  Node: 15132 decodeURIComponent encodedURIComponent,  Next: 15133 encodeURI uri,  Prev: 15131 decodeURI encodedURI,  Up: Top

263 15.1.3.2 (#sec-15.1.3.2) decodeURIComponent (encodedURIComponent)
*********************************************************************

The decodeURIComponent function computes a new version of a URI in
which each escape sequence and UTF-8 encoding of the sort that might be
introduced by the encodeURIComponent function is replaced with the
character that it represents.

   When the decodeURIComponent function is called with one argument
encodedURIComponent, the following steps are taken:

  1. Let componentString be ToString (#sec-9.8)(encodedURIComponent).

  2. Let reservedURIComponentSet be the empty String.

  3. Return the result of calling Decode(componentString,
     reservedURIComponentSet)


File: javascript_ecma_262_5th_ed.info,  Node: 15133 encodeURI uri,  Next: 15134 encodeURIComponent uriComponent,  Prev: 15132 decodeURIComponent encodedURIComponent,  Up: Top

264 15.1.3.3 (#sec-15.1.3.3) encodeURI (uri)
********************************************

The encodeURI function computes a new version of a URI in which each
instance of certain characters is replaced by one, two or three escape
sequences representing the UTF-8 encoding of the character.

   When the encodeURI function is called with one argument uri, the
following steps are taken:

  1. Let uriString be ToString (#sec-9.8)(uri).

  2. Let unescapedURISet be a String containing one instance of each
     character valid in uriReserved and uriUnescaped plus "#".

  3. Return the result of calling Encode(uriString, unescapedURISet)

   NOTE The character “`#'” is not encoded to an escape sequence
even though it is not a reserved or unescaped URI character.


File: javascript_ecma_262_5th_ed.info,  Node: 15134 encodeURIComponent uriComponent,  Next: 1514 Constructor Properties of the Global Object,  Prev: 15133 encodeURI uri,  Up: Top

265 15.1.3.4 (#sec-15.1.3.4) encodeURIComponent (uriComponent)
**************************************************************

The encodeURIComponent function computes a new version of a URI in
which each instance of certain characters is replaced by one, two or
three escape sequences representing the UTF-8 encoding of the character.

   When the encodeURIComponent function is called with one argument
uriComponent, the following steps are taken:

  1. Let componentString be ToString (#sec-9.8)(uriComponent).

  2. Let unescapedURIComponentSet be a String containing one instance
     of each character valid in uriUnescaped.

  3. Return the result of calling Encode(componentString,
     unescapedURIComponentSet)


File: javascript_ecma_262_5th_ed.info,  Node: 1514 Constructor Properties of the Global Object,  Next: 15141 Object,  Prev: 15134 encodeURIComponent uriComponent,  Up: Top

266 15.1.4 (#sec-15.1.4) Constructor Properties of the Global Object
********************************************************************


File: javascript_ecma_262_5th_ed.info,  Node: 15141 Object,  Next: 15142 Function,  Prev: 1514 Constructor Properties of the Global Object,  Up: Top

267 15.1.4.1 (#sec-15.1.4.1) Object ( . . . )
*********************************************

See 15.2.1 (#sec-15.2.1) and 15.2.2 (#sec-15.2.2).


File: javascript_ecma_262_5th_ed.info,  Node: 15142 Function,  Next: 15143 Array,  Prev: 15141 Object,  Up: Top

268 15.1.4.2 (#sec-15.1.4.2) Function ( . . . )
***********************************************

See 15.3.1 (#sec-15.3.1) and 15.3.2 (#sec-15.3.2).


File: javascript_ecma_262_5th_ed.info,  Node: 15143 Array,  Next: 15144 String,  Prev: 15142 Function,  Up: Top

269 15.1.4.3 (#sec-15.1.4.3) Array ( . . . )
********************************************

See 15.4.1 (#sec-15.4.1) and 15.4.2 (#sec-15.4.2).


File: javascript_ecma_262_5th_ed.info,  Node: 15144 String,  Next: 15145 Boolean,  Prev: 15143 Array,  Up: Top

270 15.1.4.4 (#sec-15.1.4.4) String ( . . . )
*********************************************

See 15.5.1 (#sec-15.5.1) and 15.5.2 (#sec-15.5.2).


File: javascript_ecma_262_5th_ed.info,  Node: 15145 Boolean,  Next: 15146 Number,  Prev: 15144 String,  Up: Top

271 15.1.4.5 (#sec-15.1.4.5) Boolean ( . . . )
**********************************************

See 15.6.1 (#sec-15.6.1) and 15.6.2 (#sec-15.6.2).


File: javascript_ecma_262_5th_ed.info,  Node: 15146 Number,  Next: 15147 Date,  Prev: 15145 Boolean,  Up: Top

272 15.1.4.6 (#sec-15.1.4.6) Number ( . . . )
*********************************************

See 15.7.1 (#sec-15.7.1) and 15.7.2 (#sec-15.7.2).


File: javascript_ecma_262_5th_ed.info,  Node: 15147 Date,  Next: 15148 RegExp,  Prev: 15146 Number,  Up: Top

273 15.1.4.7 (#sec-15.1.4.7) Date ( . . . )
*******************************************

See 15.9.2 (#sec-15.9.2).


File: javascript_ecma_262_5th_ed.info,  Node: 15148 RegExp,  Next: 15149 Error,  Prev: 15147 Date,  Up: Top

274 15.1.4.8 (#sec-15.1.4.8) RegExp ( . . . )
*********************************************

See 15.10.3 (#sec-15.10.3) and 15.10.4 (#sec-15.10.4).


File: javascript_ecma_262_5th_ed.info,  Node: 15149 Error,  Next: 151410 EvalError,  Prev: 15148 RegExp,  Up: Top

275 15.1.4.9 (#sec-15.1.4.9) Error ( . . . )
********************************************

See 15.11.1 (#sec-15.11.1) and 15.11.2 (#sec-15.11.2).


File: javascript_ecma_262_5th_ed.info,  Node: 151410 EvalError,  Next: 151411 RangeError,  Prev: 15149 Error,  Up: Top

276 15.1.4.10 (#sec-15.1.4.10) EvalError ( . . . )
**************************************************

See 15.11.6.1 (#sec-15.11.6.1).


File: javascript_ecma_262_5th_ed.info,  Node: 151411 RangeError,  Next: 151412 ReferenceError,  Prev: 151410 EvalError,  Up: Top

277 15.1.4.11 (#sec-15.1.4.11) RangeError ( . . . )
***************************************************

See 15.11.6.2 (#sec-15.11.6.2).


File: javascript_ecma_262_5th_ed.info,  Node: 151412 ReferenceError,  Next: 151413 SyntaxError,  Prev: 151411 RangeError,  Up: Top

278 15.1.4.12 (#sec-15.1.4.12) ReferenceError ( . . . )
*******************************************************

See 15.11.6.3 (#sec-15.11.6.3).


File: javascript_ecma_262_5th_ed.info,  Node: 151413 SyntaxError,  Next: 151414 TypeError,  Prev: 151412 ReferenceError,  Up: Top

279 15.1.4.13 (#sec-15.1.4.13) SyntaxError ( . . . )
****************************************************

See 15.11.6.4 (#sec-15.11.6.4).


File: javascript_ecma_262_5th_ed.info,  Node: 151414 TypeError,  Next: 151415 URIError,  Prev: 151413 SyntaxError,  Up: Top

280 15.1.4.14 (#sec-15.1.4.14) TypeError ( . . . )
**************************************************

See 15.11.6.5 (#sec-15.11.6.5).


File: javascript_ecma_262_5th_ed.info,  Node: 151415 URIError,  Next: 1515 Other Properties of the Global Object,  Prev: 151414 TypeError,  Up: Top

281 15.1.4.15 (#sec-15.1.4.15) URIError ( . . . )
*************************************************

See 15.11.6.6 (#sec-15.11.6.6).


File: javascript_ecma_262_5th_ed.info,  Node: 1515 Other Properties of the Global Object,  Next: 15151 Math,  Prev: 151415 URIError,  Up: Top

282 15.1.5 (#sec-15.1.5) Other Properties of the Global Object
**************************************************************


File: javascript_ecma_262_5th_ed.info,  Node: 15151 Math,  Next: 15152 JSON,  Prev: 1515 Other Properties of the Global Object,  Up: Top

283 15.1.5.1 (#sec-15.1.5.1) Math
*********************************

See 15.8 (#sec-15.8).


File: javascript_ecma_262_5th_ed.info,  Node: 15152 JSON,  Next: 152 Object Objects,  Prev: 15151 Math,  Up: Top

284 15.1.5.2 (#sec-15.1.5.2) JSON
*********************************

See 15.12 (#sec-15.12).


File: javascript_ecma_262_5th_ed.info,  Node: 152 Object Objects,  Next: 1521 The Object Constructor Called as a Function,  Prev: 15152 JSON,  Up: Top

285 15.2 (#sec-15.2) Object Objects
***********************************


File: javascript_ecma_262_5th_ed.info,  Node: 1521 The Object Constructor Called as a Function,  Next: 15211 Object [ value ],  Prev: 152 Object Objects,  Up: Top

286 15.2.1 (#sec-15.2.1) The Object Constructor Called as a Function
********************************************************************

When Object is called as a function rather than as a constructor, it
performs a type conversion.


File: javascript_ecma_262_5th_ed.info,  Node: 15211 Object [ value ],  Next: 1522 The Object Constructor,  Prev: 1521 The Object Constructor Called as a Function,  Up: Top

287 15.2.1.1 (#sec-15.2.1.1) Object ( [ value ] )
*************************************************

When the Object function is called with no arguments or with one
argument value, the following steps are taken:

  1. If value is null, undefined or not supplied, create and return a
     new Object object exactly as if the standard built-in Object
     constructor had been called with the same arguments (15.2.2.1
     (#sec-15.2.2.1)).

  2. Return ToObject (#sec-9.9)(value).


File: javascript_ecma_262_5th_ed.info,  Node: 1522 The Object Constructor,  Next: 15221 new Object [ value ],  Prev: 15211 Object [ value ],  Up: Top

288 15.2.2 (#sec-15.2.2) The Object Constructor
***********************************************

When Object is called as part of a `new' expression, it is a
constructor that may create an object.


File: javascript_ecma_262_5th_ed.info,  Node: 15221 new Object [ value ],  Next: 1523 Properties of the Object Constructor,  Prev: 1522 The Object Constructor,  Up: Top

289 15.2.2.1 (#sec-15.2.2.1) new Object ( [ value ] )
*****************************************************

When the Object constructor is called with no arguments or with one
argument value, the following steps are taken:

  1. If value is supplied, then
       1. If Type (#def-type)(value) is Object, then
            1. If the value is a native ECMAScript object, do not
               create a new object but simply return value.

            2. If the value is a host object, then actions are taken
               and a result is returned in an implementation-dependent
               manner that may depend on the host object.

       2. If Type (#def-type)(value) is String, return ToObject
          (#sec-9.9)(value).

       3. If Type (#def-type)(value) is Boolean, return ToObject
          (#sec-9.9)(value).

       4. If Type (#def-type)(value) is Number, return ToObject
          (#sec-9.9)(value).

  2. Assert: The argument value was not supplied or its type was Null
     or Undefined.

  3. Let obj be a newly created native ECMAScript object.

  4. Set the [[Prototype]] internal property of obj t to the standard
     built-in Object prototype object (15.2.4 (#sec-15.2.4)).

  5. Set the [[Class]] internal property of obj to "Object".

  6. Set the [[Extensible]] internal property of obj to true.

  7. Set the all the internal methods of obj as specified in 8.12
     (#sec-8.12).

  8. Return obj.


File: javascript_ecma_262_5th_ed.info,  Node: 1523 Properties of the Object Constructor,  Next: 15231 Objectprototype,  Prev: 15221 new Object [ value ],  Up: Top

290 15.2.3 (#sec-15.2.3) Properties of the Object Constructor
*************************************************************

The value of the [[Prototype]] internal property of the Object
constructor is the standard built-in Function prototype object.

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


File: javascript_ecma_262_5th_ed.info,  Node: 15231 Objectprototype,  Next: 15232 ObjectgetPrototypeOf O,  Prev: 1523 Properties of the Object Constructor,  Up: Top

291 15.2.3.1 (#sec-15.2.3.1) Object.prototype
*********************************************

The initial value of Object.prototype is the standard built-in Object
prototype object (15.2.4 (#sec-15.2.4)).


File: javascript_ecma_262_5th_ed.info,  Node: 15232 ObjectgetPrototypeOf O,  Next: 15233 ObjectgetOwnPropertyDescriptor O P,  Prev: 15231 Objectprototype,  Up: Top

292 15.2.3.2 (#sec-15.2.3.2) Object.getPrototypeOf ( O )
********************************************************

When the getPrototypeOf function is called with argument O, the
following steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. Return the value of the [[Prototype]] internal property of O.


File: javascript_ecma_262_5th_ed.info,  Node: 15233 ObjectgetOwnPropertyDescriptor O P,  Next: 15234 ObjectgetOwnPropertyNames O,  Prev: 15232 ObjectgetPrototypeOf O,  Up: Top

293 15.2.3.3 (#sec-15.2.3.3) Object.getOwnPropertyDescriptor ( O, P )
*********************************************************************

When the getOwnPropertyDescriptor function is called, the following
steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. Let name be ToString (#sec-9.8)(P).

  3. Let desc be the result of calling the [[GetOwnProperty]] internal
     method of O with argument name.

  4. Return the result of calling FromPropertyDescriptor
     (#sec-8.10.4)(desc) (8.10.4 (#sec-8.10.4)).


File: javascript_ecma_262_5th_ed.info,  Node: 15234 ObjectgetOwnPropertyNames O,  Next: 15235 Objectcreate O [ Properties],  Prev: 15233 ObjectgetOwnPropertyDescriptor O P,  Up: Top

294 15.2.3.4 (#sec-15.2.3.4) Object.getOwnPropertyNames ( O )
*************************************************************

When the getOwnPropertyNames function is called, the following steps
are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. Let array be the result of creating a new object as if by the
     expression `new Array ()' where `Array' is the standard built-in
     constructor with that name.

  3. Let n be 0.

  4. For each named own property P of O
       1. Let name be the String value that is the name of P.

       2. Call the [[DefineOwnProperty]] internal method of array with
          arguments ToString (#sec-9.8)(n), the PropertyDescriptor
          {[[Value]]: name, [[Writable]]: true, [[Enumerable]]: true,
          [[Configurable]]: true}, and false.

       3. Increment n by 1.

  5. Return array.

   NOTE If O is a String instance, the set of own properties processed
in step 4 includes the implicit properties defined in 15.5.5.2
(#sec-15.5.5.2) that correspond to character positions within the
object’s [[PrimitiveValue]] String.


File: javascript_ecma_262_5th_ed.info,  Node: 15235 Objectcreate O [ Properties],  Next: 15236 ObjectdefineProperty O P Attributes,  Prev: 15234 ObjectgetOwnPropertyNames O,  Up: Top

295 15.2.3.5 (#sec-15.2.3.5) Object.create ( O [, Properties] )
***************************************************************

The create function creates a new object with a specified prototype.
When the create function is called, the following steps are taken:

  1. If Type (#def-type)(O) is not Object or Null throw a TypeError
     exception.

  2. Let obj be the result of creating a new object as if by the
     expression `new Object()' where `Object' is the standard built-in
     constructor with that name

  3. Set the [[Prototype]] internal property of obj to O.

  4. If the argument Properties is present and not undefined, add own
     properties to obj as if by calling the standard built-in function
     Object.defineProperties (#sec-15.2.3.7) with arguments obj and
     Properties.

  5. Return obj.


File: javascript_ecma_262_5th_ed.info,  Node: 15236 ObjectdefineProperty O P Attributes,  Next: 15237 ObjectdefineProperties O Properties,  Prev: 15235 Objectcreate O [ Properties],  Up: Top

296 15.2.3.6 (#sec-15.2.3.6) Object.defineProperty ( O, P, Attributes )
***********************************************************************

The defineProperty function is used to add an own property and/or
update the attributes of an existing own property of an object. When
the defineProperty function is called, the following steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. Let name be ToString (#sec-9.8)(P).

  3. Let desc be the result of calling ToPropertyDescriptor with
     Attributes as the argument.

  4. Call the [[DefineOwnProperty]] internal method of O with arguments
     name, desc, and true.

  5. Return O.


File: javascript_ecma_262_5th_ed.info,  Node: 15237 ObjectdefineProperties O Properties,  Next: 15238 Objectseal O,  Prev: 15236 ObjectdefineProperty O P Attributes,  Up: Top

297 15.2.3.7 (#sec-15.2.3.7) Object.defineProperties ( O, Properties )
**********************************************************************

The defineProperties function is used to add own properties and/or
update the attributes of existing own properties of an object. When the
defineProperties function is called, the following steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. Let props be ToObject (#sec-9.9)(Properties).

  3. Let names be an internal list containing the names of each
     enumerable own property of props.

  4. Let descriptors be an empty internal List (#sec-8.8).

  5. For each element P of names in list order,
       1. Let descObj be the result of calling the [[Get]] internal
          method of props with P as the argument.

       2. Let desc be the result of calling ToPropertyDescriptor with
          descObj as the argument.

       3. Append the pair (a two element List (#sec-8.8)) consisting of
          P and desc to the end of descriptors.

  6. For each element pair from descriptors in list order,
       1. Let P be the first element of pair.

       2. Let desc be the second element of pair.

       3. Call the [[DefineOwnProperty]] internal method of O with
          arguments P, desc, and true.

  7. Return O.

   If an implementation defines a specific order of enumeration for the
for-in statement, that same enumeration order must be used to order the
list elements in step 3 of this algorithm.


File: javascript_ecma_262_5th_ed.info,  Node: 15238 Objectseal O,  Next: 15239 Objectfreeze O,  Prev: 15237 ObjectdefineProperties O Properties,  Up: Top

298 15.2.3.8 (#sec-15.2.3.8) Object.seal ( O )
**********************************************

When the seal function is called, the following steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. For each named own property name P of O,
       1. Let desc be the result of calling the [[GetOwnProperty]]
          internal method of O with P.

       2. If desc.[[Configurable]] is true, set desc.[[Configurable]]
          to false.

       3. Call the [[DefineOwnProperty]] internal method of O with P,
          desc, and true as arguments.

  3. Set the [[Extensible]] internal property of O to false.

  4. Return O.


File: javascript_ecma_262_5th_ed.info,  Node: 15239 Objectfreeze O,  Next: 152310 ObjectpreventExtensions O,  Prev: 15238 Objectseal O,  Up: Top

299 15.2.3.9 (#sec-15.2.3.9) Object.freeze ( O )
************************************************

When the freeze function is called, the following steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. For each named own property name P of O,
       1. Let desc be the result of calling the [[GetOwnProperty]]
          internal method of O with P.

       2. If IsDataDescriptor (#def-IsDataDescriptor)(desc) is true,
          then
            1. If desc.[[Writable]] is true, set desc.[[Writable]] to
               false.

       3. If desc.[[Configurable]] is true, set desc.[[Configurable]]
          to false.

       4. Call the [[DefineOwnProperty]] internal method of O with P,
          desc, and true as arguments.

  3. Set the [[Extensible]] internal property of O to false.

  4. Return O.


File: javascript_ecma_262_5th_ed.info,  Node: 152310 ObjectpreventExtensions O,  Next: 152311 ObjectisSealed O,  Prev: 15239 Objectfreeze O,  Up: Top

300 15.2.3.10 (#sec-15.2.3.10) Object.preventExtensions ( O )
*************************************************************

When the preventExtensions function is called, the following steps are
taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. Set the [[Extensible]] internal property of O to false.

  3. Return O.


File: javascript_ecma_262_5th_ed.info,  Node: 152311 ObjectisSealed O,  Next: 152312 ObjectisFrozen O,  Prev: 152310 ObjectpreventExtensions O,  Up: Top

301 15.2.3.11 (#sec-15.2.3.11) Object.isSealed ( O )
****************************************************

When the isSealed function is called with argument O, the following
steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. For each named own property name P of O,
       1. Let desc be the result of calling the [[GetOwnProperty]]
          internal method of O with P.

       2. If desc.[[Configurable]] is true, then return false.

  3. If the [[Extensible]] internal property of O is false, then return
     true.

  4. Otherwise, return false.


File: javascript_ecma_262_5th_ed.info,  Node: 152312 ObjectisFrozen O,  Next: 152313 ObjectisExtensible O,  Prev: 152311 ObjectisSealed O,  Up: Top

302 15.2.3.12 (#sec-15.2.3.12) Object.isFrozen ( O )
****************************************************

When the isFrozen function is called with argument O, the following
steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. For each named own property name P of O,
       1. Let desc be the result of calling the [[GetOwnProperty]]
          internal method of O with P.

       2. If IsDataDescriptor (#def-IsDataDescriptor)(desc) is true then
            1. If desc.[[Writable]] is true, return false.

       3. If desc.[[Configurable]] is true, then return false.

  3. If the [[Extensible]] internal property of O is false, then return
     true.

  4. Otherwise, return false.


File: javascript_ecma_262_5th_ed.info,  Node: 152313 ObjectisExtensible O,  Next: 152314 Objectkeys O,  Prev: 152312 ObjectisFrozen O,  Up: Top

303 15.2.3.13 (#sec-15.2.3.13) Object.isExtensible ( O )
********************************************************

When the isExtensible function is called with argument O, the following
steps are taken:

  1. If Type (#def-type)(O) is not Object throw a TypeError exception.

  2. Return the Boolean value of the [[Extensible]] internal property
     of O.


File: javascript_ecma_262_5th_ed.info,  Node: 152314 Objectkeys O,  Next: 1524 Properties of the Object Prototype Object,  Prev: 152313 ObjectisExtensible O,  Up: Top

304 15.2.3.14 (#sec-15.2.3.14) Object.keys ( O )
************************************************

When the keys function is called with argument O, the following steps
are taken:

  1. If the Type (#def-type)(O) is not Object, throw a TypeError
     exception.

  2. Let n be the number of own enumerable properties of O

  3. Let array be the result of creating a new Object as if by the
     expression `new Array(<var>n</var>)' where `Array' is the standard
     built-in constructor with that name.

  4. Let index be 0.

  5. For each own enumerable property of O whose name String is P
       1. Call the [[DefineOwnProperty]] internal method of array with
          arguments ToString (#sec-9.8)(index), the PropertyDescriptor
          {[[Value]]: P, [[Writable]]: true, [[Enumerable]]: true,
          [[Configurable]]: true}, and false.

       2. Increment index by 1.

  6. Return array.

   If an implementation defines a specific order of enumeration for the
for-in statement, that same enumeration order must be used in step 5 of
this algorithm.


File: javascript_ecma_262_5th_ed.info,  Node: 1524 Properties of the Object Prototype Object,  Next: 15241 Objectprototypeconstructor,  Prev: 152314 Objectkeys O,  Up: Top

305 15.2.4 (#sec-15.2.4) Properties of the Object Prototype Object
******************************************************************

The value of the [[Prototype]] internal property of the Object
prototype object is null, the value of the [[Class]] internal property
is "Object", and the initial value of the [[Extensible]] internal
property is true.


File: javascript_ecma_262_5th_ed.info,  Node: 15241 Objectprototypeconstructor,  Next: 15242 ObjectprototypetoString,  Prev: 1524 Properties of the Object Prototype Object,  Up: Top

306 15.2.4.1 (#sec-15.2.4.1) Object.prototype.constructor
*********************************************************

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


File: javascript_ecma_262_5th_ed.info,  Node: 15242 ObjectprototypetoString,  Next: 15243 ObjectprototypetoLocaleString,  Prev: 15241 Objectprototypeconstructor,  Up: Top

307 15.2.4.2 (#sec-15.2.4.2) Object.prototype.toString ( )
**********************************************************

When the toString method is called, the following steps are taken:

  1. If the this value is undefined, return "[object Undefined]".

  2. If the this value is null, return "[object Null]".

  3. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  4. Let class be the value of the [[Class]] internal property of O.

  5. Return the String value that is the result of concatenating the
     three Strings "[object ", class, and "]".


File: javascript_ecma_262_5th_ed.info,  Node: 15243 ObjectprototypetoLocaleString,  Next: 15244 ObjectprototypevalueOf,  Prev: 15242 ObjectprototypetoString,  Up: Top

308 15.2.4.3 (#sec-15.2.4.3) Object.prototype.toLocaleString ( )
****************************************************************

When the toLocaleString method is called, the following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let toString be the result of calling the [[Get]] internal method
     of O passing "toString" as the argument.

  3. If IsCallable (#sec-9.11)(toString) is false, throw a TypeError
     exception.

  4. Return the result of calling the [[Call]] internal method of
     toString passing O as the this value and no arguments.

   NOTE 1 This function is provided to give all Objects a generic
toLocaleString interface, even though not all may use it. Currently,
Array (#sec-15.4.4.3), Number (#sec-15.7.4.3), and Date (#sec-15.9.5.5)
provide their own locale-sensitive toLocaleString methods.

   NOTE 2 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.


File: javascript_ecma_262_5th_ed.info,  Node: 15244 ObjectprototypevalueOf,  Next: 15245 ObjectprototypehasOwnProperty V,  Prev: 15243 ObjectprototypetoLocaleString,  Up: Top

309 15.2.4.4 (#sec-15.2.4.4) Object.prototype.valueOf ( )
*********************************************************

When the valueOf method is called, the following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. If O is the result of calling the Object constructor with a host
     object (15.2.2.1 (#sec-15.2.2.1)), then
       1. Return either O or another value such as the host object
          originally passed to the constructor. The specific result
          that is returned is implementation-defined.

  3. Return O.


File: javascript_ecma_262_5th_ed.info,  Node: 15245 ObjectprototypehasOwnProperty V,  Next: 15246 ObjectprototypeisPrototypeOf V,  Prev: 15244 ObjectprototypevalueOf,  Up: Top

310 15.2.4.5 (#sec-15.2.4.5) Object.prototype.hasOwnProperty (V)
****************************************************************

When the hasOwnProperty method is called with argument V, the following
steps are taken:

  1. Let P be ToString (#sec-9.8)(V).

  2. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  3. Let desc be the result of calling the [[GetOwnProperty]] internal
     method of O passing P as the argument.

  4. If desc is undefined, return false.

  5. Return true.

   NOTE 1 Unlike [[HasProperty]] (8.12.6 (#sec-8.12.6)), this method
does not consider objects in the prototype chain.

   NOTE 2 The ordering of steps 1 and 2 is chosen to ensure that any
exception that would have been thrown by step 1 in previous editions of
this specification will continue to be thrown even if the this value is
undefined or null.


File: javascript_ecma_262_5th_ed.info,  Node: 15246 ObjectprototypeisPrototypeOf V,  Next: 15247 ObjectprototypepropertyIsEnumerable V,  Prev: 15245 ObjectprototypehasOwnProperty V,  Up: Top

311 15.2.4.6 (#sec-15.2.4.6) Object.prototype.isPrototypeOf (V)
***************************************************************

When the isPrototypeOf method is called with argument V, the following
steps are taken:

  1. If V is not an object, return false.

  2. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  3. Repeat
       1. Let V be the value of the [[Prototype]] internal property of
          V.

       2. if V is null, return false

       3. If O and V refer to the same object, return true.


   NOTE The ordering of steps 1 and 2 is chosen to preserve the
behaviour specified by previous editions of this specification for the
case where V is not an object and the this value is undefined or null.


File: javascript_ecma_262_5th_ed.info,  Node: 15247 ObjectprototypepropertyIsEnumerable V,  Next: 1525 Properties of Object Instances,  Prev: 15246 ObjectprototypeisPrototypeOf V,  Up: Top

312 15.2.4.7 (#sec-15.2.4.7) Object.prototype.propertyIsEnumerable (V)
**********************************************************************

When the propertyIsEnumerable method is called with argument V, the
following steps are taken:

  1. Let P be ToString (#sec-9.8)(V).

  2. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  3. Let desc be the result of calling the [[GetOwnProperty]] internal
     method of O passing P as the argument.

  4. If desc is undefined, return false.

  5. Return the value of desc.[[Enumerable]].

   NOTE 1 This method does not consider objects in the prototype chain.

   NOTE 2 The ordering of steps 1 and 2 is chosen to ensure that any
exception that would have been thrown by step 1 in previous editions of
this specification will continue to be thrown even if the this value is
undefined or null.


File: javascript_ecma_262_5th_ed.info,  Node: 1525 Properties of Object Instances,  Next: 153 Function Objects,  Prev: 15247 ObjectprototypepropertyIsEnumerable V,  Up: Top

313 15.2.5 (#sec-15.2.5) Properties of Object Instances
*******************************************************

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


File: javascript_ecma_262_5th_ed.info,  Node: 153 Function Objects,  Next: 1531 The Function Constructor Called as a Function,  Prev: 1525 Properties of Object Instances,  Up: Top

314 15.3 (#sec-15.3) Function Objects
*************************************


File: javascript_ecma_262_5th_ed.info,  Node: 1531 The Function Constructor Called as a Function,  Next: 15311 Function p1 p2 pn body,  Prev: 153 Function Objects,  Up: Top

315 15.3.1 (#sec-15.3.1) The Function Constructor Called as a Function
**********************************************************************

When Function is called as a function rather than as a constructor, it
creates and initialises a new Function object. Thus the function call
`Function(<var>...</var>)' is equivalent to the object creation
expression `new Function(<var>...</var>)' with the same arguments.


File: javascript_ecma_262_5th_ed.info,  Node: 15311 Function p1 p2 pn body,  Next: 1532 The Function Constructor,  Prev: 1531 The Function Constructor Called as a Function,  Up: Top

316 15.3.1.1 (#sec-15.3.1.1) Function (p1, p2, ... , pn, body)
**************************************************************

When the Function function is called with some arguments p1, p2, ... ,
pn, body (where n might be 0, that is, there are no “p” arguments,
and where body might also not be provided), the following steps are
taken:

  1. Create and return a new Function object as if the standard
     built-in constructor Function was used in a `new' expression with
     the same arguments (15.3.2.1 (#sec-15.3.2.1)).


File: javascript_ecma_262_5th_ed.info,  Node: 1532 The Function Constructor,  Next: 15321 new Function p1 p2 pn body,  Prev: 15311 Function p1 p2 pn body,  Up: Top

317 15.3.2 (#sec-15.3.2) The Function Constructor
*************************************************

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


File: javascript_ecma_262_5th_ed.info,  Node: 15321 new Function p1 p2 pn body,  Next: 1533 Properties of the Function Constructor,  Prev: 1532 The Function Constructor,  Up: Top

318 15.3.2.1 (#sec-15.3.2.1) new Function (p1, p2, ... , pn, body)
******************************************************************

The last argument specifies the body (executable code) of a function;
any preceding arguments specify formal parameters.

   When the Function constructor is called with some arguments p1, p2,
... , pn, body (where n might be 0, that is, there are no “p”
arguments, and where body might also not be provided), the following
steps are taken:

  1. Let argCount be the total number of arguments passed to this
     function invocation.

  2. Let P be the empty String.

  3. If argCount = 0, let body be the empty String.

  4. Else if argCount = 1, let body be that argument.

  5. Else, argCount > 1
       1. Let firstArg be the first argument.

       2. Let P be ToString (#sec-9.8)(firstArg).

       3. Let k be 2.

       4. Repeat, while k < argCount
            1. Let nextArg be the kth argument.

            2. Let P be the result of concatenating the previous value
               of P, the String "," (a comma), and ToString
               (#sec-9.8)(nextArg).

            3. Increase k by 1.

       5. Let body be the kth argument.

  6. Let body be ToString (#sec-9.8)(body).

  7. If P is not parsable as a FormalParameterList_opt_ then throw a
     SyntaxError exception.

  8. If body is not parsable as FunctionBody then throw a SyntaxError
     exception.

  9. If body is strict mode code (see 10.1.1) (#sec-10.1.1) then let
     strict be true, else let strict be false.

 10. If strict is true, throw any exceptions specified in 13.1
     (#sec-13.1) that apply.

 11. Return a new Function object created as specified in 13.2
     (#sec-13.2) passing P as the FormalParameterList and body as the
     FunctionBody. Pass in the Global Environment (#sec-10.2.3) as the
     Scope parameter and strict as the Strict flag.

   A `prototype' property is automatically created for every function,
to provide for the possibility that the function will be used as a
constructor.

   NOTE It is permissible but not necessary to have one argument for
each formal parameter to be specified. For example, all three of the
following expressions produce the same result:

new Function("a", "b", "c", "return a+b+c")


new Function("a, b, c", "return a+b+c")


new Function("a,b", "c", "return a+b+c")


File: javascript_ecma_262_5th_ed.info,  Node: 1533 Properties of the Function Constructor,  Next: 15331 Functionprototype,  Prev: 15321 new Function p1 p2 pn body,  Up: Top

319 15.3.3 (#sec-15.3.3) Properties of the Function Constructor
***************************************************************

The Function constructor is itself a Function object and its [[Class]]
is "Function". The value of the [[Prototype]] internal property of the
Function constructor is the standard built-in Function prototype object
(15.3.4 (#sec-15.3.4)).

   The value of the [[Extensible]] internal property of the Function
constructor is true.

   The Function constructor has the following properties:


File: javascript_ecma_262_5th_ed.info,  Node: 15331 Functionprototype,  Next: 15332 Functionlength,  Prev: 1533 Properties of the Function Constructor,  Up: Top

320 15.3.3.1 (#sec-15.3.3.1) Function.prototype
***********************************************

The initial value of Function.prototype is the standard built-in
Function prototype object (15.3.4 (#sec-15.3.4)).

   This property has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 15332 Functionlength,  Next: 1534 Properties of the Function Prototype Object,  Prev: 15331 Functionprototype,  Up: Top

321 15.3.3.2 (#sec-15.3.3.2) Function.length
********************************************

This is a data property with a value of 1. This property has the
attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 1534 Properties of the Function Prototype Object,  Next: 15341 Functionprototypeconstructor,  Prev: 15332 Functionlength,  Up: Top

322 15.3.4 (#sec-15.3.4) Properties of the Function Prototype Object
********************************************************************

The Function prototype object is itself a Function object (its
[[Class]] is "Function") that, when invoked, accepts any arguments and
returns undefined.

   The value of the [[Prototype]] internal property of the Function
prototype object is the standard built-in Object prototype object
(15.2.4 (#sec-15.2.4)). The initial value of the [[Extensible]]
internal property of the Function prototype object is true.

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

   The `length' property of the Function prototype object is 0.


File: javascript_ecma_262_5th_ed.info,  Node: 15341 Functionprototypeconstructor,  Next: 15342 FunctionprototypetoString,  Prev: 1534 Properties of the Function Prototype Object,  Up: Top

323 15.3.4.1 (#sec-15.3.4.1) Function.prototype.constructor
***********************************************************

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


File: javascript_ecma_262_5th_ed.info,  Node: 15342 FunctionprototypetoString,  Next: 15343 Functionprototypeapply thisArg argArray,  Prev: 15341 Functionprototypeconstructor,  Up: Top

324 15.3.4.2 (#sec-15.3.4.2) Function.prototype.toString ( )
************************************************************

An implementation-dependent representation of the function is returned.
This representation has the syntax of a FunctionDeclaration. Note in
particular that the use and placement of white space, line terminators,
and semicolons within the representation String is
implementation-dependent.

   The toString function is not generic; it throws a TypeError
exception if its this value is not a Function object. Therefore, it
cannot be transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 15343 Functionprototypeapply thisArg argArray,  Next: 15344 Functionprototypecall thisArg [ arg1 [ arg2 ] ],  Prev: 15342 FunctionprototypetoString,  Up: Top

325 15.3.4.3 (#sec-15.3.4.3) Function.prototype.apply (thisArg, argArray)
*************************************************************************

When the apply method is called on an object func with arguments
thisArg and argArray, the following steps are taken:

  1. If IsCallable (#sec-9.11)(func) is false, then throw a TypeError
     exception.

  2. If argArray is null or undefined, then
       1. Return the result of calling the [[Call]] internal method of
          func, providing thisArg as the this value and an empty list
          of arguments.

  3. If Type (#def-type)(argArray) is not Object, then throw a
     TypeError exception.

  4. Let len be the result of calling the [[Get]] internal method of
     argArray with argument "length".

  5. Let n be ToUint32 (#sec-9.6)(len).

  6. Let argList be an empty List (#sec-8.8).

  7. Let index be 0.

  8. Repeat while index < n
       1. Let indexName be ToString (#sec-9.8)(index).

       2. Let nextArg be the result of calling the [[Get]] internal
          method of argArray with indexName as the argument.

       3. Append nextArg as the last element of argList.

       4. Set index to index + 1.

  9. Return the result of calling the [[Call]] internal method of func,
     providing thisArg as the this value and argList as the list of
     arguments.

   The `length' property of the apply method is 2.

   NOTE The thisArg value is passed without modification as the this
value. This is a change from Edition 3, where a undefined or null
thisArg is replaced with the global object and ToObject (#sec-9.9) is
applied to all other values and that result is passed as the this value.


File: javascript_ecma_262_5th_ed.info,  Node: 15344 Functionprototypecall thisArg [ arg1 [ arg2 ] ],  Next: 15345 Functionprototypebind thisArg [ arg1 [ arg2 ]],  Prev: 15343 Functionprototypeapply thisArg argArray,  Up: Top

326 15.3.4.4 (#sec-15.3.4.4) Function.prototype.call (thisArg [ , arg1 [ , arg2, ... ] ] )
******************************************************************************************

When the call method is called on an object func with argument thisArg
and optional arguments arg1, arg2 etc, the following steps are taken:

  1. If IsCallable (#sec-9.11)(func) is false, then throw a TypeError
     exception.

  2. Let argList be an empty List (#sec-8.8).

  3. If this method was called with more than one argument then in left
     to right order starting with arg1 append each argument as the last
     element of argList

  4. Return the result of calling the [[Call]] internal method of func,
     providing thisArg as the this value and argList as the list of
     arguments.

   The `length' property of the call method is 1.

   NOTE The thisArg value is passed without modification as the this
value. This is a change from Edition 3, where a undefined or null
thisArg is replaced with the global object and ToObject (#sec-9.9) is
applied to all other values and that result is passed as the this value.


File: javascript_ecma_262_5th_ed.info,  Node: 15345 Functionprototypebind thisArg [ arg1 [ arg2 ]],  Next: 153451 [[Call]],  Prev: 15344 Functionprototypecall thisArg [ arg1 [ arg2 ] ],  Up: Top

327 15.3.4.5 (#sec-15.3.4.5) Function.prototype.bind (thisArg [, arg1 [, arg2, ...]])
*************************************************************************************

The bind method takes one or more arguments, thisArg and (optionally)
arg1, arg2, etc, and returns a new function object by performing the
following steps:

  1. Let Target be the this value.

  2. If IsCallable (#sec-9.11)(Target) is false, throw a TypeError
     exception.

  3. Let A be a new (possibly empty) internal list of all of the
     argument values provided after thisArg (arg1, arg2 etc), in order.

  4. Let F be a new native ECMAScript object .

  5. Set all the internal methods, except for [[Get]], of F as
     specified in 8.12 (#sec-8.12).

  6. Set the [[Get]] internal property of F as specified in 15.3.5.4
     (#sec-15.3.5.4).

  7. Set the [[TargetFunction]] internal property of F to Target.

  8. Set the [[BoundThis]] internal property of F to the value of
     thisArg.

  9. Set the [[BoundArgs]] internal property of F to A.

 10. Set the [[Class]] internal property of F to "Function".

 11. Set the [[Prototype]] internal property of F to the standard
     built-in Function prototype object as specified in 15.3.3.1
     (#sec-15.3.3.1).

 12. Set the [[Call]] internal property of F as described in 15.3.4.5.1
     (#sec-15.3.4.5.1).

 13. Set the [[Construct]] internal property of F as described in
     15.3.4.5.2 (#sec-15.3.4.5.2).

 14. Set the [[HasInstance]] internal property of F as described in
     15.3.4.5.3 (#sec-15.3.4.5.3).

 15. If the [[Class]] internal property of Target is "Function", then
       1. Let L be the `length' property of Target minus the length of
          A.

       2. Set the `length' own property of F to either 0 or L,
          whichever is larger.

 16. Else set the `length' own property of F to 0.

 17. Set the attributes of the `length' own property of F to the values
     specified in 15.3.5.1 (#sec-15.3.5.1).

 18. Set the [[Extensible]] internal property of F to true.

 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3
     (#sec-13.2.3)).

 20. Call the [[DefineOwnProperty]] internal method of F with arguments
     "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]: thrower,
     [[Enumerable]]: false, [[Configurable]]: false}, and false.

 21. Call the [[DefineOwnProperty]] internal method of F with arguments
     "arguments", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
     thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
     false.

 22. Return F.

   The `length' property of the bind method is 1.

   NOTE Function objects created using Function.prototype.bind do not
have a `prototype' property or the [[Code]], [[FormalParameters]], and
[[Scope]] internal properties.


File: javascript_ecma_262_5th_ed.info,  Node: 153451 [[Call]],  Next: 153452 [[Construct]],  Prev: 15345 Functionprototypebind thisArg [ arg1 [ arg2 ]],  Up: Top

328 15.3.4.5.1 (#sec-15.3.4.5.1) [[Call]]
*****************************************

When the [[Call]] internal method of a function object, F, which was
created using the bind function is called with a this value and a list
of arguments ExtraArgs, the following steps are taken:

  1. Let boundArgs be the value of F’s [[BoundArgs]] internal
     property.

  2. Let boundThis be the value of F’s [[BoundThis]] internal
     property.

  3. Let target be the value of F’s [[TargetFunction]] internal
     property.

  4. Let args be a new list containing the same values as the list
     boundArgs in the same order followed by the same values as the
     list ExtraArgs in the same order.

  5. Return the result of calling the [[Call]] internal method of
     target providing boundThis as the this value and providing args as
     the arguments.


File: javascript_ecma_262_5th_ed.info,  Node: 153452 [[Construct]],  Next: 153453 [[HasInstance]] V,  Prev: 153451 [[Call]],  Up: Top

329 15.3.4.5.2 (#sec-15.3.4.5.2) [[Construct]]
**********************************************

When the [[Construct]] internal method of a function object, F that was
created using the bind function is called with a list of arguments
ExtraArgs, the following steps are taken:

  1.  2. If target has no [[Construct]] internal method, a TypeError
     exception is thrown.

  3. Let boundArgs be the value of F’s [[BoundArgs]] internal
     property.

  4. Let args be a new list containing the same values as the list
     boundArgs in the same order followed by the same values as the
     list ExtraArgs in the same order.

  5. Return the result of calling the [[Construct]] internal method of
     target providing args as the arguments.


File: javascript_ecma_262_5th_ed.info,  Node: 153453 [[HasInstance]] V,  Next: 1535 Properties of Function Instances,  Prev: 153452 [[Construct]],  Up: Top

330 15.3.4.5.3 (#sec-15.3.4.5.3) [[HasInstance]] (V)
****************************************************

When the [[HasInstance]] internal method of a function object F, that
was created using the bind function is called with argument V, the
following steps are taken:

  1. Let target be the value of F’s [[TargetFunction]] internal
     property.

  2. If target has no [[HasInstance]] internal method, a TypeError
     exception is thrown.

  3. Return the result of calling the [[HasInstance]] internal method
     of target providing V as the argument.


File: javascript_ecma_262_5th_ed.info,  Node: 1535 Properties of Function Instances,  Next: 15351 length,  Prev: 153453 [[HasInstance]] V,  Up: Top

331 15.3.5 (#sec-15.3.5) Properties of Function Instances
*********************************************************

In addition to the required internal properties, every function
instance has a [[Call]] internal property and in most cases use a
different version of the [[Get]] internal property. Depending on how
they are created (see 8.6.2 (#sec-8.6.2) ,13.2 (#sec-13.2), 15
(#sec-15), and 15.3.4.5 (#sec-15.3.4.5)), function instances may have a
[[HasInstance]] internal property, a [[Scope]] internal property, a
[[Construct]] internal property, a [[FormalParameters]] internal
property, a [[Code]] internal property, a [[TargetFunction]] internal
property, a [[BoundThis]] internal property, and a [[BoundArgs]]
internal property.

   The value of the [[Class]] internal property is "Function".

   Function instances that correspond to strict mode functions (13.2
(#sec-13.2)) and function instances created using the
Function.prototype.bind method (15.3.4.5 (#sec-15.3.4.5)) have
properties named “`caller'” and “`arguments'” that throw a
TypeError exception. An ECMAScript implementation must not associate
any implementation specific behaviour with accesses of these properties
from strict mode function code.


File: javascript_ecma_262_5th_ed.info,  Node: 15351 length,  Next: 15352 prototype,  Prev: 1535 Properties of Function Instances,  Up: Top

332 15.3.5.1 (#sec-15.3.5.1) length
***********************************

The value of the `length' property is an integer that indicates the
“typical” number of arguments expected by the function. However,
the language permits the function to be invoked with some other number
of arguments. The behaviour of a function when invoked on a number of
arguments other than the number specified by its `length' property
depends on the function. This property has the attributes {
[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 15352 prototype,  Next: 15353 [[HasInstance]] V,  Prev: 15351 length,  Up: Top

333 15.3.5.2 (#sec-15.3.5.2) prototype
**************************************

The value of the `prototype' property is used to initialise the
[[Prototype]] internal property of a newly created object before the
Function object is invoked as a constructor for that newly created
object. This property has the attribute { [[Writable]]: true,
[[Enumerable]]: false, [[Configurable]]: false }.

   NOTE Function objects created using Function.prototype.bind do not
have a `prototype' property.


File: javascript_ecma_262_5th_ed.info,  Node: 15353 [[HasInstance]] V,  Next: 15354 [[Get]] P,  Prev: 15352 prototype,  Up: Top

334 15.3.5.3 (#sec-15.3.5.3) [[HasInstance]] (V)
************************************************

Assume F is a Function object.

   When the [[HasInstance]] internal method of F is called with value
V, the following steps are taken:

  1. If V is not an object, return false.

  2. Let O be the result of calling the [[Get]] internal method of F
     with property name "prototype".

  3. If Type (#def-type)(O) is not Object, throw a TypeError exception.

  4. Repeat
       1. Let V be the value of the [[Prototype]] internal property of
          V.

       2. If V is null, return false.

       3. If O and V refer to the same object, return true.


   NOTE Function objects created using Function.prototype.bind have a
different implementation of [[HasInstance]] defined in 15.3.4.5.3
(#sec-15.3.4.5.3).


File: javascript_ecma_262_5th_ed.info,  Node: 15354 [[Get]] P,  Next: 154 Array Objects,  Prev: 15353 [[HasInstance]] V,  Up: Top

335 15.3.5.4 (#sec-15.3.5.4) [[Get]] (P)
****************************************

Function objects use a variation of the [[Get]] internal method used
for other native ECMAScript objects (8.12.3 (#sec-8.12.3)).

   Assume F is a Function object. When the [[Get]] internal method of F
is called with property name P, the following steps are taken:

  1. Let v be the result of calling the default [[Get]] internal method
     (8.12.3 (#sec-8.12.3)) on F passing P as the property name
     argument.

  2. If P is "caller" and v is a strict mode Function object, throw a
     TypeError exception.

  3. Return v.

   NOTE Function objects created using Function.prototype.bind use the
default [[Get]] internal method.


File: javascript_ecma_262_5th_ed.info,  Node: 154 Array Objects,  Next: 1541 The Array Constructor Called as a Function,  Prev: 15354 [[Get]] P,  Up: Top

336 15.4 (#sec-15.4) Array Objects
**********************************

Array objects give special treatment to a certain class of property
names. A property name P (in the form of a String value) is an array
index if and only if ToString (#sec-9.8)(ToUint32 (#sec-9.6)(P)) is
equal to P and ToUint32 (#sec-9.6)(P) is not equal to 2^32−1. A
property whose property name is an array index is also called an
element. Every Array object has a `length' property whose value is
always a nonnegative integer less than 2^32. The value of the `length'
property is numerically greater than the name of every property whose
name is an array index; whenever a property of an Array object is
created or changed, other properties are adjusted as necessary to
maintain this invariant. Specifically, whenever a property is added
whose name is an array index, the `length' property is changed, if
necessary, to be one more than the numeric value of that array index;
and whenever the `length' property is changed, every property whose
name is an array index whose value is not smaller than the new length
is automatically deleted. This constraint applies only to own
properties of an Array object and is unaffected by `length' or array
index properties that may be inherited from its prototypes.

   An object, O, is said to be sparse if the following algorithm
returns true:

  1. Let len be the result of calling the [[Get]] internal method of O
     with argument "length".

  2. For each integer i in the range 0≤i<ToUint32 (#sec-9.6)(len)
       1. Let elem be the result of calling the [[GetOwnProperty]]
          internal method of O with argument ToString (#sec-9.8)(i).

       2. If elem is undefined, return true.

  3. Return false.


File: javascript_ecma_262_5th_ed.info,  Node: 1541 The Array Constructor Called as a Function,  Next: 15411 Array [ item1 [ item2 [ ] ] ],  Prev: 154 Array Objects,  Up: Top

337 15.4.1 (#sec-15.4.1) The Array Constructor Called as a Function
*******************************************************************

When Array is called as a function rather than as a constructor, it
creates and initialises a new Array object. Thus the function call
`Array(<var>...</var>)' is equivalent to the object creation expression
`new Array(<var>...</var>)' with the same arguments.


File: javascript_ecma_262_5th_ed.info,  Node: 15411 Array [ item1 [ item2 [ ] ] ],  Next: 1542 The Array Constructor,  Prev: 1541 The Array Constructor Called as a Function,  Up: Top

338 15.4.1.1 (#sec-15.4.1.1) Array ( [ item1 [ , item2 [ , ... ] ] ] )
**********************************************************************

When the Array function is called the following steps are taken:

  1. Create and return a new Array object exactly as if the standard
     built-in constructor Array was used in a `new' expression with the
     same arguments (15.4.2 (#sec-15.4.2)).


File: javascript_ecma_262_5th_ed.info,  Node: 1542 The Array Constructor,  Next: 15421 new Array [ item0 [ item1 [ ] ] ],  Prev: 15411 Array [ item1 [ item2 [ ] ] ],  Up: Top

339 15.4.2 (#sec-15.4.2) The Array Constructor
**********************************************

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


File: javascript_ecma_262_5th_ed.info,  Node: 15421 new Array [ item0 [ item1 [ ] ] ],  Next: 15422 new Array len,  Prev: 1542 The Array Constructor,  Up: Top

340 15.4.2.1 (#sec-15.4.2.1) new Array ( [ item0 [ , item1 [ , ... ] ] ] )
**************************************************************************

This description applies if and only if the Array constructor is given
no arguments or at least two arguments.

   The [[Prototype]] internal property of the newly constructed object
is set to the original Array prototype object, the one that is the
initial value of Array.prototype (15.4.3.1 (#sec-15.4.3.1)).

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

   The [[Extensible]] internal property of the newly constructed object
is set to true.

   The `length' property of the newly constructed object is set to the
number of arguments.

   The `0' property of the newly constructed object is set to item0 (if
supplied); the `1' property of the newly constructed object is set to
item1 (if supplied); and, in general, for as many arguments as there
are, the k property of the newly constructed object is set to argument
k, where the first argument is considered to be argument number 0.
These properties all have the attributes {[[Writable]]: true,
[[Enumerable]]: true, [[Configurable]]: true}.


File: javascript_ecma_262_5th_ed.info,  Node: 15422 new Array len,  Next: 1543 Properties of the Array Constructor,  Prev: 15421 new Array [ item0 [ item1 [ ] ] ],  Up: Top

341 15.4.2.2 (#sec-15.4.2.2) new Array (len)
********************************************

The [[Prototype]] internal property of the newly constructed object is
set to the original Array prototype object, the one that is the initial
value of Array.prototype (15.4.3.1 (#sec-15.4.3.1)). The [[Class]]
internal property of the newly constructed object is set to "Array".
The [[Extensible]] internal property of the newly constructed object is
set to true.

   If the argument len is a Number and ToUint32 (#sec-9.6)(len) is
equal to len, then the `length' property of the newly constructed
object is set to ToUint32 (#sec-9.6)(len). If the argument len is a
Number and ToUint32 (#sec-9.6)(len) is not equal to len, a RangeError
exception is thrown.

   If the argument len is not a Number, then the `length' property of
the newly constructed object is set to 1 and the `0' property of the
newly constructed object is set to len with attributes {[[Writable]]:
true, [[Enumerable]]: true, [[Configurable]]: true}..


File: javascript_ecma_262_5th_ed.info,  Node: 1543 Properties of the Array Constructor,  Next: 15431 Arrayprototype,  Prev: 15422 new Array len,  Up: Top

342 15.4.3 (#sec-15.4.3) Properties of the Array Constructor
************************************************************

The value of the [[Prototype]] internal property of the Array
constructor is the Function prototype object (15.3.4) (#sec-15.3.4).

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


File: javascript_ecma_262_5th_ed.info,  Node: 15431 Arrayprototype,  Next: 15432 ArrayisArray arg,  Prev: 1543 Properties of the Array Constructor,  Up: Top

343 15.4.3.1 (#sec-15.4.3.1) Array.prototype
********************************************

The initial value of Array.prototype is the Array prototype object
(15.4.4 (#sec-15.4.4)).

   This property has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 15432 ArrayisArray arg,  Next: 1544 Properties of the Array Prototype Object,  Prev: 15431 Arrayprototype,  Up: Top

344 15.4.3.2 (#sec-15.4.3.2) Array.isArray ( arg )
**************************************************

The isArray function takes one argument arg, and returns the Boolean
value true if the argument is an object whose class internal property
is "Array"; otherwise it returns false. The following steps are taken:

  1.  2. If the value of the [[Class]] internal property of arg is "Array",
     then return true.

  3. Return false.


File: javascript_ecma_262_5th_ed.info,  Node: 1544 Properties of the Array Prototype Object,  Next: 15441 Arrayprototypeconstructor,  Prev: 15432 ArrayisArray arg,  Up: Top

345 15.4.4 (#sec-15.4.4) Properties of the Array Prototype Object
*****************************************************************

The value of the [[Prototype]] internal property of the Array prototype
object is the standard built-in Object prototype object (15.2.4
(#sec-15.2.4)).

   The Array prototype object is itself an array; its [[Class]] is
"Array", and it has a `length' property (whose initial value is +0) and
the special [[DefineOwnProperty]] internal method described in 15.4.5.1
(#sec-15.4.5.1).

   In following descriptions of functions that are properties of the
Array prototype object, the phrase “this object” refers to the
object that is the this value for the invocation of the function. It is
permitted for the this to be an object for which the value of the
[[Class]] internal property is not "Array".

   NOTE The Array prototype object does not have a `valueOf' property
of its own; however, it inherits the `valueOf' property from the
standard built-in Object prototype Object.


File: javascript_ecma_262_5th_ed.info,  Node: 15441 Arrayprototypeconstructor,  Next: 15442 ArrayprototypetoString,  Prev: 1544 Properties of the Array Prototype Object,  Up: Top

346 15.4.4.1 (#sec-15.4.4.1) Array.prototype.constructor
********************************************************

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


File: javascript_ecma_262_5th_ed.info,  Node: 15442 ArrayprototypetoString,  Next: 15443 ArrayprototypetoLocaleString,  Prev: 15441 Arrayprototypeconstructor,  Up: Top

347 15.4.4.2 (#sec-15.4.4.2) Array.prototype.toString ( )
*********************************************************

When the toString method is called, the following steps are taken:

  1. Let array be the result of calling ToObject (#sec-9.9) on the this
     value.

  2. Let func be the result of calling the [[Get]] internal method of
     array with argument "join".

  3. If IsCallable (#sec-9.11)(func) is false, then let func be the
     standard built-in method Object.prototype.toString (15.2.4.2
     (#sec-15.2.4.2)).

  4. Return the result of calling the [[Call]] internal method of func
     providing array as the this value and an empty arguments list.

   NOTE The toString function is intentionally generic; it does not
require that its this value be an Array object.

   Therefore it can be transferred to other kinds of objects for use as
a method. Whether the toString function can be applied successfully to
a host object is implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 15443 ArrayprototypetoLocaleString,  Next: 15444 Arrayprototypeconcat [ item1 [ item2 [ ] ] ],  Prev: 15442 ArrayprototypetoString,  Up: Top

348 15.4.4.3 (#sec-15.4.4.3) Array.prototype.toLocaleString ( )
***************************************************************

The elements (#def-array-element) of the array are converted to Strings
using their `toLocaleString' methods, and these Strings are then
concatenated, separated by occurrences of a separator String that has
been derived in an implementation-defined locale-specific way. The
result of calling this function is intended to be analogous to the
result of toString, except that the result of this function is intended
to be locale-specific.

   The result is calculated as follows:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let arrayLen be the result of calling the [[Get]] internal method
     of array with argument "length".

  3. Let len be ToUint32 (#sec-9.6)(arrayLen).

  4. Let separator be the String value for the list-separator String
     appropriate for the host environment’s current locale (this is
     derived in an implementation-defined way).

  5. If len is zero, return the empty String.

  6. Let firstElement be the result of calling the [[Get]] internal
     method of array with argument "0".

  7. If firstElement is undefined or null, then
       1. Let R be the empty String.

  8. Else
       1. Let elementObj be ToObject (#sec-9.9)(firstElement).

       2. Let func be the result of calling the [[Get]] internal method
          of elementObj with argument "toLocaleString".

       3. If IsCallable (#sec-9.11)(func) is false, throw a TypeError
          exception.

       4. Let R be the result of calling the [[Call]] internal method
          of func providing elementObj as the this value and an empty
          arguments list.

  9. Let k be 1.

 10. Repeat, while k < len
       1. Let S be a String value produced by concatenating R and
          separator.

       2. Let nextElement be the result of calling the [[Get]] internal
          method of array with argument ToString (#sec-9.8)(k).

       3. If nextElement is undefined or null, then
            1. Let R be the empty String.

       4. Else
            1. Let elementObj be ToObject (#sec-9.9)(nextElement).

            2. Let func be the result of calling the [[Get]] internal
               method of elementObj with argument "toLocaleString".

            3. If IsCallable (#sec-9.11)(func) is false, throw a
               TypeError exception.

            4. Let R be the result of calling the [[Call]] internal
               method of func providing elementObj as the this value
               and an empty arguments list.

       5. Let R be a String value produced by concatenating S and R.

       6. Increase k by 1.

 11. Return R.

   NOTE 1 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.

   NOTE 2 The toLocaleString function is intentionally generic; it does
not require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
toLocaleString function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 15444 Arrayprototypeconcat [ item1 [ item2 [ ] ] ],  Next: 15445 Arrayprototypejoin separator,  Prev: 15443 ArrayprototypetoLocaleString,  Up: Top

349 15.4.4.4 (#sec-15.4.4.4) Array.prototype.concat ( [ item1 [ , item2 [ , ... ] ] ] )
***************************************************************************************

When the concat method is called with zero or more arguments item1,
item2, etc., it returns an array containing the array elements
(#def-array-element) of the object followed by the array elements
(#def-array-element) of each argument in order.

   The following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let A be a new array created as if by the expression `new Array()'
     where `Array' is the standard built-in constructor with that name.

  3. Let n be 0.

  4. Let items be an internal List (#sec-8.8) whose first element is O
     and whose subsequent elements are, in left to right order, the
     arguments that were passed to this function invocation.

  5. Repeat, while items is not empty
       1. Remove the first element from items and let E be the value of
          the element.

       2. If the value of the [[Class]] internal property of E is
          "Array", then
            1. Let k be 0.

            2. Let len be the result of calling the [[Get]] internal
               method of E with argument "length".

            3. Repeat, while k < len
                 1. Let P be ToString (#sec-9.8)(k).

                 2. Let exists be the result of calling the
                    [[HasProperty]] internal method of E with P.

                 3. If exists is true, then
                      1. Let subElement be the result of calling the
                         [[Get]] internal method of E with argument P.

                      2. Call the [[DefineOwnProperty]] internal method
                         of A with arguments ToString (#sec-9.8)(n),
                         Property Descriptor (#sec-8.10) {[[Value]]:
                         subElement, [[Writable]]: true,
                         [[Enumerable]]: true, [[Configurable]]: true},
                         and false.

                 4. Increase n by 1.

                 5. Increase k by 1.


       3. Else, E is not an Array
            1. Call the [[DefineOwnProperty]] internal method of A with
               arguments ToString (#sec-9.8)(n), Property Descriptor
               (#sec-8.10) {[[Value]]: E, [[Writable]]: true,
               [[Enumerable]]: true, [[Configurable]]: true}, and false.

            2. Increase n by 1.


  6. Return A.

   The `length' property of the concat method is 1.

   NOTE The concat function is intentionally generic; it does not
require that its this value be an Array object.

   Therefore it can be transferred to other kinds of objects for use as
a method. Whether the concat function can be applied successfully to a
host object is implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 15445 Arrayprototypejoin separator,  Next: 15446 Arrayprototypepop,  Prev: 15444 Arrayprototypeconcat [ item1 [ item2 [ ] ] ],  Up: Top

350 15.4.4.5 (#sec-15.4.4.5) Array.prototype.join (separator)
*************************************************************

The elements (#def-array-element) of the array are converted to
Strings, and these Strings are then concatenated, separated by
occurrences of the separator. If no separator is provided, a single
comma is used as the separator.

   The join method takes one argument, separator, and performs the
following steps:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenVal be the result of calling the [[Get]] internal method of
     O with argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenVal).

  4. If separator is undefined, let separator be the single-character
     String ",".

  5. Let sep be ToString (#sec-9.8)(separator).

  6. If len is zero, return the empty String.

  7. Let element0 be the result of calling the [[Get]] internal method
     of O with argument "0".

  8. If element0 is undefined or null, let R be the empty String;
     otherwise, Let R be ToString (#sec-9.8)(element0).

  9. Let k be 1.

 10. Repeat, while k < len
       1. Let S be the String value produced by concatenating R and sep.

       2. Let element be the result of calling the [[Get]] internal
          method of O with argument ToString (#sec-9.8)(k).

       3. If element is undefined or null, Let next be the empty
          String; otherwise, let next be ToString (#sec-9.8)(element).

       4. Let R be a String value produced by concatenating S and next.

       5. Increase k by 1.

 11. Return R.

   The `length' property of the join method is 1.

   NOTE The join function is intentionally generic; it does not require
that its this value be an Array object. Therefore, it can be
transferred to other kinds of objects for use as a method. Whether the
join function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 15446 Arrayprototypepop,  Next: 15447 Arrayprototypepush [ item1 [ item2 [ ] ] ],  Prev: 15445 Arrayprototypejoin separator,  Up: Top

351 15.4.4.6 (#sec-15.4.4.6) Array.prototype.pop ( )
****************************************************

The last element (#def-array-element) of the array is removed from the
array and returned.

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenVal be the result of calling the [[Get]] internal method of
     O with argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenVal).

  4. If len is zero,
       1. Call the [[Put]] internal method of O with arguments
          "length", 0, and true.

       2. Return undefined.

  5. Else, len > 0
       1. Let indx be ToString (#sec-9.8)(len−1).

       2. Let element be the result of calling the [[Get]] internal
          method of O with argument indx.

       3. Call the [[Delete]] internal method of O with arguments indx
          and true.

       4. Call the [[Put]] internal method of O with arguments
          "length", indx, and true.

       5. Return element.


   NOTE The pop function is intentionally generic; it does not require
that its this value be an Array object. Therefore it can be transferred
to other kinds of objects for use as a method. Whether the pop function
can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 15447 Arrayprototypepush [ item1 [ item2 [ ] ] ],  Next: 15448 Arrayprototypereverse,  Prev: 15446 Arrayprototypepop,  Up: Top

352 15.4.4.7 (#sec-15.4.4.7) Array.prototype.push ( [ item1 [ , item2 [ , ... ] ] ] )
*************************************************************************************

The arguments are appended to the end of the array, in the order in
which they appear. The new length of the array is returned as the
result of the call.

   When the push method is called with zero or more arguments item1,
item2, etc., the following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenVal be the result of calling the [[Get]] internal method of
     O with argument "length".

  3. Let n be ToUint32 (#sec-9.6)(lenVal).

  4. Let items be an internal List (#sec-8.8) whose elements are, in
     left to right order, the arguments that were passed to this
     function invocation.

  5. Repeat, while items is not empty
       1. Remove the first element from items and let E be the value of
          the element.

       2. Call the [[Put]] internal method of O with arguments ToString
          (#sec-9.8)(n), E, and true.

       3. Increase n by 1.

  6. Call the [[Put]] internal method of O with arguments "length", n,
     and true.

  7. Return n.

   The `length' property of the push method is 1.

   NOTE The push function is intentionally generic; it does not require
that its this value be an Array object. Therefore it can be transferred
to other kinds of objects for use as a method. Whether the push
function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 15448 Arrayprototypereverse,  Next: 15449 Arrayprototypeshift,  Prev: 15447 Arrayprototypepush [ item1 [ item2 [ ] ] ],  Up: Top

353 15.4.4.8 (#sec-15.4.4.8) Array.prototype.reverse ( )
********************************************************

The elements (#def-array-element) of the array are rearranged so as to
reverse their order. The object is returned as the result of the call.

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenVal be the result of calling the [[Get]] internal method of
     O with argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenVal).

  4. Let middle be floor (#def-floor)(len/2).

  5. Let lower be 0.

  6. Repeat, while lower ≠ middle
       1. Let upper be len−lower−1.

       2. Let upperP be ToString (#sec-9.8)(upper).

       3. Let lowerP be ToString (#sec-9.8)(lower).

       4. Let lowerValue be the result of calling the [[Get]] internal
          method of O with argument lowerP.

       5. Let upperValue be the result of calling the [[Get]] internal
          method of O with argument upperP .

       6. Let lowerExists be the result of calling the [[HasProperty]]
          internal method of O with argument lowerP.

       7. Let upperExists be the result of calling the [[HasProperty]]
          internal method of O with argument upperP.

       8. If lowerExists is true and upperExists is true, then
            1. Call the [[Put]] internal method of O with arguments
               lowerP, upperValue, and true .

            2. Call the [[Put]] internal method of O with arguments
               upperP, lowerValue, and true .

       9. Else if lowerExists is false and upperExists is true, then
            1. Call the [[Put]] internal method of O with arguments
               lowerP, upperValue, and true .

            2. Call the [[Delete]] internal method of O, with arguments
               upperP and true.

      10. Else if lowerExists is true and upperExists is false, then
            1. Call the [[Delete]] internal method of O, with arguments
               lowerP and true .

            2. Call the [[Put]] internal method of O with arguments
               upperP, lowerValue, and true .

      11. Else, both lowerExists and upperExists are false
            1. No action is required.

      12. Increase lower by 1.

  7. Return O .

   NOTE The reverse function is intentionally generic; it does not
require that its this value be an Array object. Therefore, it can be
transferred to other kinds of objects for use as a method. Whether the
reverse function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 15449 Arrayprototypeshift,  Next: 154410 Arrayprototypeslice start end,  Prev: 15448 Arrayprototypereverse,  Up: Top

354 15.4.4.9 (#sec-15.4.4.9) Array.prototype.shift ( )
******************************************************

The first element (#def-array-element) of the array is removed from the
array and returned.

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenVal be the result of calling the [[Get]] internal method of
     O with argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenVal).

  4. If len is zero, then
       1. Call the [[Put]] internal method of O with arguments
          "length", 0, and true.

       2. Return undefined.

  5. Let first be the result of calling the [[Get]] internal method of
     O with argument "0".

  6. Let k be 1.

  7. Repeat, while k < len
       1. Let from be ToString (#sec-9.8)(k).

       2. Let to be ToString (#sec-9.8)(k−1).

       3. Let fromPresent be the result of calling the [[HasProperty]]
          internal method of O with argument from.

       4. If fromPresent is true, then
            1. Let fromVal be the result of calling the [[Get]]
               internal method of O with argument from.

            2. Call the [[Put]] internal method of O with arguments to,
               fromVal, and true.

       5. Else, fromPresent is false
            1. Call the [[Delete]] internal method of O with arguments
               to and true.

       6. Increase k by 1.

  8. Call the [[Delete]] internal method of O with arguments ToString
     (#sec-9.8)(len−1) and true.

  9. Call the [[Put]] internal method of O with arguments "length",
     (len−1) , and true.

 10. Return first.

   NOTE The shift function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
shift function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154410 Arrayprototypeslice start end,  Next: 154411 Arrayprototypesort comparefn,  Prev: 15449 Arrayprototypeshift,  Up: Top

355 15.4.4.10 (#sec-15.4.4.10) Array.prototype.slice (start, end)
*****************************************************************

The slice method takes two arguments, start and end, and returns an
array containing the elements (#def-array-element) of the array from
element start up to, but not including, element end (or through the end
of the array if end is undefined). If start is negative, it is treated
as length+start where length is the length of the array. If end is
negative, it is treated as length+end where length is the length of the
array. The following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let A be a new array created as if by the expression `new Array()'
     where `Array' is the standard built-in constructor with that name.

  3. Let lenVal be the result of calling the [[Get]] internal method of
     O with argument "length".

  4. Let len be ToUint32 (#sec-9.6)(lenVal).

  5. Let relativeStart be ToInteger (#sec-9.4)(start).

  6. If relativeStart is negative, let k be max((len +
     relativeStart),0); else let k be min(relativeStart, len).

  7. If end is undefined, let relativeEnd be len; else let relativeEnd
     be ToInteger (#sec-9.4)(end).

  8. If relativeEnd is negative, let final be max((len +
     relativeEnd),0); else let final be min(relativeEnd, len).

  9. Let n be 0.

 10. Repeat, while k < final
       1. Let Pk be ToString (#sec-9.8)(k).

       2. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument Pk.

       3. If kPresent is true, then
            1. Let kValue be the result of calling the [[Get]] internal
               method of O with argument Pk.

            2. Call the [[DefineOwnProperty]] internal method of A with
               arguments ToString (#sec-9.8)(n), Property Descriptor
               (#sec-8.10) {[[Value]]: kValue, [[Writable]]: true,
               [[Enumerable]]: true, [[Configurable]]: true}, and false.

       4. Increase k by 1.

       5. Increase n by 1.

 11. Return A.

   The `length' property of the slice method is 2.

   NOTE The slice function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
slice function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154411 Arrayprototypesort comparefn,  Next: 154412 Arrayprototypesplice start deleteCount [ item1 [ item2 [ ] ] ],  Prev: 154410 Arrayprototypeslice start end,  Up: Top

356 15.4.4.11 (#sec-15.4.4.11) Array.prototype.sort (comparefn)
***************************************************************

The elements (#def-array-element) of this array are sorted. The sort is
not necessarily stable (that is, elements that compare equal do not
necessarily remain in their original order). If comparefn is not
undefined, it should be a function that accepts two arguments x and y
and returns a negative value if x < y, zero if x = y, or a positive
value if x > y.

   Let obj be the result of calling ToObject (#sec-9.9) passing the
this value as the argument.

   Let len be the result of applying Uint32 to the result of calling
the [[Get]] internal method of obj with argument "length".

   If comparefn is not undefined and is not a consistent comparison
function for the elements (#def-array-element) of this array (see
below), the behaviour of sort is implementation-defined.

   Let proto be the value of the [[Prototype]] internal property of
obj. If proto is not null and there exists an integer j such that all
of the conditions below are satisfied then the behaviour of sort is
implementation-defined:

   * obj is sparse (#def-sparse) (15.4 (#sec-15.4))

   * 0 ≤ j < len

   * The result of calling the [[HasProperty]] internal method of proto
     with argument ToString (#sec-9.8)(j) is true.

   The behaviour of sort is also implementation defined if obj is
sparse (#def-sparse) and any of the following conditions are true:

   * The [[Extensible]] internal property of obj is false.

   * Any array index property of obj whose name is a nonnegative
     integer less than len is a data property whose [[Configurable]]
     attribute is false.

   The behaviour of sort is also implementation defined if any array
index property of obj whose name is a nonnegative integer less than len
is an accessor property or is a data property whose [[Writable]]
attribute is false.

   Otherwise, the following steps are taken.

  1. Perform an implementation-dependent sequence of calls to the
     [[Get]] , [[Put]], and [[Delete]] internal methods of obj and to
     SortCompare (described below), where the first argument for each
     call to [[Get]], [[Put]], or [[Delete]] is a nonnegative integer
     less than len and where the arguments for calls to SortCompare are
     results of previous calls to the [[Get]] internal method. The
     throw argument to the [[Put]] and [[Delete]] internal methods will
     be the value true. If obj is not sparse (#def-sparse) then
     [[Delete]] must not be called.

  2. Return obj.

   * There must be some mathematical permutation π of the nonnegative
     integers less than len, such that for every nonnegative integer j
     less than len, if property old[j] existed, then new[Ï€(j)] is
     exactly the same value as old[j]. But if property old[j] did not
     exist, then new[Ï€(j)] does not exist.

   * Then for all nonnegative integers j and k, each less than len, if
     SortCompare(j,k) < 0 (see SortCompare below), then π(j) < π(k).

   Here the notation old[j] is used to refer to the hypothetical result
of calling the [[Get]] internal method of obj with argument j before
this function is executed, and the notation new[j] to refer to the
hypothetical result of calling the [[Get]] internal method of obj with
argument j after this function has been executed.

   A function comparefn is a consistent comparison function for a set
of values S if all of the requirements below are met for all values a,
b, and c (possibly the same value) in the set S: The notation a <_CF_ b
means comparefn(a,b) < 0; a =_CF_ b means comparefn(a,b) = 0 (of either
sign); and a >_CF_ b means comparefn(a,b) > 0.

   * Calling comparefn(a,b) always returns the same value v when given
     a specific pair of values a and b as its two arguments.
     Furthermore, Type (#def-type)(v) is Number, and v is not NaN. Note
     that this implies that exactly one of a <_CF_ b, a =_CF_ b, and a
     >_CF_ b will be true for a given pair of a and b.

   * Calling comparefn(a,b) does not modify the this object.

   * a =_CF_ a (reflexivity)

   * If a =_CF_ b, then b =_CF_ a (symmetry)

   * If a =_CF_ b and b =_CF_ c, then a =_CF_ c (transitivity of =_CF_)

   * If a <_CF_ b and b <_CF_ c, then a <_CF_ c (transitivity of <_CF_)

   * If a >_CF_ b and b >_CF_ c, then a >_CF_ c (transitivity of >_CF_)

   NOTE The above conditions are necessary and sufficient to ensure
that comparefn divides the set S into equivalence classes and that
these equivalence classes are totally ordered.

   When the SortCompare abstract operation is called with two arguments
j and k, the following steps are taken:

  1. Let jString be ToString (#sec-9.8)(j).

  2. Let kString be ToString (#sec-9.8)(k).

  3. Let hasj be the result of calling the [[HasProperty]] internal
     method of obj with argument jString.

  4. Let hask be the result of calling the [[HasProperty]] internal
     method of obj with argument kString.

  5. If hasj and hask are both false, then return +0.

  6. If hasj is false, then return 1.

  7. If hask is false, then return −1.

  8. Let x be the result of calling the [[Get]] internal method of obj
     with argument jString.

  9. Let y be the result of calling the [[Get]] internal method of obj
     with argument kString.

 10. If x and y are both undefined, return +0.

 11. If x is undefined, return 1.

 12. If y is undefined, return −1.

 13. If the argument comparefn is not undefined, then
       1. If IsCallable (#sec-9.11)(comparefn) is false, throw a
          TypeError exception.

       2. Return the result of calling the [[Call]] internal method of
          comparefn passing undefined as the this value and with
          arguments x and y.

 14. Let xString be ToString (#sec-9.8)(x).

 15. Let yString be ToString (#sec-9.8)(y).

 16. If xString < yString, return −1.

 17. If xString > yString, return 1.

 18. Return +0.

   NOTE 1 Because non-existent property values always compare greater
than undefined property values, and undefined always compares greater
than any other value, undefined property values always sort to the end
of the result, followed by non-existent property values.

   NOTE 2 The sort function is intentionally generic; it does not
require that its this value be an Array object. Therefore, it can be
transferred to other kinds of objects for use as a method. Whether the
sort function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154412 Arrayprototypesplice start deleteCount [ item1 [ item2 [ ] ] ],  Next: 154413 Arrayprototypeunshift [ item1 [ item2 [ ] ] ],  Prev: 154411 Arrayprototypesort comparefn,  Up: Top

357 15.4.4.12 (#sec-15.4.4.12) Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , ... ] ] ] )
*************************************************************************************************************

When the splice method is called with two or more arguments start,
deleteCount and (optionally) item1, item2, etc., the deleteCount
elements (#def-array-element) of the array starting at array index
start are replaced by the arguments item1, item2, etc. An Array object
containing the deleted elements (#def-array-element) (if any) is
returned. The following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let A be a new array created as if by the expression `new Array()'
     where `Array' is the standard built-in constructor with that name.

  3. Let lenVal be the result of calling the [[Get]] internal method of
     O with argument "length".

  4. Let len be ToUint32 (#sec-9.6)(lenVal).

  5. Let relativeStart be ToInteger (#sec-9.4)(start).

  6. If relativeStart is negative, let actualStart be max((len +
     relativeStart),0); else let actualStart be min(relativeStart, len).

  7. Let actualDeleteCount be min(max(ToInteger
     (#sec-9.4)(deleteCount),0), len − actualStart).

  8. Let k be 0.

  9. Repeat, while k < actualDeleteCount
       1. Let from be ToString (#sec-9.8)(relativeStart+k).

       2. Let fromPresent be the result of calling the [[HasProperty]]
          internal method of O with argument from.

       3. If fromPresent is true, then
            1. Let fromValue be the result of calling the [[Get]]
               internal method of O with argument from.

            2. Call the [[DefineOwnProperty]] internal method of A with
               arguments ToString (#sec-9.8)(k), Property Descriptor
               (#sec-8.10) {[[Value]]: fromValue, [[Writable]]: true,
               [[Enumerable]]: true, [[Configurable]]: true}, and false.

       4. Increment k by 1.

 10. Let items be an internal List (#sec-8.8) whose elements are, in
     left to right order, the portion of the actual argument list
     starting with item1. The list will be empty if no such items are
     present.

 11. Let itemCount be the number of elements in items.

 12. If itemCount < actualDeleteCount, then
       1. Let k be actualStart.

       2. Repeat, while k < (len − actualDeleteCount)
            1. Let from be ToString (#sec-9.8)(k+actualDeleteCount).

            2. Let to be ToString (#sec-9.8)(k+itemCount).

            3. Let fromPresent be the result of calling the
               [[HasProperty]] internal method of O with argument from.

            4. If fromPresent is true, then
                 1. Let fromValue be the result of calling the [[Get]]
                    internal method of O with argument from.

                 2. Call the [[Put]] internal method of O with
                    arguments to, fromValue, and true.

            5. Else, fromPresent is false
                 1. Call the [[Delete]] internal method of O with
                    arguments to and true.

            6. Increase k by 1.

       3. Let k be len.

       4. Repeat, while k > (len − actualDeleteCount + itemCount)
            1. Call the [[Delete]] internal method of O with arguments
               ToString (#sec-9.8)(k−1) and true.

            2. Decrease k by 1.


 13. Else if itemCount > actualDeleteCount, then
       1. Let k be (len − actualDeleteCount).

       2. Repeat, while k > actualStart
            1. Let from be ToString (#sec-9.8)(k + actualDeleteCount
               − 1).

            2. Let to be ToString (#sec-9.8)(k + itemCount − 1)

            3. Let fromPresent be the result of calling the
               [[HasProperty]] internal method of O with argument from.

            4. If fromPresent is true, then
                 1. Let fromValue be the result of calling the [[Get]]
                    internal method of O with argument from.

                 2. Call the [[Put]] internal method of O with
                    arguments to, fromValue, and true.

            5. Else, fromPresent is false
                 1. Call the [[Delete]] internal method of O with
                    argument to and true.

            6. Decrease k by 1.


 14. Let k be actualStart.

 15. Repeat, while items is not empty
       1. Remove the first element from items and let E be the value of
          that element.

       2. Call the [[Put]] internal method of O with arguments ToString
          (#sec-9.8)(k), E, and true.

       3. Increase k by 1.

 16. Call the [[Put]] internal method of O with arguments "length",
     (len − actualDeleteCount + itemCount), and true.

 17. Return A.

   The `length' property of the splice method is 2.

   NOTE The splice function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
splice function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154413 Arrayprototypeunshift [ item1 [ item2 [ ] ] ],  Next: 154414 ArrayprototypeindexOf searchElement [ fromIndex ],  Prev: 154412 Arrayprototypesplice start deleteCount [ item1 [ item2 [ ] ] ],  Up: Top

358 15.4.4.13 (#sec-15.4.4.13) Array.prototype.unshift ( [ item1 [ , item2 [ , ... ] ] ] )
******************************************************************************************

The arguments are prepended to the start of the array, such that their
order within the array is the same as the order in which they appear in
the argument list.

   When the unshift method is called with zero or more arguments item1,
item2, etc., the following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenVal be the result of calling the [[Get]] internal method of
     O with argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenVal).

  4. Let argCount be the number of actual arguments.

  5. Let k be len.

  6. Repeat, while k > 0,
       1. Let from be ToString (#sec-9.8)(k−1).

       2. Let to be ToString (#sec-9.8)(k+argCount −1).

       3. Let fromPresent be the result of calling the [[HasProperty]]
          internal method of O with argument from.

       4. If fromPresent is true, then
            1. Let fromValue be the result of calling the [[Get]]
               internal method of O with argument from.

            2. Call the [[Put]] internal method of O with arguments to,
               fromValue, and true.

       5. Else, fromPresent is false
            1. Call the [[Delete]] internal method of O with arguments
               to, and true.

       6. Decrease k by 1.

  7. Let j be 0.

  8. Let items be an internal List (#sec-8.8) whose elements are, in
     left to right order, the arguments that were passed to this
     function invocation.

  9. Repeat, while items is not empty
       1. Remove the first element from items and let E be the value of
          that element.

       2. Call the [[Put]] internal method of O with arguments ToString
          (#sec-9.8)(j), E, and true.

       3. Increase j by 1.

 10. Call the [[Put]] internal method of O with arguments "length",
     len+argCount, and true.

 11. Return len+argCount.

   The `length' property of the unshift method is 1.

   NOTE The unshift function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
unshift function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154414 ArrayprototypeindexOf searchElement [ fromIndex ],  Next: 154415 ArrayprototypelastIndexOf searchElement [ fromIndex ],  Prev: 154413 Arrayprototypeunshift [ item1 [ item2 [ ] ] ],  Up: Top

359 15.4.4.14 (#sec-15.4.4.14) Array.prototype.indexOf ( searchElement [ , fromIndex ] )
****************************************************************************************

indexOf compares searchElement to the elements of the array, in
ascending order, using the internal Strict Equality Comparison
Algorithm (11.9.6) (#sec-11.9.6), and if found at one or more
positions, returns the index of the first such position; otherwise,
−1 is returned.

   The optional second argument fromIndex defaults to 0 (i.e. the whole
array is searched). If it is greater than or equal to the length of the
array, −1 is returned, i.e. the array will not be searched. If it is
negative, it is used as the offset from the end of the array to compute
fromIndex. If the computed index is less than 0, the whole array will
be searched.

   When the indexOf method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue).

  4. If len is 0, return −1.

  5. If argument fromIndex was passed let n be ToInteger
     (#sec-9.4)(fromIndex); else let n be 0.

  6. If n ≥ len, return −1.

  7. If n ≥ 0, then
       1. Let k be n.

  8. Else, n<0
       1. Let k be len − abs (#def-abs)(n).

       2. If k is less than 0, then let k be 0.

  9. Repeat, while k<len
       1. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument ToString (#sec-9.8)(k).

       2. If kPresent is true, then
            1. Let elementK be the result of calling the [[Get]]
               internal method of O with the argument ToString
               (#sec-9.8)(k).

            2. Let same be the result of applying the Strict Equality
               Comparison Algorithm to searchElement and elementK.

            3. If same is true, return k.

       3. Increase k by 1.

 10. Return −1.

   The `length' property of the indexOf method is 1.

   NOTE The indexOf function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
indexOf function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154415 ArrayprototypelastIndexOf searchElement [ fromIndex ],  Next: 154416 Arrayprototypeevery callbackfn [ thisArg ],  Prev: 154414 ArrayprototypeindexOf searchElement [ fromIndex ],  Up: Top

360 15.4.4.15 (#sec-15.4.4.15) Array.prototype.lastIndexOf ( searchElement [ , fromIndex ] )
********************************************************************************************

lastIndexOf compares searchElement to the elements of the array in
descending order using the internal Strict Equality Comparison
Algorithm (11.9.6) (#sec-11.9.6), and if found at one or more
positions, returns the index of the last such position; otherwise, −1
is returned.

   The optional second argument fromIndex defaults to the array’s
length (i.e. the whole array is searched). If it is greater than or
equal to the length of the array, the whole array will be searched. If
it is negative, it is used as the offset from the end of the array to
compute fromIndex. If the computed index is less than 0, −1 is
returned.

   When the lastIndexOf method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue).

  4. If len is 0, return −1.

  5. If argument fromIndex was passed let n be ToInteger
     (#sec-9.4)(fromIndex); else let n be len.

  6. If n ≥ 0, then let k be min(n, len − 1).

  7. Else, n < 0
       1. Let k be len − abs (#def-abs)(n).

  8. Repeat, while k≥0
       1. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument ToString (#sec-9.8)(k).

       2. If kPresent is true, then
            1. Let elementK be the result of calling the [[Get]]
               internal method of O with the argument ToString
               (#sec-9.8)(k).

            2. Let same be the result of applying the Strict Equality
               Comparision Algorithm to searchElement and elementK.

            3. If same is true, return k.

       3. Decrease k by 1.

  9. Return −1.

   The `length' property of the lastIndexOf method is 1.

   NOTE The lastIndexOf function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
lastIndexOf function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154416 Arrayprototypeevery callbackfn [ thisArg ],  Next: 154417 Arrayprototypesome callbackfn [ thisArg ],  Prev: 154415 ArrayprototypelastIndexOf searchElement [ fromIndex ],  Up: Top

361 15.4.4.16 (#sec-15.4.4.16) Array.prototype.every ( callbackfn [ , thisArg ] )
*********************************************************************************

callbackfn should be a function that accepts three arguments and
returns a value that is coercible to the Boolean value true or false.
every calls callbackfn once for each element (#def-array-element)
present in the array, in ascending order, until it finds one where
callbackfn returns false. If such an element is found, every
immediately returns false. Otherwise, if callbackfn returned true for
all elements, every will return true. callbackfn is called only for
elements of the array which actually exist; it is not called for
missing elements of the array.

   If a thisArg parameter is provided, it will be used as the this
value for each invocation of callbackfn. If it is not provided,
undefined is used instead.

   callbackfn is called with three arguments: the value of the element,
the index of the element, and the object being traversed.

   every does not directly mutate the object on which it is called but
the object may be mutated by the calls to callbackfn.

   The range of elements processed by every is set before the first
call to callbackfn. Elements which are appended to the array after the
call to every begins will not be visited by callbackfn. If existing
elements of the array are changed, their value as passed to callbackfn
will be the value at the time every visits them; elements that are
deleted after the call to every begins and before being visited are not
visited. every acts like the “for all” quantifier in mathematics.
In particular, for an empty array, it returns true.

   When the every method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue).

  4. If IsCallable (#sec-9.11)(callbackfn) is false, throw a TypeError
     exception.

  5. If thisArg was supplied, let T be thisArg; else let T be undefined.

  6. Let k be 0.

  7. Repeat, while k < len
       1. Let Pk be ToString (#sec-9.8)(k).

       2. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument Pk.

       3. If kPresent is true, then
            1. Let kValue be the result of calling the [[Get]] internal
               method of O with argument Pk.

            2. Let testResult be the result of calling the [[Call]]
               internal method of callbackfn with T as the this value
               and argument list containing kValue, k, and O.

            3. If ToBoolean (#sec-9.2)(testResult) is false, return
               false.

       4. Increase k by 1.

  8. Return true.

   The `length' property of the every method is 1.

   NOTE The every function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
every function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154417 Arrayprototypesome callbackfn [ thisArg ],  Next: 154418 ArrayprototypeforEach callbackfn [ thisArg ],  Prev: 154416 Arrayprototypeevery callbackfn [ thisArg ],  Up: Top

362 15.4.4.17 (#sec-15.4.4.17) Array.prototype.some ( callbackfn [ , thisArg ] )
********************************************************************************

callbackfn should be a function that accepts three arguments and
returns a value that is coercible to the Boolean value true or false.
some calls callbackfn once for each element (#def-array-element)
present in the array, in ascending order, until it finds one where
callbackfn returns true. If such an element is found, some immediately
returns true. Otherwise, some returns false. callbackfn is called only
for elements of the array which actually exist; it is not called for
missing elements of the array.

   If a thisArg parameter is provided, it will be used as the this
value for each invocation of callbackfn. If it is not provided,
undefined is used instead.

   callbackfn is called with three arguments: the value of the element,
the index of the element, and the object being traversed.

   some does not directly mutate the object on which it is called but
the object may be mutated by the calls to callbackfn.

   The range of elements processed by some is set before the first call
to callbackfn. Elements that are appended to the array after the call
to some begins will not be visited by callbackfn. If existing elements
of the array are changed, their value as passed to callbackfn will be
the value at the time that some visits them; elements that are deleted
after the call to some begins and before being visited are not visited.
some acts like the “exists” quantifier in mathematics. In
particular, for an empty array, it returns false.

   When the some method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue).

  4. If IsCallable (#sec-9.11)(callbackfn) is false, throw a TypeError
     exception.

  5. If thisArg was supplied, let T be thisArg; else let T be undefined.

  6. Let k be 0.

  7. Repeat, while k < len
       1. Let Pk be ToString (#sec-9.8)(k).

       2. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument Pk.

       3. If kPresent is true, then
            1. Let kValue be the result of calling the [[Get]] internal
               method of O with argument Pk.

            2. Let testResult be the result of calling the [[Call]]
               internal method of callbackfn with T as the this value
               and argument list containing kValue, k, and O.

            3. If ToBoolean (#sec-9.2)(testResult) is true, return true.

       4. Increase k by 1.

  8. Return false.

   The `length' property of the some method is 1.

   NOTE The some function is intentionally generic; it does not require
that its this value be an Array object. Therefore it can be transferred
to other kinds of objects for use as a method. Whether the some
function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154418 ArrayprototypeforEach callbackfn [ thisArg ],  Next: 154419 Arrayprototypemap callbackfn [ thisArg ],  Prev: 154417 Arrayprototypesome callbackfn [ thisArg ],  Up: Top

363 15.4.4.18 (#sec-15.4.4.18) Array.prototype.forEach ( callbackfn [ , thisArg ] )
***********************************************************************************

callbackfn should be a function that accepts three arguments. forEach
calls callbackfn once for each element (#def-array-element) present in
the array, in ascending order. callbackfn is called only for elements
of the array which actually exist; it is not called for missing
elements of the array.

   If a thisArg parameter is provided, it will be used as the this
value for each invocation of callbackfn. If it is not provided,
undefined is used instead.

   callbackfn is called with three arguments: the value of the element,
the index of the element, and the object being traversed.

   forEach does not directly mutate the object on which it is called
but the object may be mutated by the calls to callbackfn.

   The range of elements processed by forEach is set before the first
call to callbackfn. Elements which are appended to the array after the
call to forEach begins will not be visited by callbackfn. If existing
elements of the array are changed, their value as passed to callback
will be the value at the time forEach visits them; elements that are
deleted after the call to forEach begins and before being visited are
not visited.

   When the forEach method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue).

  4. If IsCallable (#sec-9.11)(callbackfn) is false, throw a TypeError
     exception.

  5. If thisArg was supplied, let T be thisArg; else let T be undefined.

  6. Let k be 0.

  7. Repeat, while k < len
       1. Let Pk be ToString (#sec-9.8)(k).

       2. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument Pk.

       3. If kPresent is true, then
            1. Let kValue be the result of calling the [[Get]] internal
               method of O with argument Pk.

            2. Call the [[Call]] internal method of callbackfn with T
               as the this value and argument list containing kValue,
               k, and O.

       4. Increase k by 1.

  8. Return undefined.

   The `length' property of the forEach method is 1.

   NOTE The forEach function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
forEach function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154419 Arrayprototypemap callbackfn [ thisArg ],  Next: 154420 Arrayprototypefilter callbackfn [ thisArg ],  Prev: 154418 ArrayprototypeforEach callbackfn [ thisArg ],  Up: Top

364 15.4.4.19 (#sec-15.4.4.19) Array.prototype.map ( callbackfn [ , thisArg ] )
*******************************************************************************

callbackfn should be a function that accepts three arguments. map calls
callbackfn once for each element (#def-array-element) in the array, in
ascending order, and constructs a new Array from the results.
callbackfn is called only for elements of the array which actually
exist; it is not called for missing elements of the array.

   If a thisArg parameter is provided, it will be used as the this
value for each invocation of callbackfn. If it is not provided,
undefined is used instead.

   callbackfn is called with three arguments: the value of the element,
the index of the element, and the object being traversed.

   map does not directly mutate the object on which it is called but
the object may be mutated by the calls to callbackfn.

   When the map method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue).

  4. If IsCallable (#sec-9.11)(callbackfn) is false, throw a TypeError
     exception.

  5. If thisArg was supplied, let T be thisArg; else let T be undefined.

  6. Let A be a new array created as if by the expression `new
     Array(<var>len</var>)' where `Array' is the standard built-in
     constructor with that name and len is the value of len.

  7. Let k be 0.

  8. Repeat, while k < len
       1. Let Pk be ToString (#sec-9.8)(k).

       2. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument Pk.

       3. If kPresent is true, then
            1. Let kValue be the result of calling the [[Get]] internal
               method of O with argument Pk.

            2. Let mappedValue be the result of calling the [[Call]]
               internal method of callbackfn with T as the this value
               and argument list containing kValue, k, and O.

            3. Call the [[DefineOwnProperty]] internal method of A with
               arguments Pk, Property Descriptor (#sec-8.10)
               {[[Value]]: mappedValue, [[Writable]]: true,
               [[Enumerable]]: true, [[Configurable]]: true}, and false.

       4. Increase k by 1.

  9. Return A.

   The `length' property of the map method is 1.

   NOTE The map function is intentionally generic; it does not require
that its this value be an Array object. Therefore it can be transferred
to other kinds of objects for use as a method. Whether the map function
can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154420 Arrayprototypefilter callbackfn [ thisArg ],  Next: 154421 Arrayprototypereduce callbackfn [ initialValue ],  Prev: 154419 Arrayprototypemap callbackfn [ thisArg ],  Up: Top

365 15.4.4.20 (#sec-15.4.4.20) Array.prototype.filter ( callbackfn [ , thisArg ] )
**********************************************************************************

callbackfn should be a function that accepts three arguments and
returns a value that is coercible to the Boolean value true or false.
filter calls callbackfn once for each element (#def-array-element) in
the array, in ascending order, and constructs a new array of all the
values for which callbackfn returns true. callbackfn is called only for
elements of the array which actually exist; it is not called for
missing elements of the array.

   If a thisArg parameter is provided, it will be used as the this
value for each invocation of callbackfn. If it is not provided,
undefined is used instead.

   callbackfn is called with three arguments: the value of the element,
the index of the element, and the object being traversed.

   filter does not directly mutate the object on which it is called but
the object may be mutated by the calls to callbackfn.

   The range of elements processed by filter is set before the first
call to callbackfn. Elements which are appended to the array after the
call to filter begins will not be visited by callbackfn. If existing
elements of the array are changed their value as passed to callbackfn
will be the value at the time filter visits them; elements that are
deleted after the call to filter begins and before being visited are
not visited.

   When the filter method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue).

  4. If IsCallable (#sec-9.11)(callbackfn) is false, throw a TypeError
     exception.

  5. If thisArg was supplied, let T be thisArg; else let T be undefined.

  6. Let A be a new array created as if by the expression `new Array()'
     where `Array' is the standard built-in constructor with that name.

  7. Let k be 0.

  8. Let to be 0.

  9. Repeat, while k < len
       1. Let Pk be ToString (#sec-9.8)(k).

       2. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument Pk.

       3. If kPresent is true, then
            1. Let kValue be the result of calling the [[Get]] internal
               method of O with argument Pk.

            2. Let selected be the result of calling the [[Call]]
               internal method of callbackfn with T as the this value
               and argument list containing kValue, k, and O.

            3. If ToBoolean (#sec-9.2)(selected) is true, then
                 1. Call the [[DefineOwnProperty]] internal method of A
                    with arguments ToString (#sec-9.8)(to), Property
                    Descriptor (#sec-8.10) {[[Value]]: kValue,
                    [[Writable]]: true, [[Enumerable]]: true,
                    [[Configurable]]: true}, and false.

                 2. Increase to by 1.


       4. Increase k by 1.

 10. Return A.

   The `length' property of the filter method is 1.

   NOTE The filter function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
filter function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154421 Arrayprototypereduce callbackfn [ initialValue ],  Next: 154422 ArrayprototypereduceRight callbackfn [ initialValue ],  Prev: 154420 Arrayprototypefilter callbackfn [ thisArg ],  Up: Top

366 15.4.4.21 (#sec-15.4.4.21) Array.prototype.reduce ( callbackfn [ , initialValue ] )
***************************************************************************************

callbackfn should be a function that takes four arguments. reduce calls
the callback, as a function, once for each element (#def-array-element)
present in the array, in ascending order.

   callbackfn is called with four arguments: the previousValue (or
value from the previous call to callbackfn), the currentValue (value of
the current element), the currentIndex, and the object being traversed.
The first time that callback is called, the previousValue and
currentValue can be one of two values. If an initialValue was provided
in the call to reduce, then previousValue will be equal to initialValue
and currentValue will be equal to the first value in the array. If no
initialValue was provided, then previousValue will be equal to the
first value in the array and currentValue will be equal to the second.
It is a TypeError if the array contains no elements and initialValue is
not provided.

   reduce does not directly mutate the object on which it is called but
the object may be mutated by the calls to callbackfn.

   The range of elements processed by reduce is set before the first
call to callbackfn. Elements that are appended to the array after the
call to reduce begins will not be visited by callbackfn. If existing
elements of the array are changed, their value as passed to callbackfn
will be the value at the time reduce visits them; elements that are
deleted after the call to reduce begins and before being visited are
not visited.

   When the reduce method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue ).

  4. If IsCallable (#sec-9.11)(callbackfn) is false, throw a TypeError
     exception.

  5. If len is 0 and initialValue is not present, throw a TypeError
     exception.

  6. Let k be 0.

  7. If initialValue is present, then
       1. Set accumulator to initialValue.

  8. Else, initialValue is not present
       1. Let kPresent be false.

       2. Repeat, while kPresent is false and k < len
            1. Let Pk be ToString (#sec-9.8)(k).

            2. Let kPresent be the result of calling the
               [[HasProperty]] internal method of O with argument Pk.

            3. If kPresent is true, then
                 1. Let accumulator be the result of calling the
                    [[Get]] internal method of O with argument Pk.

            4. Increase k by 1.

       3. If kPresent is false, throw a TypeError exception.

  9. Repeat, while k < len
       1. Let Pk be ToString (#sec-9.8)(k).

       2. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument Pk.

       3. If kPresent is true, then
            1. Let kValue be the result of calling the [[Get]] internal
               method of O with argument Pk.

            2. Let accumulator be the result of calling the [[Call]]
               internal method of callbackfn with undefined as the this
               value and argument list containing accumulator, kValue,
               k, and O.

       4. Increase k by 1.

 10. Return accumulator.

   The `length' property of the reduce method is 1.

   NOTE The reduce function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
reduce function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 154422 ArrayprototypereduceRight callbackfn [ initialValue ],  Next: 1545 Properties of Array Instances,  Prev: 154421 Arrayprototypereduce callbackfn [ initialValue ],  Up: Top

367 15.4.4.22 (#sec-15.4.4.22) Array.prototype.reduceRight ( callbackfn [ , initialValue ] )
********************************************************************************************

callbackfn should be a function that takes four arguments. reduceRight
calls the callback, as a function, once for each element
(#def-array-element) present in the array, in descending order.

   callbackfn is called with four arguments: the previousValue (or
value from the previous call to callbackfn), the currentValue (value of
the current element), the currentIndex, and the object being traversed.
The first time the function is called, the previousValue and
currentValue can be one of two values. If an initialValue was provided
in the call to reduceRight, then previousValue will be equal to
initialValue and currentValue will be equal to the last value in the
array. If no initialValue was provided, then previousValue will be
equal to the last value in the array and currentValue will be equal to
the second-to-last value. It is a TypeError if the array contains no
elements and initialValue is not provided.

   reduceRight does not directly mutate the object on which it is
called but the object may be mutated by the calls to callbackfn.

   The range of elements processed by reduceRight is set before the
first call to callbackfn. Elements that are appended to the array after
the call to reduceRight begins will not be visited by callbackfn. If
existing elements of the array are changed by callbackfn, their value
as passed to callbackfn will be the value at the time reduceRight
visits them; elements that are deleted after the call to reduceRight
begins and before being visited are not visited.

   When the reduceRight method is called with one or two arguments, the
following steps are taken:

  1. Let O be the result of calling ToObject (#sec-9.9) passing the
     this value as the argument.

  2. Let lenValue be the result of calling the [[Get]] internal method
     of O with the argument "length".

  3. Let len be ToUint32 (#sec-9.6)(lenValue ).

  4. If IsCallable (#sec-9.11)(callbackfn) is false, throw a TypeError
     exception.

  5. If len is 0 and initialValue is not present, throw a TypeError
     exception.

  6. Let k be len−1.

  7. If initialValue is present, then
       1. Set accumulator to initialValue.

  8. Else, initialValue is not present
       1. Let kPresent be false.

       2. Repeat, while kPresent is false and k ≥ 0
            1. Let Pk be ToString (#sec-9.8)(k).

            2. Let kPresent be the result of calling the
               [[HasProperty]] internal method of O with argument Pk.

            3. If kPresent is true, then
                 1. Let accumulator be the result of calling the
                    [[Get]] internal method of O with argument Pk.

            4. Decrease k by 1.

       3. If kPresent is false, throw a TypeError exception.

  9. Repeat, while k ≥ 0
       1. Let Pk be ToString (#sec-9.8)(k).

       2. Let kPresent be the result of calling the [[HasProperty]]
          internal method of O with argument Pk.

       3. If kPresent is true, then
            1. Let kValue be the result of calling the [[Get]] internal
               method of O with argument Pk.

            2. Let accumulator be the result of calling the [[Call]]
               internal method of callbackfn with undefined as the this
               value and argument list containing accumulator, kValue,
               k, and O.

       4. Decrease k by 1.

 10. Return accumulator.

   The `length' property of the reduceRight method is 1.

   NOTE The reduceRight function is intentionally generic; it does not
require that its this value be an Array object. Therefore it can be
transferred to other kinds of objects for use as a method. Whether the
reduceRight function can be applied successfully to a host object is
implementation-dependent.


File: javascript_ecma_262_5th_ed.info,  Node: 1545 Properties of Array Instances,  Next: 15451 [[DefineOwnProperty]] P Desc Throw,  Prev: 154422 ArrayprototypereduceRight callbackfn [ initialValue ],  Up: Top

368 15.4.5 (#sec-15.4.5) Properties of Array Instances
******************************************************

Array instances inherit properties from the Array prototype object and
their [[Class]] internal property value is "Array". Array instances
also have the following properties.


File: javascript_ecma_262_5th_ed.info,  Node: 15451 [[DefineOwnProperty]] P Desc Throw,  Next: 15452 length,  Prev: 1545 Properties of Array Instances,  Up: Top

369 15.4.5.1 (#sec-15.4.5.1) [[DefineOwnProperty]] ( P, Desc, Throw )
*********************************************************************

Array objects use a variation of the [[DefineOwnProperty]] internal
method used for other native ECMAScript objects (8.12.9 (#sec-8.12.9)).

   Assume A is an Array object, Desc is a Property Descriptor
(#sec-8.10), and Throw is a Boolean flag.

   In the following algorithm, the term “Reject” means “If Throw
is true, then throw a TypeError exception, otherwise return false.”

   When the [[DefineOwnProperty]] internal method of A is called with
property P, Property Descriptor (#sec-8.10) Desc, and Boolean flag
Throw, the following steps are taken:

  1. Let oldLenDesc be the result of calling the [[GetOwnProperty]]
     internal method of A passing "length" as the argument. The result
     will never be undefined or an accessor descriptor because Array
     objects are created with a length data property that cannot be
     deleted or reconfigured.

  2. Let oldLen be oldLenDesc.[[Value]].

  3. If P is "length", then
       1. If the [[Value]] field of Desc is absent, then
            1. Return the result of calling the default
               [[DefineOwnProperty]] internal method (8.12.9
               (#sec-8.12.9)) on A passing "length", Desc, and Throw as
               arguments.

       2. Let newLenDesc be a copy of Desc.

       3. Let newLen be ToUint32 (#sec-9.6)(Desc.[[Value]]).

       4. If newLen is not equal to ToNumber (#sec-9.3)(
          Desc.[[Value]]), throw a RangeError exception.

       5. Set newLenDesc.[[Value] to newLen.

       6. If newLen ≥ oldLen, then
            1. Return the result of calling the default
               [[DefineOwnProperty]] internal method (8.12.9
               (#sec-8.12.9)) on A passing "length", newLenDesc, and
               Throw as arguments.

       7. Reject (#def-reject-for-array) if oldLenDesc.[[Writable]] is
          false.

       8. If newLenDesc.[[Writable]] is absent or has the value true,
          let newWritable be true.

       9.            1. Need to defer setting the [[Writable]] attribute to
               false in case any elements (#def-array-element) cannot
               be deleted.

            2. Let newWritable be false.

            3. Set newLenDesc.[[Writable]] to true.

      10. Let succeeded be the result of calling the default
          [[DefineOwnProperty]] internal method (8.12.9 (#sec-8.12.9))
          on A passing "length", newLenDesc, and Throw as arguments.

      11. If succeeded is false, return false.

      12. While newLen < oldLen repeat,
            1. Set oldLen to oldLen − 1.

            2. Let deleteSucceeded be the result of calling the
               [[Delete]] internal method of A passing ToString
               (#sec-9.8)(oldLen) and false as arguments.

            3. If deleteSucceeded is false, then
                 1. Set newLenDesc.[[Value] to oldLen+1.

                 2. If newWritable is false, set newLenDesc.[[Writable]
                    to false.

                 3. Call the default [[DefineOwnProperty]] internal
                    method (8.12.9 (#sec-8.12.9)) on A passing
                    "length", newLenDesc, and false as arguments.

                 4. Reject (#def-reject-for-array).


      13. If newWritable is false, then
            1. Call the default [[DefineOwnProperty]] internal method
               (8.12.9 (#sec-8.12.9)) on A passing "length", Property
               Descriptor (#sec-8.10) {[[Writable]]: false}, and false
               as arguments. This call will always return true.

      14. Return true.

  4. Else if P is an array index (15.4 (#sec-15.4)), then
       1. Let index be ToUint32 (#sec-9.6)(P).

       2. Reject (#def-reject-for-array) if index ≥ oldLen and
          oldLenDesc.[[Writable]] is false.

       3. Let succeeded be the result of calling the default
          [[DefineOwnProperty]] internal method (8.12.9 (#sec-8.12.9))
          on A passing P, Desc, and false as arguments.

       4. Reject (#def-reject-for-array) if succeeded is false.

       5. If index ≥ oldLen
            1. Set oldLenDesc.[[Value]] to index + 1.

            2. Call the default [[DefineOwnProperty]] internal method
               (8.12.9 (#sec-8.12.9)) on A passing "length",
               oldLenDesc, and false as arguments. This call will
               always return true.

       6. Return true.

  5. Return the result of calling the default [[DefineOwnProperty]]
     internal method (8.12.9 (#sec-8.12.9)) on A passing P, Desc, and
     Throw as arguments.


File: javascript_ecma_262_5th_ed.info,  Node: 15452 length,  Next: 155 String Objects,  Prev: 15451 [[DefineOwnProperty]] P Desc Throw,  Up: Top

370 15.4.5.2 (#sec-15.4.5.2) length
***********************************

The `length' property of this Array object is a data property whose
value is always numerically greater than the name of every deletable
property whose name is an array index.

   The `length' property initially has the attributes { [[Writable]]:
true, [[Enumerable]]: false, [[Configurable]]: false }.

   NOTE Attempting to set the length property of an Array object to a
value that is numerically less than or equal to the largest numeric
property name of an existing array indexed non-deletable property of
the array will result in the length being set to a numeric value that
is one greater than that largest numeric property name. See 15.4.5.1
(#sec-15.4.5.1).


File: javascript_ecma_262_5th_ed.info,  Node: 155 String Objects,  Next: 1551 The String Constructor Called as a Function,  Prev: 15452 length,  Up: Top

371 15.5 (#sec-15.5) String Objects
***********************************


File: javascript_ecma_262_5th_ed.info,  Node: 1551 The String Constructor Called as a Function,  Next: 15511 String [ value ],  Prev: 155 String Objects,  Up: Top

372 15.5.1 (#sec-15.5.1) The String Constructor Called as a Function
********************************************************************

When String is called as a function rather than as a constructor, it
performs a type conversion.


File: javascript_ecma_262_5th_ed.info,  Node: 15511 String [ value ],  Next: 1552 The String Constructor,  Prev: 1551 The String Constructor Called as a Function,  Up: Top

373 15.5.1.1 (#sec-15.5.1.1) String ( [ value ] )
*************************************************

Returns a String value (not a String object) computed by ToString
(#sec-9.8)(value). If value is not supplied, the empty String "" is
returned.


File: javascript_ecma_262_5th_ed.info,  Node: 1552 The String Constructor,  Next: 15521 new String [ value ],  Prev: 15511 String [ value ],  Up: Top

374 15.5.2 (#sec-15.5.2) The String Constructor
***********************************************

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


File: javascript_ecma_262_5th_ed.info,  Node: 15521 new String [ value ],  Next: 1553 Properties of the String Constructor,  Prev: 1552 The String Constructor,  Up: Top

375 15.5.2.1 (#sec-15.5.2.1) new String ( [ value ] )
*****************************************************

The [[Prototype]] internal property of the newly constructed object is
set to the standard built-in String prototype object that is the
initial value of String.prototype (15.5.3.1 (#sec-15.5.3.1)).

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

   The [[Extensible]] internal property of the newly constructed object
is set to true.

   The [[PrimitiveValue]] internal property of the newly constructed
object is set to ToString (#sec-9.8)(value), or to the empty String if
value is not supplied.


File: javascript_ecma_262_5th_ed.info,  Node: 1553 Properties of the String Constructor,  Next: 15531 Stringprototype,  Prev: 15521 new String [ value ],  Up: Top

376 15.5.3 (#sec-15.5.3) Properties of the String Constructor
*************************************************************

The value of the [[Prototype]] internal property of the String
constructor is the standard built-in Function prototype object (15.3.4
(#sec-15.3.4)).

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


File: javascript_ecma_262_5th_ed.info,  Node: 15531 Stringprototype,  Next: 15532 StringfromCharCode [ char0 [ char1 [ ] ] ],  Prev: 1553 Properties of the String Constructor,  Up: Top

377 15.5.3.1 (#sec-15.5.3.1) String.prototype
*********************************************

The initial value of String.prototype is the standard built-in String
prototype object (15.5.4 (#sec-15.5.4)).

   This property has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 15532 StringfromCharCode [ char0 [ char1 [ ] ] ],  Next: 1554 Properties of the String Prototype Object,  Prev: 15531 Stringprototype,  Up: Top

378 15.5.3.2 (#sec-15.5.3.2) String.fromCharCode ( [ char0 [ , char1 [ , ... ] ] ] )
************************************************************************************

Returns a String value containing as many characters as the number of
arguments. Each argument specifies one character of the resulting
String, with the first argument specifying the first character, and so
on, from left to right. An argument is converted to a character by
applying the operation ToUint16 (#sec-9.7) (9.7 (#sec-9.7)) and
regarding the resulting 16-bit integer as the code unit value of a
character. If no arguments are supplied, the result is the empty String.

   The `length' property of the fromCharCode function is 1.


File: javascript_ecma_262_5th_ed.info,  Node: 1554 Properties of the String Prototype Object,  Next: 15541 Stringprototypeconstructor,  Prev: 15532 StringfromCharCode [ char0 [ char1 [ ] ] ],  Up: Top

379 15.5.4 (#sec-15.5.4) Properties of the String Prototype Object
******************************************************************

The String prototype object is itself a String object (its [[Class]] is
"String") whose value is an empty String.

   The value of the [[Prototype]] internal property of the String
prototype object is the standard built-in Object prototype object
(15.2.4 (#sec-15.2.4)).


File: javascript_ecma_262_5th_ed.info,  Node: 15541 Stringprototypeconstructor,  Next: 15542 StringprototypetoString,  Prev: 1554 Properties of the String Prototype Object,  Up: Top

380 15.5.4.1 (#sec-15.5.4.1) String.prototype.constructor
*********************************************************

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


File: javascript_ecma_262_5th_ed.info,  Node: 15542 StringprototypetoString,  Next: 15543 StringprototypevalueOf,  Prev: 15541 Stringprototypeconstructor,  Up: Top

381 15.5.4.2 (#sec-15.5.4.2) String.prototype.toString ( )
**********************************************************

Returns this String value. (Note that, for a String object, the
`toString' method happens to return the same thing as the `valueOf'
method.)


File: javascript_ecma_262_5th_ed.info,  Node: 15543 StringprototypevalueOf,  Next: 15544 StringprototypecharAt pos,  Prev: 15542 StringprototypetoString,  Up: Top

382 15.5.4.3 (#sec-15.5.4.3) String.prototype.valueOf ( )
*********************************************************

Returns this String value.

   The valueOf function is not generic; it throws a TypeError exception
if its this value is not a String or String object. Therefore, it
cannot be transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 15544 StringprototypecharAt pos,  Next: 15545 StringprototypecharCodeAt pos,  Prev: 15543 StringprototypevalueOf,  Up: Top

383 15.5.4.4 (#sec-15.5.4.4) String.prototype.charAt (pos)
**********************************************************

Returns a String containing the character at position pos in the String
resulting from converting this object to a String. If there is no
character at that position, the result is the empty String. The result
is a String value, not a String object.

   If pos is a value of Number type that is an integer, then the result
of `x.charAt(<var>pos</var>)' is equal to the result of
`x.substring(<var>pos</var>, <wbr /><var>pos</var>+1)'.

   When the charAt method is called with one argument pos, the
following steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let position be ToInteger (#sec-9.4)(pos).

  4. Let size be the number of characters in S.

  5. If position < 0 or position ≥ size, return the empty String.

  6. Return a String of length 1, containing one character from S,
     namely the character at position position, where the first
     (leftmost) character in S is considered to be at position 0, the
     next one at position 1, and so on.

   NOTE The charAt function is intentionally generic; it does not
require that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 15545 StringprototypecharCodeAt pos,  Next: 15546 Stringprototypeconcat [ string1 [ string2 [ ] ] ],  Prev: 15544 StringprototypecharAt pos,  Up: Top

384 15.5.4.5 (#sec-15.5.4.5) String.prototype.charCodeAt (pos)
**************************************************************

Returns a Number (a nonnegative integer less than 2^16) representing
the code unit value of the character at position pos in the String
resulting from converting this object to a String. If there is no
character at that position, the result is NaN.

   When the charCodeAt method is called with one argument pos, the
following steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let position be ToInteger (#sec-9.4)(pos).

  4. Let size be the number of characters in S.

  5. If position < 0 or position ≥ size, return NaN.

  6. Return a value of Number type, whose value is the code unit value
     of the character at position position in the String S, where the
     first (leftmost) character in S is considered to be at position 0,
     the next one at position 1, and so on.

   NOTE The charCodeAt function is intentionally generic; it does not
require that its this value be a String object. Therefore it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 15546 Stringprototypeconcat [ string1 [ string2 [ ] ] ],  Next: 15547 StringprototypeindexOf searchString position,  Prev: 15545 StringprototypecharCodeAt pos,  Up: Top

385 15.5.4.6 (#sec-15.5.4.6) String.prototype.concat ( [ string1 [ , string2 [ , ... ] ] ] )
********************************************************************************************

When the concat method is called with zero or more arguments string1,
string2, etc., it returns a String consisting of the characters of this
object (converted to a String) followed by the characters of each of
string1, string2, etc. (where each argument is converted to a String).
The result is a String value, not a String object. The following steps
are taken:

  1.  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let args be an internal list that is a copy of the argument list
     passed to this function.

  4. Let R be S.

  5. Repeat, while args is not empty
       1. Remove the first element from args and let next be the value
          of that element.

       2. Let R be the String value consisting of the characters in the
          previous value of R followed by the characters of ToString
          (#sec-9.8)(next).

  6. Return R.

   The `length' property of the concat method is 1.

   NOTE The concat function is intentionally generic; it does not
require that its this value be a String object. Therefore it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 15547 StringprototypeindexOf searchString position,  Next: 15548 StringprototypelastIndexOf searchString position,  Prev: 15546 Stringprototypeconcat [ string1 [ string2 [ ] ] ],  Up: Top

386 15.5.4.7 (#sec-15.5.4.7) String.prototype.indexOf (searchString, position)
******************************************************************************

If searchString appears as a substring of the result of converting this
object to a String, at one or more positions that are greater than or
equal to position, then the index of the smallest such position is
returned; otherwise, −1 is returned. If position is undefined, 0 is
assumed, so as to search all of the String.

   The indexOf method takes two arguments, searchString and position,
and performs the following steps:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let searchStr be ToString (#sec-9.8)(searchString).

  4. Let pos be ToInteger (#sec-9.4)(position). (If position is
     undefined, this step produces the value 0).

  5. Let len be the number of characters in S.

  6. Let start be min(max(pos, 0), len).

  7. Let searchLen be the number of characters in searchStr.

  8. Return the smallest possible integer k not smaller than start such
     that k+searchLen is not greater than len, and for all nonnegative
     integers j less than searchLen, the character at position k+j of S
     is the same as the character at position j of searchStr); but if
     there is no such integer k, then return the value −1.

   The `length' property of the indexOf method is 1.

   NOTE The indexOf function is intentionally generic; it does not
require that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 15548 StringprototypelastIndexOf searchString position,  Next: 15549 StringprototypelocaleCompare that,  Prev: 15547 StringprototypeindexOf searchString position,  Up: Top

387 15.5.4.8 (#sec-15.5.4.8) String.prototype.lastIndexOf (searchString, position)
**********************************************************************************

If searchString appears as a substring of the result of converting this
object to a String at one or more positions that are smaller than or
equal to position, then the index of the greatest such position is
returned; otherwise, −1 is returned. If position is undefined, the
length of the String value is assumed, so as to search all of the
String.

   The lastIndexOf method takes two arguments, searchString and
position, and performs the following steps:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let searchStr be ToString (#sec-9.8)(searchString).

  4. Let numPos be ToNumber (#sec-9.3)(position). (If position is
     undefined, this step produces the value NaN).

  5. If numPos is NaN, let pos be +∞; otherwise, let pos be ToInteger
     (#sec-9.4)(numPos).

  6. Let len be the number of characters in S.

  7. Let start min(max(pos, 0), len).

  8. Let searchLen be the number of characters in searchStr.

  9.
   The `length' property of the lastIndexOf method is 1.

   NOTE The lastIndexOf function is intentionally generic; it does not
require that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 15549 StringprototypelocaleCompare that,  Next: 155410 Stringprototypematch regexp,  Prev: 15548 StringprototypelastIndexOf searchString position,  Up: Top

388 15.5.4.9 (#sec-15.5.4.9) String.prototype.localeCompare (that)
******************************************************************

When the localeCompare method is called with one argument that, it
returns a Number other than NaN that represents the result of a
locale-sensitive String comparison of the this value (converted to a
String) with that (converted to a String). The two Strings are S and
that. The two Strings are compared in an implementation-defined
fashion. The result is intended to order String values in the sort
order specified by the system default locale, and will be negative,
zero, or positive, depending on whether S comes before that in the sort
order, the Strings are equal, or S comes after that in the sort order,
respectively.

   Before perform the comparisons the following steps are performed to
prepare the Strings:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let That be ToString (#sec-9.8)(that).

   The localeCompare method, if considered as a function of two
arguments this and that, is a consistent comparison function (as
defined in 15.4.4.11 (#sec-15.4.4.11)) on the set of all Strings.
Furthermore, localeCompare returns 0 or −0 when comparing two Strings
that are considered canonically equivalent by the Unicode standard.

   The actual return values are implementation-defined to permit
implementers to encode additional information in the value, but the
function is required to define a total ordering on all Strings and to
return 0 when comparing Strings that are considered canonically
equivalent by the Unicode standard.

   If no language-sensitive comparison at all is available from the
host environment, this function may perform a bitwise comparison.

   NOTE 1 The localeCompare method itself is not directly suitable as
an argument to Array.prototype.sort because the latter requires a
function of two arguments.

   NOTE 2 This function is intended to rely on whatever
language-sensitive comparison functionality is available to the
ECMAScript environment from the host environment, and to compare
according to the rules of the host environment’s current locale. It
is strongly recommended that this function treat Strings that are
canonically equivalent according to the Unicode standard as identical
(in other words, compare the Strings as if they had both been converted
to Normalised Form C or D first). It is also recommended that this
function not honour Unicode compatibility equivalences or
decompositions.

   NOTE 3 The second 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.

   NOTE 4 The localeCompare function is intentionally generic; it does
not require that its this value be a String object. Therefore, it can
be transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155410 Stringprototypematch regexp,  Next: 155411 Stringprototypereplace searchValue replaceValue,  Prev: 15549 StringprototypelocaleCompare that,  Up: Top

389 15.5.4.10 (#sec-15.5.4.10) String.prototype.match (regexp)
**************************************************************

When the match method is called with argument regexp, the following
steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. If Type (#def-type)(regexp) is Object and the value of the
     [[Class]] internal property of regexp is "RegExp", then let rx be
     regexp;

  4. Else, let rx be a new RegExp object created as if by the
     expression `new RegExp(<var>regexp</var>)' where `RegExp' is the
     standard built-in constructor with that name.

  5. Let global be the result of calling the [[Get]] internal method of
     rx with argument "global".

  6. Let exec be the standard built-in function RegExp.prototype.exec
     (see 15.10.6.2 (#sec-15.10.6.2))

  7. If global is not true, then
       1. Return the result of calling the [[Call]] internal method of
          exec with rx as the this value and argument list containing S.

  8. Else, global is true
       1. Call the [[Put]] internal method of rx with arguments
          "lastIndex" and 0.

       2. Let A be a new array created as if by the expression `new
          Array()' where `Array' is the standard built-in constructor
          with that name.

       3. Let previousLastIndex be 0.

       4. Let n be 0.

       5. Let lastMatch be true.

       6. Repeat, while lastMatch is true
            1. Let result be the result of calling the [[Call]]
               internal method of exec with rx as the this value and
               argument list containing S.

            2. If result is null, then set lastMatch to false.

            3. Else, result is not null
                 1. Let thisIndex be the result of calling the [[Get]]
                    internal method of rx with argument "lastIndex".

                 2. If thisIndex = previousLastIndex then
                      1. Call the [[Put]] internal method of rx with
                         arguments "lastIndex" and thisIndex+1.

                      2. Set previousLastIndex to thisIndex+1.

                 3. Else, set previousLastIndex to thisIndex.

                 4. Let matchStr be the result of calling the [[Get]]
                    internal method of result with argument "0".

                 5. Call the [[DefineOwnProperty]] internal method of A
                    with arguments ToString (#sec-9.8)(n), the Property
                    Descriptor (#sec-8.10) {[[Value]]: matchStr,
                    [[Writable]]: true, [[Enumerable]]: true,
                    [[configurable]]: true}, and false.

                 6. Increment n.


       7. If n = 0, then return null.

       8. Return A.


   NOTE The match function is intentionally generic; it does not
require that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155411 Stringprototypereplace searchValue replaceValue,  Next: 155412 Stringprototypesearch regexp,  Prev: 155410 Stringprototypematch regexp,  Up: Top

390 15.5.4.11 (#sec-15.5.4.11) String.prototype.replace (searchValue, replaceValue)
***********************************************************************************

First set string according to the following steps:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let string be the result of calling ToString (#sec-9.8), giving it
     the this value as its argument.

   If searchValue is a regular expression (an object whose [[Class]]
internal property is "RegExp"), do the following: If searchValue.global
is false, then search string for the first match of the regular
expression searchValue. If searchValue.global is true, then search
string for all matches of the regular expression searchValue. Do the
search in the same manner as in String.prototype.match, including the
update of searchValue`.lastIndex'. Let m be the number of left
capturing parentheses in searchValue (using NcapturingParens
(#def-NcapturingParens) as specified in 15.10.2.1 (#sec-15.10.2.1)).

   If searchValue is not a regular expression, let searchString be
ToString (#sec-9.8)(searchValue) and search string for the first
occurrence of searchString. Let m be 0.

   If replaceValue is a function, then for each matched substring, call
the function with the following m + 3 arguments. Argument 1 is the
substring that matched. If searchValue is a regular expression, the
next m arguments are all of the captures in the MatchResult (see
15.10.2.1 (#sec-15.10.2.1)). Argument m + 2 is the offset within string
where the match occurred, and argument m + 3 is string. The result is a
String value derived from the original

   Otherwise, let newstring denote the result of converting
replaceValue to a String. The result is a String value derived from the
original input String by replacing each matched substring with a String
derived from newstring by replacing characters in newstring by
replacement text as specified in Table 22. These `$' replacements are
done left-to-right, and, once such a replacement is performed, the new
replacement text is not subject to further replacements. For example,
`"$1,$2".replace(/(\$(\d))/g, "$$1-$1$2")' returns `"$1-$11,$1-$22"'. A
`$' in newstring that does not match any of the forms below is left as
is.

   Table 22 — Replacement Text Symbol Substitutions Characters
Replacement text `$$' `$' `$&' The matched substring.  `$`' The portion
of string that precedes the matched substring.  `$?' The portion of
string that follows the matched substring.  `$<var>n</var>' The nth
capture, where n is a single digit in the range 1 to 9 and `$'n is not
followed by a decimal digit. If n≤m and the nth capture is undefined,
use the empty String instead. If n>m, the result is
implementation-defined.  `$<var>nn</var>' The nnth capture, where nn is
a two-digit decimal number in the range 01 to 99. If nn≤m and the
nnth capture is undefined, use the empty String instead. If nn>m, the
result is implementation-defined.  NOTE The replace function is
intentionally generic; it does not require that its this value be a
String object. Therefore, it can be transferred to other kinds of
objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155412 Stringprototypesearch regexp,  Next: 155413 Stringprototypeslice start end,  Prev: 155411 Stringprototypereplace searchValue replaceValue,  Up: Top

391 15.5.4.12 (#sec-15.5.4.12) String.prototype.search (regexp)
***************************************************************

When the search method is called with argument regexp, the following
steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let string be the result of calling ToString (#sec-9.8), giving it
     the this value as its argument.

  3. If Type (#def-type)(regexp) is Object and the value of the
     [[Class]] internal property of regexp is "RegExp", then let rx be
     regexp;

  4. Else, let rx be a new RegExp object created as if by the
     expression `new RegExp(<var>regexp</var>)' where `RegExp' is the
     standard built-in constructor with that name.

  5. Search the value string from its beginning for an occurrence of
     the regular expression pattern rx. Let result be a Number
     indicating the offset within string where the pattern matched, or
     −1 if there was no match. The `lastIndex' and `global'
     properties of regexp are ignored when performing the search. The
     `lastIndex' property of regexp is left unchanged.

  6. Return result.

   NOTE The search function is intentionally generic; it does not
require that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155413 Stringprototypeslice start end,  Next: 155414 Stringprototypesplit separator limit,  Prev: 155412 Stringprototypesearch regexp,  Up: Top

392 15.5.4.13 (#sec-15.5.4.13) String.prototype.slice (start, end)
******************************************************************

The slice method takes two arguments, start and end, and returns a
substring of the result of converting this object to a String, starting
from character position start and running to, but not including,
character position end (or through the end of the String if end is
undefined). If start is negative, it is treated as sourceLength+start
where sourceLength is the length of the String. If end is negative, it
is treated as sourceLength+end where sourceLength is the length of the
String. The result is a String value, not a String object. The
following steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let len be the number of characters in S.

  4. Let intStart be ToInteger (#sec-9.4)(start).

  5. If end is undefined, let intEnd be len; else let intEnd be
     ToInteger (#sec-9.4)(end).

  6. If intStart is negative, let from be max(len + intStart,0); else
     let from be min(intStart, len).

  7. If intEnd is negative, let to be max(len + intEnd,0); else let to
     be min(intEnd, len).

  8. Let span be max(to − from,0).

  9. Return a String containing span consecutive characters from S
     beginning with the character at position from.

   The `length' property of the slice method is 2.

   NOTE The slice function is intentionally generic; it does not
require that its this value be a String object. Therefore it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155414 Stringprototypesplit separator limit,  Next: 155415 Stringprototypesubstring start end,  Prev: 155413 Stringprototypeslice start end,  Up: Top

393 15.5.4.14 (#sec-15.5.4.14) String.prototype.split (separator, limit)
************************************************************************

Returns an Array object into which substrings of the result of
converting this object to a String have been stored. The substrings are
determined by searching from left to right for occurrences of
separator; these occurrences are not part of any substring in the
returned array, but serve to divide up the String value. The value of
separator may be a String of any length or it may be a RegExp object
(i.e., an object whose [[Class]] internal property is "RegExp"; see
15.10 (#sec-15.10)).

   The value of separator may be an empty String, an empty regular
expression, or a regular expression that can match an empty String. In
this case, separator does not match the empty substring at the
beginning or end of the input String, nor does it match the empty
substring at the end of the previous separator match. (For example, if
separator is the empty String, the String is split up into individual
characters; the length of the result array equals the length of the
String, and each substring contains one character.) If separator is a
regular expression, only the first match at a given position of the
this String is considered, even if backtracking could yield a
non-empty-substring match at that position. (For example,
`"ab".split(/a*?/)' evaluates to the array `["a","b"]', while
`"ab".split(/a*/)' evaluates to the array `["","b"]'.)

   If the this object is (or converts to) the empty String, the result
depends on whether separator can match the empty String. If it can, the
result array contains no elements (#def-array-element). Otherwise, the
result array contains one element, which is the empty String.

   If separator is a regular expression that contains capturing
parentheses, then each time separator is matched the results (including
any undefined results) of the capturing parentheses are spliced into
the output array. For example,

"A<B>bold</B>and<CODE>coded</CODE>".split(/<(\/)?([^<>]+)>/)

   evaluates to the array

["A", undefined, "B", "bold", "/", "B", "and", undefined, "CODE", "coded", "/", "CODE", ""]

   If separator is undefined, then the result array contains just one
String, which is the this value (converted to a String). If limit is
not undefined, then the output array is truncated so that it contains
no more than limit elements.

   When the split method is called, the following steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let A be a new array created as if by the expression `new Array()'
     where `Array' is the standard built-in constructor with that name.

  4. Let lengthA be 0.

  5. If limit is undefined, let lim = 2^32−1; else let lim = ToUint32
     (#sec-9.6)(limit).

  6. Let s be the number of characters in S.

  7. Let p = 0.

  8. If separator is a RegExp object (its [[Class]] is "RegExp"), let R
     = separator; otherwise let R = ToString (#sec-9.8)(separator).

  9. If lim = 0, return A.

 10. If separator is undefined, then
       1. Call the [[DefineOwnProperty]] internal method of A with
          arguments "0", Property Descriptor (#sec-8.10) {[[Value]]: S,
          [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]:
          true}, and false.

       2. Return A.

 11. If s = 0, then
       1. Call SplitMatch(R, S, 0) and let z be its MatchResult result.

       2. If z is not failure, return A.

       3. Call the [[DefineOwnProperty]] internal method of A with
          arguments "0", Property Descriptor (#sec-8.10) {[[Value]]: S,
          [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]:
          true}, and false.

       4. Return A.

 12. Let q = p.

 13. Repeat, while q ≠ s
       1. Call SplitMatch(R, S, q) and let z be its MatchResult result.

       2. If z is failure, then let q = q+1.

       3. Else, z is not failure
            1. z must be a State. Let e be z’s endIndex and let cap
               be z’s captures array.

            2. If e = p, then let q = q+1.

            3. Else, e ≠ p
                 1. Let T be a String value equal to the substring of S
                    consisting of the characters at positions p
                    (inclusive) through q (exclusive).

                 2. Call the [[DefineOwnProperty]] internal method of A
                    with arguments ToString (#sec-9.8)(lengthA),
                    Property Descriptor (#sec-8.10) {[[Value]]: T,
                    [[Writable]]: true, [[Enumerable]]: true,
                    [[Configurable]]: true}, and false.

                 3. Increment lengthA by 1.

                 4. If lengthA = lim, return A.

                 5. Let p = e.

                 6. Let i = 0.

                 7. Repeat, while i is not equal to the number of
                    elements in cap.
                      1. Let i = i+1.

                      2. Call the [[DefineOwnProperty]] internal method
                         of A with arguments ToString
                         (#sec-9.8)(lengthA), Property Descriptor
                         (#sec-8.10) {[[Value]]: cap[i], [[Writable]]:
                         true, [[Enumerable]]: true, [[Configurable]]:
                         true}, and false.

                      3. Increment lengthA by 1.

                      4. If A`.length' = lim, return A.

                 8. Let q = p.



 14. Let T be a String value equal to the substring of S consisting of
     the characters at positions p (inclusive) through s (exclusive).

 15. Call the [[DefineOwnProperty]] internal method of A with arguments
     ToString (#sec-9.8)(lengthA), Property Descriptor (#sec-8.10)
     {[[Value]]: T, [[Writable]]: true, [[Enumerable]]: true,
     [[Configurable]]: true}, and false.

 16. Return A.

   The abstract operation SplitMatch takes three parameters, a String
S, an integer q, and a String or RegExp R, and performs the following
in order to return a MatchResult (see 15.10.2.1 (#sec-15.10.2.1)):

  1. If r is a RegExp object (its [[Class]] is "RegExp"), then
       1. Call the [[Match]] internal method of r giving it the
          arguments s and q, and return the MatchResult result.

  2. Type (#def-type)(r) must be String. Let r be the number of
     characters in r.

  3. Let s be the number of characters in s.

  4. If q+r > s then return the MatchResult failure.

  5. If there exists an integer i between 0 (inclusive) and r
     (exclusive) such that the character at position q+i of s is
     different from the character at position i of r, then return
     failure.

  6. Let cap be an empty array of captures (see 15.10.2.1
     (#sec-15.10.2.1)).

  7. Return the State (q+r, cap). (see 15.10.2.1 (#sec-15.10.2.1))

   The `length' property of the split method is 2.

   NOTE 1 The split method ignores the value of separator`.global' for
separators that are RegExp objects.

   NOTE 2 The split function is intentionally generic; it does not
require that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155415 Stringprototypesubstring start end,  Next: 155416 StringprototypetoLowerCase,  Prev: 155414 Stringprototypesplit separator limit,  Up: Top

394 15.5.4.15 (#sec-15.5.4.15) String.prototype.substring (start, end)
**********************************************************************

The substring method takes two arguments, start and end, and returns a
substring of the result of converting this object to a String, starting
from character position start and running to, but not including,
character position end of the String (or through the end of the String
is end is undefined). The result is a String value, not a String object.

   If either argument is NaN or negative, it is replaced with zero; if
either argument is larger than the length of the String, it is replaced
with the length of the String.

   If start is larger than end, they are swapped.

   The following steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let len be the number of characters in S.

  4. Let intStart be ToInteger (#sec-9.4)(start).

  5. If end is undefined, let intEnd be len; else let intEnd be
     ToInteger (#sec-9.4)(end).

  6. Let finalStart be min(max(intStart, 0), len).

  7. Let finalEnd be min(max(intEnd, 0), len).

  8. Let from be min(finalStart, finalEnd).

  9. Let to be max(finalStart, finalEnd).

 10. Return a String whose length is to − from, containing characters
     from S, namely the characters with indices from through to−1, in
     ascending order.

   The `length' property of the substring method is 2.

   NOTE The substring function is intentionally generic; it does not
require that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155416 StringprototypetoLowerCase,  Next: 155417 StringprototypetoLocaleLowerCase,  Prev: 155415 Stringprototypesubstring start end,  Up: Top

395 15.5.4.16 (#sec-15.5.4.16) String.prototype.toLowerCase ( )
***************************************************************

The following steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let L be a String where each character of L is either the Unicode
     lowercase equivalent of the corresponding character of S or the
     actual corresponding character of S if no Unicode lowercase
     equivalent exists.

  4. Return L.

   For the purposes of this operation, the 16-bit code units of the
Strings are treated as code points in the Unicode Basic Multilingual
Plane. Surrogate code points are directly transferred from S to L
without any mapping.

   The result must be derived according to the case mappings in the
Unicode character database (this explicitly includes not only the
UnicodeData.txt file, but also the SpecialCasings.txt file that
accompanies it in Unicode 2.1.8 and later).

   NOTE 1 The case mapping of some characters may produce multiple
characters. In this case the result String may not be the same length
as the source String. Because both toUpperCase and toLowerCase have
context-sensitive behaviour, the functions are not symmetrical. In
other words, `s.toUpperCase().toLowerCase()' is not necessarily equal
to `s.toLowerCase()'.

   NOTE 2 The toLowerCase function is intentionally generic; it does
not require that its this value be a String object. Therefore, it can
be transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155417 StringprototypetoLocaleLowerCase,  Next: 155418 StringprototypetoUpperCase,  Prev: 155416 StringprototypetoLowerCase,  Up: Top

396 15.5.4.17 (#sec-15.5.4.17) String.prototype.toLocaleLowerCase ( )
*********************************************************************

This function works exactly the same as toLowerCase except that its
result is intended to yield the correct result for the host
environment’s current locale, rather than a locale-independent
result. There will only be a difference in the few cases (such as
Turkish) where the rules for that language conflict with the regular
Unicode case mappings.

   NOTE 1 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.

   NOTE 2 The toLocaleLowerCase function is intentionally generic; it
does not require that its this value be a String object. Therefore, it
can be transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155418 StringprototypetoUpperCase,  Next: 155419 StringprototypetoLocaleUpperCase,  Prev: 155417 StringprototypetoLocaleLowerCase,  Up: Top

397 15.5.4.18 (#sec-15.5.4.18) String.prototype.toUpperCase ( )
***************************************************************

This function behaves in exactly the same way as
String.prototype.toLowerCase, except that characters are mapped to
their _uppercase_ equivalents as specified in the Unicode Character
Database.

   NOTE The toUpperCase function is intentionally generic; it does not
require that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155419 StringprototypetoLocaleUpperCase,  Next: 155420 Stringprototypetrim,  Prev: 155418 StringprototypetoUpperCase,  Up: Top

398 15.5.4.19 (#sec-15.5.4.19) String.prototype.toLocaleUpperCase ( )
*********************************************************************

This function works exactly the same as toUpperCase except that its
result is intended to yield the correct result for the host
environment’s current locale, rather than a locale-independent
result. There will only be a difference in the few cases (such as
Turkish) where the rules for that language conflict with the regular
Unicode case mappings.

   NOTE 1 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.

   NOTE 2 The toLocaleUpperCase function is intentionally generic; it
does not require that its this value be a String object. Therefore, it
can be transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 155420 Stringprototypetrim,  Next: 1555 Properties of String Instances,  Prev: 155419 StringprototypetoLocaleUpperCase,  Up: Top

399 15.5.4.20 (#sec-15.5.4.20) String.prototype.trim ( )
********************************************************

The following steps are taken:

  1. Call CheckObjectCoercible (#sec-9.10) passing the this value as
     its argument.

  2. Let S be the result of calling ToString (#sec-9.8), giving it the
     this value as its argument.

  3. Let T be a String value that is a copy of S with both leading and
     trailing white space removed. The definition of white space is the
     union of WhiteSpace and LineTerminator.

  4. Return T.

   NOTE The trim function is intentionally generic; it does not require
that its this value be a String object. Therefore, it can be
transferred to other kinds of objects for use as a method.


File: javascript_ecma_262_5th_ed.info,  Node: 1555 Properties of String Instances,  Next: 15551 length,  Prev: 155420 Stringprototypetrim,  Up: Top

400 15.5.5 (#sec-15.5.5) Properties of String Instances
*******************************************************

String instances inherit properties from the String prototype object
and their [[Class]] internal property value is "String". String
instances also have a [[PrimitiveValue]] internal property, a `length'
property, and a set of enumerable properties with array index names.

   The [[PrimitiveValue]] internal property is the String value
represented by this String object. The array index named properties
correspond to the individual characters of the String value. A special
[[GetOwnProperty]] internal method is used to specify the number,
values, and attributes of the array index named properties.


File: javascript_ecma_262_5th_ed.info,  Node: 15551 length,  Next: 15552 [[GetOwnProperty]] P,  Prev: 1555 Properties of String Instances,  Up: Top

401 15.5.5.1 (#sec-15.5.5.1) length
***********************************

The number of characters in the String value represented by this String
object.

   Once a String object is created, this property is unchanging. It has
the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: false }.


File: javascript_ecma_262_5th_ed.info,  Node: 15552 [[GetOwnProperty]] P,  Next: 156 Boolean Objects,  Prev: 15551 length,  Up: Top

402 15.5.5.2 (#sec-15.5.5.2) [[GetOwnProperty]] ( P )
*****************************************************

String objects use a variation of the [[GetOwnProperty]] internal
method used for other native ECMAScript objects (8.12.1 (#sec-8.12.1)).
This special internal method is used to add access for named properties
corresponding to individual characters of String objects.

   Assume S is a String object and P is a String.

   When the [[GetOwnProperty]] internal method of S is called with
property name P, the following steps are taken:

  1. Let desc be the result of calling the default [[GetOwnProperty]]
     internal method (8.12.1 (#sec-8.12.1)) on S with argument P.

  2. If desc is not undefined return desc.

  3. If ToString (#sec-9.8)(abs (#def-abs)(ToInteger (#sec-9.4)(P))) is
     not the same value as P, return undefined.

  4. Let str be the String value of the [[PrimitiveValue]] internal
     property of S.

  5. Let index be ToInteger (#sec-9.4)(P).

  6. Let len be the number of characters in str.

  7. If len ≤ index, return undefined.

  8. Let resultStr be a String of length 1, containing one character
     from str, specifically the character at position index, where the
     first (leftmost) character in str is considered to be at position
     0, the next one at position 1, and so on.

  9. Return a Property Descriptor (#sec-8.10) { [[Value]]: resultStr,
     [[Enumerable]]: true, [[Writable]]: false, [[Configurable]]: false
     }


File: javascript_ecma_262_5th_ed.info,  Node: 156 Boolean Objects,  Next: 1561 The Boolean Constructor Called as a Function,  Prev: 15552 [[GetOwnProperty]] P,  Up: Top

403 15.6 (#sec-15.6) Boolean Objects
************************************


File: javascript_ecma_262_5th_ed.info,  Node: 1561 The Boolean Constructor Called as a Function,  Next: 15611 Boolean value,  Prev: 156 Boolean Objects,  Up: Top

404 15.6.1 (#sec-15.6.1) The Boolean Constructor Called as a Function
*********************************************************************

When Boolean is called as a function rather than as a constructor, it
performs a type conversion.


File: javascript_ecma_262_5th_ed.info,  Node: 15611 Boolean value,  Next: 1562 The Boolean Constructor,  Prev: 1561 The Boolean Constructor Called as a Function,  Up: Top

405 15.6.1.1 (#sec-15.6.1.1) Boolean (value)
********************************************

Returns a Boolean value (not a Boolean object) computed by ToBoolean
(#sec-9.2)(value).