Homec4science
Diffusion libphutil (stable) Browse

libphutil/src/docs/drafts/javascript_pitfalls.txt
bc1c139c818bstable

Last Change
Raw File

javascript_pitfalls.txt
View Options

This document discusses design flaws in the Javascript language, and how to avoid, work around, or at least understand them.
=Implicit Semicolons=
Javascript tries to insert semicolons if you forgot them. This is a horrible idea. Notably, it can mask syntax errors by transforming subexpressions on their own lines into statements with no effect:
<code> string = "Here is a fairly long string that does not fit on one "
"line. Note that I forgot the string concatenation operators "
"so this will compile and execute with the wrong behavior. ";
</code>Here's what ECMA262 says about this:
<code> When, as the program is parsed ..., a token ... is encountered that is not
allowed by any production of the grammar, then a semicolon is automatically
inserted before the offending token if one or more of the following conditions
is true: ...
</code>To protect yourself against this ``feature'', don't use it. Always explicitly insert semicolons after each statement. You should also prefer to break lines in places where insertion of a semicolon would not make the unparseable parseable, usually after operators.
=`this' defaults to window=
When a function is called without a calling context, <tt>this</tt> is implicitly bound to window. There is no reason for the language to work like this and it causes many subtle errors. To understand this, see [[Articles/Scope Resolution]].
=<tt>with</tt> is bad news bears=
<tt>with</tt> is a terrible idea:
<code> with (object) {
property = 3; // Might be on object, might be on window: who knows.
}
</code>Do <b>not</b> use <tt>with</tt>.
=arguments is not an Array=
You can convert <tt>arguments</tt> to an array using $A. Note that you can pass <tt>arguments</tt> to Function.prototype.apply() without converting it.
=Object, Array, and iteration are needlessly hard=
There is exactly one reasonable, consistent way to use these primitives but it is not obvious. Navigate these troubled waters with [[Articles/Object and Array]].
=typeof null == "object"=
This statement is true in Javascript:
<code> typeof null == 'object'
</code>This is strictly a bug in the language.
=undefined is a special type=
There is a special type in JavaScript called "undefined", that has only one value, also called <tt>undefined</tt>. Undefined is the value uninitialized variables and unspecified formal parameters are assigned. For example:
<code> var x;
typeof x == 'undefined' // true!
</code>Conceptually, <tt>undefined</tt> is extremely similar to <tt>null</tt> and is the source of many programming errors in JavaScript.
=var is a mess=
The <tt>var</tt> keyword is confusing and its mechanism is not obvious. A detailed explanation can be found in [[Articles/Scope Resolution]].
=Number, String, and Boolean objects=
Like Java, Javascript has primitive versions of number, string, and boolean, and object versions. In Java, there's some argument for this distinction. In Javascript, it's completely worthless and the behavior of these objects is wrong. :String and :Boolean in particular are totally unusable:
<code> "pancake" == "pancake"; // true
new String("pancake") == new String("pancake"); // false
var b = new Boolean(false);
b; // false
!b; // ALSO false
!b == b; // But this is true!
!!b == !b // Negate both sides and it's false again. FUCK.
if (b) {
// Better fucking believe this will get executed. FUCKING FUCK.
}
</code>There is no advantage to using the object forms (the primitive forms behave like objects and can have methods and properties, and inherit from Array.prototype, Number.prototype, etc.) and their logical behavior is at best absurd and at worst strictly wrong. <b>Never use</b> <tt>new Number()</tt>, <tt>new String()</tt> or <tt>new Boolean()</tt> unless your Javascript is God Tier and you are absolutely sure you know what you are doing.
c4science · Help