JavaScript/Notes/TypeConversion

From Noisebridge
< JavaScript(Difference between revisions)
Jump to: navigation, search
(Converting to String)
(Converting to Boolean)
(38 intermediate revisions by 2 users not shown)
Line 1: Line 1:
There are five primitive types in JavaScript: Null, Undefined, Boolean, String, Number.  
+
== Types ==
 +
* Number
 +
* String
 +
* Boolean
 +
* Null
 +
* Undefined
 +
* Object
 +
There are five primitive types in JavaScript. Everything else is an object.
  
Various operations in JavaScript require conversion to and from primitive values.  
+
=== Conversion ===
 +
Various operations in JavaScript require conversion between primitive and object values.
  
 
=== Converting to Boolean ===
 
=== Converting to Boolean ===
When evaluating any expression that requires a boolean value, the expression must be converted into a boolean using the internal <nowiki>[[ToBoolean]]</nowiki>.
+
When evaluating any expression that requires a boolean value, a boolean value must be produced. This occurs with the internal <nowiki>[[ToBoolean]]</nowiki>  
 +
[http://ecma-international.org/ecma-262/5.1/#sec-9.2 &sect; 9.2)].
  
 
For example:
 
For example:
 
<source lang="javascript">
 
<source lang="javascript">
 
var n = 0;
 
var n = 0;
if(n) { // false
+
if(n) { // [[ToBoolean]](0) = false
 
}
 
}
  
var t = !""; // Empty string is falsy.
+
var t = !""; // true. Empty string is falsy.
var f = !"f"; // Non-empty strings are not falsy.
+
var f = !"f"; // false. Non-empty strings other than "0" are not falsy, here.
 +
Boolean(""); // false.
 
</source>
 
</source>
  
All numbers boolean-convert to true except for the following: <code>+/-0</code> and <code>NaN</code>
+
All numbers boolean-convert to true except for <code>+/-0</code> and <code>NaN</code>.
  
Boolean operators use type-conversion for the evaluation of their left hand side operands.
+
Boolean operators use type-conversion for the evaluation of their operand or operands.
 
<source lang="javascript">
 
<source lang="javascript">
1 && 0;            // 1.
+
1 && 0;            // 0.
 
"" || 0;          // 0.
 
"" || 0;          // 0.
 
null || undefined; // undefined.
 
null || undefined; // undefined.
Line 40: Line 50:
  
 
=== Converting to String ===
 
=== Converting to String ===
When either operand is a string, concatenation is performed.
+
With the <code>+</code> operator, when either operand is a string, concatenation is performed.
  
Whenever the <code>+</code> operator is used, the operands must be converted into primitive values. First, the interpreter calls the object's valueOf to get a primitive value. If the result is a primitive value, then that value is used. '''Example:'''
+
All native objects have a toString method. Number.prototype.toString(base) is special in that it takes a <code>base</code> parameter.  
  
 
<source lang="javascript">
 
<source lang="javascript">
var o = {  
+
15..toString(16)
 +
</source>
 +
 
 +
<source lang="javascript">
 +
String(15); // Calls ToPrimitive(input argument, hint String).
 +
</source>
 +
 
 +
=== Conversion to Primitive ===
 +
Mathematical unary and binary operators, as well as boolean operators require the operands to be converted to primitives.
 +
 
 +
The Addition operator is used, the operands must be converted into primitive values. First, the interpreter calls the object's valueOf. If the result is a primitive value, then that value is used. '''Example:'''
 +
 
 +
<source lang="javascript">
 +
var ob = {  
 
   valueOf : function() { return 1; }  
 
   valueOf : function() { return 1; }  
 
};
 
};
o + 1; // 2.
+
ob + 1; // 2.
 
</source>
 
</source>
  
Otherwise, the object's toString is called.  
+
Otherwise, if <code>''o''.valueOf</code> results in an object &mdash;and <code>Object.prototype.valueOf</code> does &mdash; the object's <code>toString</code> is called.  
 
<source lang="javascript">
 
<source lang="javascript">
var o = { toString : function() { return "1"; } };
+
var ob = { toString : function() { return "1"; } };
o + 1; // "11".
+
ob + 1; // "11".
 
</source>
 
</source>
 +
 +
'''Example:''' [http://jsbin.com/eTAQaNoX/2/edit toString, valueOf, and concatenation]
  
 
=== Converting to Number ===
 
=== Converting to Number ===
Converting strings is a very common requirement and many methods can be used. Any mathematical operator except the concatenation/addition operator will force type-conversion to number.  
+
Converting strings is a very common requirement and many approaches can be used. Any mathematical operator except the concatenation/addition operator will force type-conversion to number.
 +
 
  
=== Converting to Object ===
 
Property access operation on string, number, and boolean primitives results in the creation of a temporary object.
 
 
<source lang="javascript">
 
<source lang="javascript">
true.toString(); // Boolean Object.
+
var d1 = new Date(NaN);
1.2.valueOf(); // Number object.
+
var d2 = new Date(NaN);
" foo ".trim(); // String Object.
+
 
 +
d1.setFullYear(2000);
 +
d2.setFullYear(2000);
 +
 
 +
d1 >= d2; // true, conversion to number.
 +
d1 <= d2; // true, conversion to number.
 +
d1 == d2 // false, different objects.
 +
</source>
 +
 
 +
== parseInt(s, radix) ==
 +
 
 +
To force use of a particular base, use the radix parameter:
 +
<source lang="javascript">parseInt("09", base) // base from 2 to 36.</source>
 +
 
 +
If <code>radix</code> is omitted, the base is determined by the contents of the string. Any string beginning with <code>0x</code> or <code>0X</code> represents a hexadecimal number. A string beginning with a leading 0 may, in older implementations, be parsed as octal (as if raxix were 8), in ECMA-262 Ed 3 (octal digits are 0-7). If string <code>09</code> is converted to <code>0</code>.
 +
 
 +
<source lang="javascript">
 +
var t = "0xf";
 +
Number(t); // 15
 +
+t;        // 15
 +
</source>
 +
 
 +
=== Primitive to Object with Property Accessors <code>.</code> and <code>[]</code> ===
 +
Property access operation on string, number, and boolean primitives results in the creation of a '''temporary'' object, for the algorithm.
 +
<source lang="javascript">
 +
// Primitive to Object conversion.
 +
true.toString(); // creates a temporary Boolean Object.
 +
1.2.valueOf();   // creates a temporary Number object.
 +
" foo ".trim(); // creates a temporary String Object.
  
 
// null.toString(); // TypeError
 
// null.toString(); // TypeError
Line 72: Line 124:
  
 
See also: http://dhtmlkitchen.com/how-property-access-works/
 
See also: http://dhtmlkitchen.com/how-property-access-works/
 +
 +
=== Object Creation ===
 +
<source lang="javascript">
 +
// You'll never need these.
 +
new Object(1);    // Results a Number object.
 +
new Object(true); // Results a Boolean object.
 +
new Object("");  // Results a String object.
 +
JSON.parse("{}"); // Results an Object object.
 +
</source>
 +
 +
== Type Checking ==
 +
Use sparingly. Avoid overloading with typechecking.
 +
=== The typeof Operator ===
 +
<source lang="javascript">
 +
typeof someval;
 +
</source>
 +
 +
<table border="1">
 +
<tr>
 +
<th>Type <th>Result
 +
<tr style="background: #eee"><td>Undefined <td>"undefined"
 +
<tr><td>Null <td>"object"
 +
<tr style="background: #eee"><td>Boolean <td>"boolean"
 +
<tr><td>Number <td>"number"
 +
<tr style="background: #eee"><td>String <td>"string"
 +
<tr><td>Object (native or host and doesn't implement <nowiki>[[Call]]</nowiki>) <td>"object"
 +
<tr style="background: #eee"><td>Object (native or host and implements <nowiki>[[Call]]</nowiki>) <td>"function"
 +
</table>

Revision as of 23:22, 11 January 2014

Contents

Types

  • Number
  • String
  • Boolean
  • Null
  • Undefined
  • Object

There are five primitive types in JavaScript. Everything else is an object.

Conversion

Various operations in JavaScript require conversion between primitive and object values.

Converting to Boolean

When evaluating any expression that requires a boolean value, a boolean value must be produced. This occurs with the internal [[ToBoolean]] § 9.2).

For example:

var n = 0;
if(n) { // [[ToBoolean]](0) = false
}
 
var t = !""; // true. Empty string is falsy.
var f = !"f"; // false. Non-empty strings other than "0" are not falsy, here.
Boolean(""); // false.

All numbers boolean-convert to true except for +/-0 and NaN.

Boolean operators use type-conversion for the evaluation of their operand or operands.

1 && 0;            // 0.
"" || 0;           // 0.
null || undefined; // undefined.
undefined || 1;    // 1.
NaN || 0;          // 0;

All falsy values:

false
""
null
undefined
0
NaN

All other primitive values and all objects are truthy.

Converting to String

With the + operator, when either operand is a string, concatenation is performed.

All native objects have a toString method. Number.prototype.toString(base) is special in that it takes a base parameter.

15..toString(16)
String(15); // Calls ToPrimitive(input argument, hint String).

Conversion to Primitive

Mathematical unary and binary operators, as well as boolean operators require the operands to be converted to primitives.

The Addition operator is used, the operands must be converted into primitive values. First, the interpreter calls the object's valueOf. If the result is a primitive value, then that value is used. Example:

var ob = { 
  valueOf : function() { return 1; } 
};
ob + 1; // 2.

Otherwise, if o.valueOf results in an object —and Object.prototype.valueOf does — the object's toString is called.

var ob = { toString : function() { return "1"; } };
ob + 1; // "11".

Example: toString, valueOf, and concatenation

Converting to Number

Converting strings is a very common requirement and many approaches can be used. Any mathematical operator except the concatenation/addition operator will force type-conversion to number.


var d1 = new Date(NaN);
var d2 = new Date(NaN);
 
d1.setFullYear(2000);
d2.setFullYear(2000);
 
d1 >= d2; // true, conversion to number.
d1 <= d2; // true, conversion to number.
d1 == d2 // false, different objects.

parseInt(s, radix)

To force use of a particular base, use the radix parameter:

parseInt("09", base) // base from 2 to 36.

If radix is omitted, the base is determined by the contents of the string. Any string beginning with 0x or 0X represents a hexadecimal number. A string beginning with a leading 0 may, in older implementations, be parsed as octal (as if raxix were 8), in ECMA-262 Ed 3 (octal digits are 0-7). If string 09 is converted to 0.

var t = "0xf";
Number(t); // 15
+t;        // 15

Primitive to Object with Property Accessors . and []

Property access operation on string, number, and boolean primitives results in the creation of a 'temporary object, for the algorithm.

// Primitive to Object conversion.
true.toString(); // creates a temporary Boolean Object.
1.2.valueOf();   // creates a temporary Number object.
" foo ".trim();  // creates a temporary String Object.
 
// null.toString(); // TypeError
// undefined.toString(); // TypeError

See also: http://dhtmlkitchen.com/how-property-access-works/

Object Creation

// You'll never need these.
new Object(1);    // Results a Number object.
new Object(true); // Results a Boolean object.
new Object("");   // Results a String object.
JSON.parse("{}"); // Results an Object object.

Type Checking

Use sparingly. Avoid overloading with typechecking.

The typeof Operator

typeof someval;
Type Result
Undefined "undefined"
Null "object"
Boolean "boolean"
Number "number"
String "string"
Object (native or host and doesn't implement [[Call]]) "object"
Object (native or host and implements [[Call]]) "function"
Personal tools