A list of funny and tricky JavaScript examples
npm install wtfjs
[![WTFPL 2.0][license-image]][license-url]
[![NPM version][npm-image]][npm-url]
[![Patreon][patreon-image]][patreon-url]
[![Buy Me A Coffee][bmc-image]][bmc-url]
> A list of funny and tricky JavaScript examples
JavaScript is a great language. It has a simple syntax, large ecosystem and, what is most important, a great community.
At the same time, we all know that JavaScript is quite a funny language with tricky parts. Some of them can quickly turn our everyday job into hell, and some of them can make us laugh out loud.
The original idea for WTFJS belongs to Brian Leroux. This list is highly inspired by his talk “WTFJS” at dotJS 2012:
You can install this handbook using npm. Just run:
``
$ npm install -g wtfjs
You should be able to run wtfjs at the command line now. This will open the manual in your selected $PAGER. Otherwise, you may continue reading on here.
The source is available here:
Currently, there are these translations of wtfjs:
- 中文
- हिंदी
- Français
- Português do Brasil
- Polski
- Italiano
- Russian (on Habr.com)
- 한국어
[Help translating to your language][tr-request]
[tr-request]: https://github.com/denysdovhan/wtfjs/blob/master/CONTRIBUTING.md#translations
Note: Translations are maintained by their translators. They may not contain every example, and existing examples may be outdated.
- 💪🏻 Motivation
- ✍🏻 Notation
- 👀 Examples
- [[] is equal ![]](#-is-equal-)true
- [ is not equal ![], but not equal [] too](#true-is-not-equal--but-not-equal--too)NaN
- true is false
- baNaNa
- is not a NaN
- and === weird cases[]
- It's a fail
- [ is truthy, but not true](#-is-truthy-but-not-true)null
- is falsy, but not false
- is an object, but it is undefinedundefined
- Minimal value is greater than zero
- function is not a function
- Adding arrays
- Trailing commas in array
- Array equality is a monster
- and Number
- is a bad guytrue
- Math with and false
- HTML comments are valid in JavaScript
- is ~~not~~ a number[]
- [ and null are objects](#-and-null-are-objects)0.1 + 0.2
- Magically increasing numbers
- Precision of
- Patching numbers
- Comparison of three numbers
- Funny math
- Addition of RegExps
- Strings aren't instances of
- Calling functions with backticks
- Call call call
- A property__proto__
- Object as a key of object's property
- Accessing prototypes with
- ${{Object}}
- Destructuring with default values
- Dots and spreading
- Labels
- Nested labels
- Insidious
- Is this multiple inheritance?
- A generator which yields itself
- A class of class
- Non-coercible objects
- Tricky arrow functions
- Arrow functions can not be a constructor
- and arrow functionsNumber.toFixed()
- Tricky return
- Chaining assignments on object
- Accessing object properties with arrays
- display different numbersMath.max()
- less than Math.min()
- Comparing to 0
- Same variable redeclaration
- Default behavior Array.prototype.sort()
- resolve() won't return Promise instance
- is undefinedarguments
- bindingalert
- An from hellsetTimeout
- An infinite timeout
- A objecttrue
- Double dot
- Extra Newness
- Why you should use semicolons
- Split a string by a space
- A stringified string
- Non-strict comparison of a number to
- 📚 Other resources
- 🤝 Supporting
- 🎓 License
> Just for fun
>
> — _“Just for Fun: The Story of an Accidental Revolutionary”, Linus Torvalds_
The primary goal of this list is to collect some crazy examples and explain how they work, if possible. Just because it's fun to learn something that we didn't know before.
If you are a beginner, you can use these notes to get a deeper dive into JavaScript. I hope these notes will motivate you to spend more time reading the specification.
If you are a professional developer, you can consider these examples as a great reference for all of the quirks and unexpected edges of our beloved JavaScript.
In any case, just read this. You're probably going to find something new.
> ⚠️ Note: If you enjoy reading this document, please, consider supporting the author of this collection.
// -> is used to show the result of an expression. For example:
`js`
1 + 1; // -> 2
// > means the result of console.log or another output. For example:
`js`
console.log("hello, world!"); // > hello, world!
// is just a comment used for explanations. Example:
`js`
// Assigning a function to foo constant
const foo = function() {};
is equal ![]Array is equal not array:
`js`
[] == ![]; // -> true
The abstract equality operator converts both sides to numbers to compare them, and both sides become the number 0 for different reasons. Arrays are truthy, so on the right, the opposite of a truthy value is false, which is then coerced to 0. On the left, however, an empty array is coerced to a number without becoming a boolean first, and empty arrays are coerced to 0, despite being truthy.
Here is how this expression simplifies:
`js`
+[] == +![];
0 == +false;
0 == 0;
true;
See also [[] is truthy, but not true](#-is-truthy-but-not-true).
- 12.5.9 Logical NOT Operator (!)
- 7.2.15 Abstract Equality Comparison
is not equal ![], but not equal [] tooArray is not equal true, but not Array is not equal true too;false
Array is equal , not Array is equal false too:
`js
true == []; // -> false
true == ![]; // -> false
false == []; // -> true
false == ![]; // -> true
`
`js
true == []; // -> false
true == ![]; // -> false
// According to the specification
true == []; // -> false
toNumber(true); // -> 1
toNumber([]); // -> 0
1 == 0; // -> false
true == ![]; // -> false
![]; // -> false
true == false; // -> false
`
`js
false == []; // -> true
false == ![]; // -> true
// According to the specification
false == []; // -> true
toNumber(false); // -> 0
toNumber([]); // -> 0
0 == 0; // -> true
false == ![]; // -> true
![]; // -> false
false == false; // -> true
`
- 7.2.15 Abstract Equality Comparison
`js`
!!"false" == !!"true"; // -> true
!!"false" === !!"true"; // -> true
Consider this step-by-step:
`js
// true is 'truthy' and represented by value 1 (number), 'true' in string form is NaN.
true == "true"; // -> false
false == "false"; // -> false
// 'false' is not the empty string, so it's a truthy value
!!"false"; // -> true
!!"true"; // -> true
`
- 7.2.15 Abstract Equality Comparison
`js`
"b" + "a" + +"a" + "a"; // -> 'baNaNa'
This is an old-school joke in JavaScript, but remastered. Here's the original one:
`js`
"foo" + +"bar"; // -> 'fooNaN'
The expression is evaluated as 'foo' + (+'bar'), which converts 'bar' to not a number.
- 12.8.3 The Addition Operator (+)
- 12.5.6 Unary + Operator
is not a NaN`js`
NaN === NaN; // -> false
The specification strictly defines the logic behind this behavior:
> 1. If Type(x) is different from Type(y), return false.Type(x)
> 2. If is Number, thenx
> 1. If is NaN, return false.y
> 2. If is NaN, return false.
> 3. … … …
>
> — 7.2.14 Strict Equality Comparison
Following the definition of NaN from the IEEE:
> Four mutually exclusive relations are possible: less than, equal, greater than, and unordered. The last case arises when at least one operand is NaN. Every NaN shall compare unordered with everything, including itself.
>
> — “What is the rationale for all comparisons returning false for IEEE754 NaN values?” at StackOverflow
and === weird casesObject.is() determines if two values have the same value or not. It works similar to the === operator but there are a few weird cases:
`javascript
Object.is(NaN, NaN); // -> true
NaN === NaN; // -> false
Object.is(-0, 0); // -> false
-0 === 0; // -> true
Object.is(NaN, 0 / 0); // -> true
NaN === 0 / 0; // -> false
`
In JavaScript lingo, NaN and NaN are the same value but they're not strictly equal. NaN === NaN being false is apparently due to historical reasons so it would probably be better to accept it as it is.
Similarly, -0 and 0 are strictly equal, but they're not the same value.
For more details about NaN === NaN, see the above case.
- Here are the TC39 specs about Object.is
- Equality comparisons and sameness on MDN
You would not believe, but …
`js`
(![] + [])[+[]] +
(![] + [])[+!+[]] +
([![]] + [][[]])[+!+[] + [+[]]] +
(![] + [])[!+[] + !+[]];
// -> 'fail'
By breaking that mass of symbols into pieces, we notice that the following pattern occurs often:
`js`
![] + []; // -> 'false'
![]; // -> false
So we try adding [] to false. But due to a number of internal function calls (binary + Operator -> ToPrimitive -> [[DefaultValue]]) we end up converting the right operand to a string:
`js`
![] + [].toString(); // 'false'
Thinking of a string as an array we can access its first character via [0]:
`js`
"false"[0]; // -> 'f'
The rest is obvious, but the i is tricky. The i in fail is grabbed by generating the string 'falseundefined' and grabbing the element on index ['10'].
More examples:
`js`
+![] // -> 0
+!![] // -> 1
!![] // -> true
![] // -> false
[][[]] // -> undefined
+!![] / +![] // -> Infinity
[] + {} // -> "[object Object]"
+{} // -> NaN
- Brainfuck beware: JavaScript is after you!
- Writing a sentence without using the Alphabet — generate any phrase using JavaScript
is truthy, but not trueAn array is a truthy value, however, it's not equal to true.
`js`
!![] // -> true
[] == true // -> false
Here are links to the corresponding sections in the ECMA-262 specification:
- 12.5.9 Logical NOT Operator (!)
- 7.2.15 Abstract Equality Comparison
is falsy, but not falseDespite the fact that null is a falsy value, it's not equal to false.
`js`
!!null; // -> false
null == false; // -> false
At the same time, other falsy values, like 0 or '' are equal to false.
`js`
0 == false; // -> true
"" == false; // -> true
The explanation is the same as for previous example. Here's the corresponding link:
- 7.2.15 Abstract Equality Comparison
is an object, but it is undefined> ⚠️ This is part of the Browser API and won't work in a Node.js environment ⚠️
Despite the fact that document.all is an array-like object and it gives access to the DOM nodes in the page, it responds to the typeof function as undefined.
`js`
document.all instanceof Object; // -> true
typeof document.all; // -> 'undefined'
At the same time, document.all is not equal to undefined.
`js`
document.all === undefined; // -> false
document.all === null; // -> false
But at the same time:
`js`
document.all == null; // -> true
> document.all used to be a way to access DOM elements, in particular with old versions of IE. While it has never been a standard it was broadly used in the old age JS code. When the standard progressed with new APIs (such as document.getElementById) this API call became obsolete and the standard committee had to decide what to do with it. Because of its broad use they decided to keep the API but introduce a willful violation of the JavaScript specification.false
> The reason why it responds to when using the Strict Equality Comparison with undefined while true when using the Abstract Equality Comparison is due to the willful violation of the specification that explicitly allows that.
>
> — “Obsolete features - document.all” at WhatWG - HTML spec
> — “Chapter 4 - ToBoolean - Falsy values” at YDKJS - Types & Grammar
Number.MIN_VALUE is the smallest number, which is greater than zero:
`js`
Number.MIN_VALUE > 0; // -> true
> Number.MIN_VALUE is 5e-324, i.e. the smallest positive number that can be represented within float precision, i.e. that's as close as you can get to zero. It defines the best resolution that floats can give you.Number.NEGATIVE_INFINITY
>
> Now the overall smallest value is although it's not really numeric in a strict sense.0
>
> — “Why is less than Number.MIN_VALUE in JavaScript?” at StackOverflow
> ⚠️ A bug present in V8 v5.5 or lower (Node.js <=7) ⚠️
All of you know about the annoying _undefined is not a function_, but what about this?
`js
// Declare a class which extends null
class Foo extends null {}
// -> [Function: Foo]
new Foo() instanceof null;
// > TypeError: function is not a function
// > at … … …
`
This is not a part of the specification. It's just a bug that has now been fixed, so there shouldn't be a problem with it in the future.
It's continuation of story with previous bug in modern environment (tested with Chrome 71 and Node.js v11.8.0).
`js`
class Foo extends null {}
new Foo() instanceof null;
// > TypeError: Super constructor null of Foo is not a constructor
This is not a bug because:
`js`
Object.getPrototypeOf(Foo.prototype); // -> null
If the class has no constructor the call from prototype chain. But in the parent has no constructor. Just in case, I’ll clarify that null is an object:
`js`
typeof null === "object";
Therefore, you can inherit from it (although in the world of the OOP for such terms would have beaten me). So you can't call the null constructor. If you change this code:
`js`
class Foo extends null {
constructor() {
console.log("something");
}
}
You see the error:
`
ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor
And if you add super:
`js`
class Foo extends null {
constructor() {
console.log(111);
super();
}
}
JS throws an error:
`
TypeError: Super constructor null of Foo is not a constructor
- An explanation of this issue by @geekjob
What if you try to add two arrays?
`js`
[1, 2, 3] + [4, 5, 6]; // -> '1,2,34,5,6'
The concatenation happens. Step-by-step, it looks like this:
`js`
[1, 2, 3] +
[4, 5, 6][
// call toString()
(1, 2, 3)
].toString() +
[4, 5, 6].toString();
// concatenation
"1,2,3" + "4,5,6";
// ->
("1,2,34,5,6");
You've created an array with 4 empty elements. Despite all, you'll get an array with three elements, because of trailing commas:
`js`
let a = [, , ,];
a.length; // -> 3
a.toString(); // -> ',,'
> Trailing commas (sometimes called "final commas") can be useful when adding new elements, parameters, or properties to JavaScript code. If you want to add a new property, you can simply add a new line without modifying the previously last line if that line already uses a trailing comma. This makes version-control diffs cleaner and editing code might be less troublesome.
>
> — Trailing commas at MDN
Array equality is a monster in JS, as you can see below:
`js
[] == '' // -> true
[] == 0 // -> true
[''] == '' // -> true
[0] == 0 // -> true
[0] == '' // -> false
[''] == 0 // -> true
[null] == '' // true
[null] == 0 // true
[undefined] == '' // true
[undefined] == 0 // true
[[]] == 0 // true
[[]] == '' // true
[[[[[[]]]]]] == '' // true
[[[[[[]]]]]] == 0 // true
[[[[[[ null ]]]]]] == 0 // true
[[[[[[ null ]]]]]] == '' // true
[[[[[[ undefined ]]]]]] == 0 // true
[[[[[[ undefined ]]]]]] == '' // true
`
You should watch very carefully for the above examples! The behaviour is described in section 7.2.15 Abstract Equality Comparison of the specification.
and NumberIf we don't pass any arguments into the Number constructor, we'll get 0. The value undefined is assigned to formal arguments when there are no actual arguments, so you might expect that Number without arguments takes undefined as a value of its parameter. However, when we pass undefined, we will get NaN.
`js`
Number(); // -> 0
Number(undefined); // -> NaN
According to the specification:
1. If no arguments were passed to this function's invocation, let n be +0.n
2. Else, let be ? ToNumber(value).undefined
3. In case of , ToNumber(undefined) should return NaN.
Here's the corresponding section:
- 20.1.1 The Number Constructor
- 7.1.3 ToNumber(argument)
is a bad guyparseInt is famous by its quirks:
`js`
parseInt("f*ck"); // -> NaN
parseInt("f*ck", 16); // -> 15
💡 Explanation: This happens because parseInt will continue parsing character-by-character until it hits a character it doesn't know. The f in 'f*ck' is the hexadecimal digit 15.
Parsing Infinity to integer is something…
`js`
//
parseInt("Infinity", 10); // -> NaN
// ...
parseInt("Infinity", 18); // -> NaN...
parseInt("Infinity", 19); // -> 18
// ...
parseInt("Infinity", 23); // -> 18...
parseInt("Infinity", 24); // -> 151176378
// ...
parseInt("Infinity", 29); // -> 385849803
parseInt("Infinity", 30); // -> 13693557269
// ...
parseInt("Infinity", 34); // -> 28872273981
parseInt("Infinity", 35); // -> 1201203301724
parseInt("Infinity", 36); // -> 1461559270678...
parseInt("Infinity", 37); // -> NaN
Be careful with parsing null too:
`js`
parseInt(null, 24); // -> 23
💡 Explanation:
> It's converting null to the string "null" and trying to convert it. For radixes 0 through 23, there are no numerals it can convert, so it returns NaN. At 24, "n", the 14th letter, is added to the numeral system. At 31, "u", the 21st letter, is added and the entire string can be decoded. At 37 on there is no longer any valid numeral set that can be generated and NaN is returned.
>
> — “parseInt(null, 24) === 23… wait, what?” at StackOverflow
Don't forget about octals:
`js`
parseInt("06"); // 6
parseInt("08"); // 8 if support ECMAScript 5
parseInt("08"); // 0 if not support ECMAScript 5
💡 Explanation: If the input string begins with "0", radix is eight (octal) or 10 (decimal). Exactly which radix is chosen is implementation-dependent. ECMAScript 5 specifies that 10 (decimal) is used, but not all browsers support this yet. For this reason always specify a radix when using parseInt.
parseInt always convert input to string:
`js`
parseInt({ toString: () => 2, valueOf: () => 1 }); // -> 2
Number({ toString: () => 2, valueOf: () => 1 }); // -> 1
Be careful while parsing floating point values
`js`
parseInt(0.000001); // -> 0
parseInt(0.0000001); // -> 1
parseInt(1 / 1999999); // -> 5
💡 Explanation: ParseInt takes a string argument and returns an integer of the specified radix. ParseInt also strips anything after and including the first non-digit in the string parameter. 0.000001 is converted to a string "0.000001" and the parseInt returns 0. When 0.0000001 is converted to a string it is treated as "1e-7" and hence parseInt returns 1. 1/1999999 is interpreted as 5.00000250000125e-7 and parseInt returns 5.
and falseLet's do some math:
`js`
true + true; // -> 2
(true + true) * (true + true) - true; // -> 3
Hmmm… 🤔
We can coerce values to numbers with the Number constructor. It's quite obvious that true will be coerced to 1:
`js`
Number(true); // -> 1
The unary plus operator attempts to convert its value into a number. It can convert string representations of integers and floats, as well as the non-string values true, false, and null. If it cannot parse a particular value, it will evaluate to NaN. That means we can coerce true to 1 easier:
`js`
+true; // -> 1
When you're performing addition or multiplication, the ToNumber method is invoked. According to the specification, this method returns:
> If argument is true, return 1. If argument is false, return +0.
That's why we can add boolean values as regular numbers and get correct results.
Corresponding sections:
- 12.5.6 Unary + Operator
- 12.8.3 The Addition Operator (+)
- 7.1.3 ToNumber(argument)
You will be impressed, but
`js`
(function() {
return
{
b: 10;
}
})(); // -> undefined
return and the returned expression must be in the same line:
`js`
(function() {
return {
b: 10
};
})(); // -> { b: 10 }
This is because of a concept called Automatic Semicolon Insertion, which automagically inserts semicolons after most newlines. In the first example, there is a semicolon inserted between the return statement and the object literal, so the function returns undefined and the object literal is never evaluated.
- 11.9.1 Rules of Automatic Semicolon Insertion
- 13.10 The return Statement
`js
var foo = { n: 1 };
var bar = foo;
foo.x = foo = { n: 2 };
foo.x; // -> undefined
foo; // -> {n: 2}
bar; // -> {n: 1, x: {n: 2}}
`
From right to left, {n: 2} is assigned to foo, and the result of this assignment {n: 2} is assigned to foo.x, that's why bar is {n: 1, x: {n: 2}} as bar is a reference to foo. But why foo.x is undefined while bar.x is not ?
Foo and bar references the same object {n: 1}, and lvalues are resolved before assignations. foo = {n: 2} is creating a new object, and so foo is updated to reference that new object. The trick here is foo in foo.x = ... as a lvalue was resolved beforehand and still reference the old foo = {n: 1} object and update it by adding the x value. After that chain assignments, bar still reference the old foo object, but foo reference the new {n: 2} object, where x is not existing.
It's equivalent to:
`js
var foo = { n: 1 };
var bar = foo;
foo = { n: 2 }; // -> {n: 2}
bar.x = foo; // -> {n: 1, x: {n: 2}}
// bar.x point to the address of the new foo object
// it's not equivalent to: bar.x = {n: 2}
`
`js
var obj = { property: 1 };
var array = ["property"];
obj[array]; // -> 1
// this also works with nested arrays
var nestedArray = [[[[[[[[[["property"]]]]]]]]]];
obj[nestedArray]; // -> 1
`
What about pseudo-multidimensional arrays?
`js
var map = {};
var x = 1;
var y = 2;
var z = 3;
map[[x, y, z]] = true;
map[[x + 10, y, z]] = true;
map["1,2,3"]; // -> true
map["11,2,3"]; // -> true
`
The brackets [] operator converts the passed expression using toString. Converting a one-element array to a string is akin to converting the contained element to the string:
`js`
["property"].toString(); // -> 'property'
display different numbersNumber.toFixed() can behave a bit strange in different browsers. Check out this example:
`js`
(0.7875).toFixed(3);
// Firefox: -> 0.787
// Chrome: -> 0.787
// IE11: -> 0.788
(0.7876).toFixed(3);
// Firefox: -> 0.788
// Chrome: -> 0.788
// IE11: -> 0.788
While your first instinct may be that IE11 is correct and Firefox/Chrome are wrong, the reality is that Firefox/Chrome are more directly obeying standards for numbers (IEEE-754 Floating Point), while IE11 is minutely disobeying them in (what is probably) an effort to give clearer results.
You can see why this occurs with a few quick tests:
`js`
// Confirm the odd result of rounding a 5 down
(0.7875).toFixed(3); // -> 0.787
// It looks like it's just a 5 when you expand to the
// limits of 64-bit (double-precision) float accuracy
(0.7875).toFixed(14); // -> 0.78750000000000
// But what if you go beyond the limit?
(0.7875).toFixed(20); // -> 0.78749999999999997780
Floating point numbers are not stored as a list of decimal digits internally, but through a more complicated methodology that produces tiny inaccuracies that are usually rounded away by toString and similar calls, but are actually present internally.
In this case, that "5" on the end was actually an extremely tiny fraction below a true 5. Rounding it at any reasonable length will render it as a 5... but it is actually not a 5 internally.
IE11, however, will report the value input with only zeros appended to the end even in the toFixed(20) case, as it seems to be forcibly rounding the value to reduce the troubles from hardware limits.
See for reference NOTE 2 on the ECMA-262 definition for toFixed.
- 20.1.3.3 Number.prototype.toFixed (fractionDigits)
less than Math.min()I find this example hilarious:
`js`
Math.min() > Math.max(); // -> true
Math.min() < Math.max(); // -> false
This is a simple one. Let's consider each part of this expression separately:
`js`
Math.min(); // -> Infinity
Math.max(); // -> -Infinity
Infinity > -Infinity; // -> true
Why so? Well, Math.max() is not the same thing as Number.MAX_VALUE. It does not return the largest possible number.
Math.max takes arguments, tries to convert the to numbers, compares each one and then returns the largest remaining. If no arguments are given, the result is −∞. If any value is NaN, the result is NaN.
The opposite is happening for Math.min. Math.min returns ∞, if no arguments are given.
- 15.8.2.11 Math.max
- 15.8.2.11 Math.min
- Why is Math.max() less than Math.min()? by Charlie Harvey
to 0The following expressions seem to introduce a contradiction:
`js`
null == 0; // -> false
null > 0; // -> false
null >= 0; // -> true
How can null be neither equal to nor greater than 0, if null >= 0 is actually true? (This also works with less than in the same way.)
The way these three expressions are evaluated are all different and are responsible for producing this unexpected behavior.
First, the abstract equality comparison null == 0. Normally, if this operator can't compare the values on either side properly, it converts both to numbers and compares the numbers. Then, you might expect the following behavior:
`js`
// This is not what happens
(null == 0 + null) == +0;
0 == 0;
true;
However, according to a close reading of the spec, the number conversion doesn't actually happen on a side that is null or undefined. Therefore, if you have null on one side of the equal sign, the other side must be null or undefined for the expression to return true. Since this is not the case, false is returned.
Next, the relational comparison null > 0. The algorithm here, unlike that of the abstract equality operator, _will_ convert null to a number. Therefore, we get this behavior:
`js`
null > 0
+null = +0
0 > 0
false
Finally, the relational comparison null >= 0. You could argue that this expression should be the result of null > 0 || null == 0; if this were the case, then the above results would mean that this would also be false. However, the >= operator in fact works in a very different way, which is basically to take the opposite of the < operator. Because our example with the greater than operator above also holds for the less than operator, that means this expression is actually evaluated like so:
`js`
null >= 0;
!(null < 0);
!(+null < +0);
!(0 < 0);
!false;
true;
- 7.2.12 Abstract Relational Comparison
- 7.2.15 Abstract Equality Comparison
- An in-depth explanation
JS allows to redeclare variables:
`js`
a;
a;
// This is also valid
a, a;
Works also in strict mode:
`js`
var a, a, a;
var a;
var a;
All definitions are merged into one definition.
Imagine that you need to sort an array of numbers.
`js`
[10, 1, 3].sort(); // -> [ 1, 10, 3 ]
The default sort order is built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values.
- 22.1.3.25 Array.prototype.sort ( comparefn )
Pass compareFn if you try to sort anything but string.
`js`
[10, 1, 3].sort((a, b) => a - b); // -> [ 1, 3, 10 ]
`js
const theObject = {
a: 7
};
const thePromise = new Promise((resolve, reject) => {
resolve(theObject);
}); // Promise instance object
thePromise.then(value => {
console.log(value === theObject); // > true
console.log(value); // > { a: 7 }
});
`
The value which is resolved from thePromise is exactly theObject.
How about input another Promise into the resolve function?
`js
const theObject = new Promise((resolve, reject) => {
resolve(7);
}); // Promise instance object
const thePromise = new Promise((resolve, reject) => {
resolve(theObject);
}); // Promise instance object
thePromise.then(value => {
console.log(value === theObject); // > false
console.log(value); // > 7
});
`
> This function flattens nested layers of promise-like objects (e.g. a promise that resolves to a promise that resolves to something) into a single layer.
The specification is ECMAScript 25.6.1.3.2 Promise Resolve Functions. But it is not quite human-friendly.
is undefinedWrite them in the console. They will return the value defined in the last object.
`js`
{}{}; // -> undefined
{}{}{}; // -> undefined
{}{}{}{}; // -> undefined
{foo: 'bar'}{}; // -> 'bar'
{}{foo: 'bar'}; // -> 'bar'
{}{foo: 'bar'}{}; // -> 'bar'
{a: 'b'}{c:' d'}{}; // -> 'd'
{a: 'b', c: 'd'}{}; // > SyntaxError: Unexpected token ':'
({}{}); // > SyntaxError: Unexpected token '{'
When inspecting each {}, they returns undefined. If you inspect {foo: 'bar'}{}, you will find {foo: 'bar'} is 'bar'.
There are two meanings for {}: an object or a block. For example, the {} in () => {} means block. So we need to use () => ({}) to return an object.
Let's use {foo: 'bar'} as a block. Write this snippet in your console:
`js`
if (true) {
foo: "bar";
} // -> 'bar'
Surprisingly, it behaviors the same! You can guess here that {foo: 'bar'}{} is a block.
bindingConsider this function:
`js
function a(x) {
arguments[0] = "hello";
console.log(x);
}
a(); // > undefined
a(1); // > "hello"
`
arguments is an Array-like object that contains the values of the arguments passed to that function. When no arguments are passed, then there's no x to override.
- The arguments object on MDN
from hellThis on is literally from hell:
`js`
[666]["\155\141\160"]"\143\157\156\163\164\162\165\143\164\157\162""
)(666); // alert(666)
This one is based on octal escape sequences and multiple strings.
Any character with a character code lower than 256 (i.e. any character in the extended ASCII range) can be escaped using its octal-encoded character code, prefixed with \. An example above is basically and alert ecoded by octal escape sequances.
- Martin Kleppe tweet about it
- JavaScript character escape sequences
- Multi-Line JavaScript Strings
Guess what would happen if we set an infinite timeout?
`js`
setTimeout(() => console.log("called"), Infinity); // ->
// > 'called'
It will executed immediately instead of infinity delay.
Usually, runtime stores the delay as a 32-bit signed integer internally. This causes an integer overflow, resulting in the timeout being executed immediately.
For example, in Node.js we will get this warning:
`
(node:1731) TimeoutOverflowWarning: Infinity does not fit into a 32-bit signed integer.
Timeout duration was set to 1.
(Use to show where the warning was created)`
- WindowOrWorkerGlobalScope.setTimeout() on MDN
- Node.js Documentation on Timers
- Timers on W3C
objectGuess what would happen if we set an callback that's not a function to setTimeout?
`js`
setTimeout(123, 100); // ->
// > 'called'
This is fine.
`js`
setTimeout('{a: 1}', 100); // ->
// > 'called'
This is also fine.
`js`
setTimeout({a: 1}, 100); // ->
// > 'Uncaught SyntaxError: Unexpected identifier setTimeout (async) (anonymous) @ VM__:1'
This throws an SyntaxError.
Note that this can easily happen if your function returns an object and you call it here instead of passing it! What if the content - policy is set to self?
`js`
setTimeout(123, 100); // ->
// > console.error("[Report Only] Refused to evaluate a string as JavaScript because 'unsafe-eval' is not an allowed source of script in the following Content Security Policy directive: "script-src 'report-sample' 'self' ")
The console refuses to run it at all!
WindowOrWorkerGlobalScope.setTimeout() can be called with code as first argument, which will be passed on to eval, which is bad. Eval will coerce her input to String, and evaluate what is produced, so Objects becomes '[object Object]' which has hmmm ... an 'Unexpected identifier'!
- eval() on MDN (don't use this)
- WindowOrWorkerGlobalScope.setTimeout() on MDN
- Content Security Policy
- Timers on W3C
Let's try to coerce a number to a string:
`js`
27.toString() // > Uncaught SyntaxError: Invalid or unexpected token
Maybe we should try with two dots?
`js`
27..toString(); // -> '27'
But why doesn't first example work?
It's just a language grammar limitation.
The . character presents an ambiguity. It can be understood to be the member operator, or a decimal, depending on its placement.
The specification's interpretation of the . character in that particular position is that it will be a decimal. This is defined by the numeric literal syntax of ECMAScript.
You must always use parenthesis or an addition dot to make such expression valid.
`js`
(27).toString(); // -> '27'
// or
27..toString(); // -> '27'
- Usage of toString in JavaScript on StackOverflow
- Why does 10..toString() work, but 10.toString() does not?
I present this as an oddity for your amusement.
`js
class Foo extends Function {
constructor(val) {
super();
this.prototype.val = val;
}
}
new new Foo(":D")().val; // -> ':D'
`
Constructors in JavaScript are just functions with some special treatment. By extending Function using the class syntax you create a class that, when instantiated, is now a function, which you can then additionally instantiate.
While not exhaustively tested, I believe the last statement can be analyzed thus:
`js`
new new Foo(":D")().val(new newFooInstance()).val;
veryNewFooInstance.val;
// -> ':D'
As a tiny addendum, doing new Function('return "bar";')` of course