Skip to content

❓ A simple quiz for JavaScript developers. Test yourself, your friends, your job applicants and simply enjoy JavaScript)

License

Notifications You must be signed in to change notification settings

everget/javascript-quiz

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 

Repository files navigation

JavaScript Quiz

Table of Contents

  1. Labels
  2. Semicolons
  3. Coercions
  4. Comparisons
  5. Inequalities
  6. Calculus
  7. Conditional statements
  8. Destructuring assignment
  9. void operator
  10. typeof operator
  11. , operator
  12. try-catch statement
  13. Hoisting
  14. Scopes & Closures & Hoisting
  15. Context
  16. delete operator
  17. ... operator
  18. instanceof operator
  19. Template literals
  20. Object
  21. Function
  22. Default parameters
  23. arguments
  24. class
  25. GeneratorFunction
  26. Promise
  27. AsyncFunction
  28. Reflect
  29. Proxy
  30. Array
  31. Date
  32. RegExp
  33. Symbol
  34. String
  35. Number
  36. Boolean
  37. Math
  38. Window
  39. Event loop
  40. eval method
  41. with operator
  42. Miscellaneous

Labels

vars: var vars = vars;

vars;
foo: { foo = 123 };

foo;
var foo = {};
var bar = 1;

foo: {
    bar: 2;
    baz: ++bar;
};

foo.baz + foo.bar + bar;
a: b: c: d: e: f: g: 1, 2, 3, 4, 5;
(printing => {
  printing: {
     console.log(1);
     if (!printing) {
       break printing;
     }
     console.log(2);
  };
  console.log(3);
})(false);

Back to top

Semicolons

var foo = [] // Missing semicolon!
(new Date).getTime();
!function(){console.log('Awesome');}() // Missing semicolon!
!function(){console.log('JS');}();
var [foo, bar, baz] = [1, 2, 3];

foo = bar // Missing semicolon!
++baz

[foo, bar, baz];
function foo() {
  return // Missing semicolon!
      'Awesome JS';
}

foo() === 'Awesome JS';
var bar = 'bar' // Missing semicolon!
/JS/g.exec('Awesome JS');

Back to top

Coercions

!!~1;
false % 1;
1 / '';
+'  -12';
+'1 2';
+'1'++;
'1' - - '1';
'5' + + '6';
'1' + 2 + '3' + 4;
'foo' + + 'bar';
4 - '5' + 0xf - '1e1';
!!!function() {};
4 + 3 + 2 + '1';
[1] + 1;
[] + 24 + 10;
'foo'.split('') + [];
[] + [] + 'foo'.split('');
[1, 2] + [3, 4];
[1, 2, [3, 4]] + [[5, 6], 7, 8];
[4] * [4];
({} + {});
[] + {};

[] * {};
{} + [];
[] + [];
++[];
[] + null + 1;
[4, 4] * [4, 4];
[3 + NaN + true] + [10 / (8 * null) - 1];
[][[]];
[[]][0];
++[[]][+[]];

Back to top

Comparisons

'3' - 2 === 1;
undefined == false;
[1] == true;
var x = true;
var y = false;

x != y === !(x == y);
!!'false' ==  !!'true';
!!'false' === !!'true';
1 + 2 + '3' == 1 + '2' + 3;
'001' == true;
[2] == true;
'00' == 0;
[true] == true;
0 === -0;
null == 0;
[1, 1] == true;
' \t\r\n' == 0;
'0x0' == false;
[[[[1]]]] == true;
'002' == true;
[] == ![];
[[]] == 0;

Back to top

Inequalities

10 > 9 > 8;
9 < 5 < 1;
2 < 6 < 1;
1 < 3 < 4;
+0 < -0;
01 < 1;
0,0000008 < 8;
[10] < [2];
'10' < '9';
'3' > '12'
'03' > '12';
Infinity > -Infinity;
({} + 'y' > {} + 'x');

Back to top

Calculus

0.3 - 0.1;
0.1 * 0.2;
.1 + .2 != .3;
0.1 + (0.2 + 0.3) == (0.1 + 0.2) + 0.3;
(0.2 + 0.4) / 1 == (0.1 + 0.2) * 2;
-9 % 7;
42 / -0;
9999999999999999 === 1e16;
1e16 === 1e16 + 1;
1e16 + 1.1 < 1e16 + 2;
var x = 5;
var y = 10;
var z = x+++y;

[x, y, z];
var x = 0;

[x+++x++, x];
1 + - + + + - + 1;
01 - + - 02 - + - 03;
8 | 1;
~~(-5.5);
~~+'2.9'-1 == ('2.9' >> 0) - 1;
(1.22e-10).toFixed(2);
12..toFixed(1);
(0.9).toFixed(0);
(0.00008).toFixed(3) === 0;
parseInt('08');
parseInt(null);
parseInt(null, 24);
parseInt(Infinity);
parseInt(1 / 0, 19);
parseInt('Infinity', 23)
parseFloat('12.3.4');
parseFloat('\t\v\r12.34\n ');
parseFloat('-.00');

Back to top

Conditional statements

('false') && ('bar');
1 || 'foo' && 0;
1 && 3;
1 && 'foo' || 0;
var x, y;
x = (y = 0) && (y = 1);

[x, y];
var x = 1;
if (false)
    x = 3;
    x = 4;

x;
var foo = NaN;
switch (foo) {
  case NaN:
    console.log('NaN');
    break;
  default:
    console.log('default');
}
var foo = {};
switch (foo) {
  case {}:
    console.log('object');
    break;
  default:
    console.log('default');
}

Back to top

Destructuring assignment

var [x] = [];
x;
var [x = 1] = [];
x;
var [x, x, x, x] = 'JS is awesome language'.split(' ');
x;
({ x, y } = { x: 5, y: 6, x: 7 });
var { x, y } = { x: x, y: y };

[x, y];
var x, { x: y = 1 } = { x };

[x, y];
var o1 = { a: 1 },
    o2 = { b: 2 },
    o3 = { c: 3 }

[o1, o2, o3] = [o3, o2, o1];

o3;

Back to top

void operator

(() => void (1 + 1))();
void function() { return 'foo'; }();

Back to top

typeof operator

typeof 000;
typeof (null && false);
typeof (void null);
typeof { null: null }.null;
typeof setTimeout(() => {}, 0);
typeof typeof undefined;
var y = 1, x = y = typeof x;
x;
var x = [typeof x, typeof y][1];
typeof typeof x;

Back to top

Comma operator

(1, 2, 3);
var x = 0;
var y = (x++, 99);

[x, y];
(1, function(){})();
if (9, 0) console.log('ok');
[true, false][+true, +false];
(1,5 - 1) * 2;
var smth = (45, 87) > (195, 3) ? 'bar' : (54, 65) > (1, 0) ? '' : 'baz';
alert('1', alert('2', alert('3')));
typeof ('x', 3);
var f = (function f() { return '1' }, function g() { return 2 })();

typeof f;
[3, 4, 5, 6][1, 2];
if ((1, true) && (2, false) || (3, false) && (4, true) || (5, true)) {
  console.log('if');
} else {
  console.log('else');
}
alert('2',
  foo = (x) => alert(x),
  foo('1')
),
foo('3');

Back to top

try catch statement

(() => {
  try {
    return 'try';
  } finally {
    console.log('finally');
  }
})();
var foo = () => {
  var o = { foo: 24 };
  window.bar = () => {
    return o;
  };

  try {
    return o;
  } finally {
    o = null;
  }
};

foo(); // => ?
bar(); // => ?
try {
  setTimeout(function() {
    throw new Error()
  }, 1000);
} catch (err) {}
try {
  try {
    throw new Error('try');
  } catch (err) {
    console.error('inner', err.message);
    throw err;
  } finally {
    console.log('finally');
  }
} catch (err) {
  console.error('outer', err.message);
}
(() => {
  label: try {
    return 0;
  } finally {
    break label;
    return 1;
  }
  return 2;
})();
(() => {
  try {
      throw new Error('try')
  } catch (err) {
      throw err;
  } finally {
      throw new Error('finally');
  }
})();

Back to top

Hoisting

var bar;
f();

function f() {
  return bar;
}

var bar = 2410;
(function() {
   console.log(x);
   console.log(f());

   var x = 1;
   function f() {
      return 2;
   }
})();
function f(x) {
  return x * 2;
}

var f;

typeof f;

Back to top

Scopes & Closures & Hoisting

var x = 1;
{
  var x = 2;
}

x;
if (!('y' in window)) {
  var y = 1;
}

y;
(function() {
  var x = x = 3;
})();

[typeof x, typeof y];
var foo = function bar() {
  return 'bar';
}

typeof bar();
var foo = 1;
function bar() {
  foo = 10;
  return;
  function foo() {};
}

bar();
foo;
x = 1;
(() => {
  return x;
  var x = 2;
})();
var x = 1;
if (function f() {}) {
  x += typeof f;
}

x;
(function f() {
  function f() { return 1; }
  return f();
  function f() { return 2; }
})();
for (var i = 0; i < 10; i++) {
  setTimeout(() => alert(i), 100);
}
var foo = 11;

function bar() {
  return foo;
  foo = 10;
  function foo() {};
  var foo = '12';
}

typeof bar();
var foo = 1,
var bar = function foo(x) {
  x && foo(--x);
};

foo;
(function() {
  var foo = 'x';

  (function (foo) {
    foo = 'y';
  })(foo);

  return foo;
})();
(function f(f) {
  return typeof f();
})(() => 1);
function f() {
  var x = 5;
  return new Function('y', 'return x + y');
}

f()(1);
var x = 1;

function f() {
  var x = 2;
  return new Function('', 'return x');
}

f()();

Back to top

Context

function f() {
  alert(this);
}

f.call(null);
function f() {
  return this;
}

f.call(f);
(function() {

  var f = function() {
    return this * 2;
  };

  return [
    f.call(undefined),
    f.call(null),
    f.call(1)
  ];

})();
var user = {
  name: 'Alex',
  _user: this
};

user._user.name;
var foo = {
  bar() { return this.baz },
  baz: 1
};

typeof (f = foo.bar)();
(function() {
  'use strict'

  var x = 10;
  var foo = {
    x: 20,
    bar() {
      var x = 30;
      return this.x;
    }
  };

  return [
    foo.bar(),
    (foo.bar)(),
    (foo.bar = foo.bar)(),
    (foo.bar, foo.bar)(),
    (foo.baz || foo.bar)()
  ];

})();
var foo = {
  bar: function() { return this === foo },
  baz: () => this === foo
};

foo.bar() === foo.baz();
var foo = {
  bar: 'bar',
  baz: !(function() {
    console.log(this.bar);
  })()
};

foo.baz;
(function() {
  'use strict';

  const g1 = (function() { return this || (1, eval)('this') })();
  const g2 = (function() { return this })();

  return g1 === g2;
}());

Back to top

delete operator

var numbers = [2, 3, 5, 7, 11, 13];
delete numbers[3];

numbers.length;
delete [].length;
function foo() {};
delete foo.length;

typeof foo.length;
var Person = function() {};
Person.prototype.type = 'person';

var admin = new Person();
delete admin.type;

admin.type;
delete delete window.document;
(function() {
  x = 1;
  window.y = 2;
  this.z = 3;
  var w = 4;

  delete x;
  delete y;
  delete z;
  delete w;

  return [typeof x, typeof y, typeof z, typeof w];
})();
(x => {
  delete x;
  return x;
})(1);
var x = 1;
y = 1;

(function() {
  return (delete window.x) === (delete window.y);
})();
void typeof delete this;

Back to top

Spread operator

[...[...'...']].length
var foo = [...[,,24]];

[0 in foo, 1 in foo, 2 in foo];

Back to top

instanceof operator

function A() {};
function B() {};

A.prototype = B.prototype = {};

var a = new A();

a instanceof B;
function A() {};
var a = new A();

A.prototype = {};

a instanceof A;
function A() {};

function B() {};
B.prototype = Object.create(A.prototype);

var b = new B();

b instanceof A;
function f() { return f; }

new f() instanceof f;

Back to top

Template literals

`${1.0}`;
`use strict`;

this == null;
typeof `${{Object}}`.prototype
((...args) => args)``
var foo = { `hello world`: 24 };

Back to top

Object

Object instanceof Function;
Object.prototype.toString.call();
Object.prototype.toString.call(Object);
Object.is(NaN, NaN);
Object.is(-0, +0);
Object.assign({}, 'function');
var foo = 'abc';
var bar = Object(foo);

Object.prototype.toString.call(bar);
Object.freeze(window);

var didItWork = true;

didItWork;
({ 'toString': null }).propertyIsEnumerable('toString');
{ x: 1, y: 2 }['x'];
var obj = {
 '': ''
};

obj[''];
{ [{}]: {} };
var obj = {
  1: 'foo'
};

obj[1] == obj[[1]];
obj[[1]] == obj['1'];
'foo'.someProperty = 17;

'foo'.someProperty;
(function() {
  var foo = {};
  var bar = {};
  var map = {};

  map[foo] = 'foo';
  map[bar] = 'bar';

  return map[foo];
})();
100['toString']['length'];
({}).valueOf();
{ valueOf: () => true } == '1.0e0';
var foo = {
  toString: () => '[object Foo]',
  valueOf: () => 2410
};

'object: ' + foo;
var x = 1;
var y = { toString: () => '1' };
var z = 1;

x + y + z;
var foo = { x: 1 };
foo.y = foo = { x: 2 };

foo.y;
var t = true;
var obj = ({[t]: t});

obj;
var t = true;
var obj = ({[`${t}`]: t, [t]: t});

obj;
('__proto__').__proto__.__proto__.__proto__;
var proto = {
  x: () => 'x'
}

var foo = new Object(proto);
var bar = new Object(proto);

foo === bar;
Object.create(null) instanceof Object;
var bar = { bar: 'bar'};

function foo() {}
foo.prototype = bar;

[bar instanceof foo, Object.create(bar) instanceof foo];
Object.prototype.isPrototypeOf(window);
var foo = { __proto__: null };

Object.getPrototypeOf(foo) === null;
var __proto__ = 'bar';
var foo = { __proto__ };

Object.getPrototypeOf(foo) === Object.prototype;

Back to top

Function

typeof Function;
Function instanceof Function;
Function instanceof Object;
typeof Function.prototype;
Function.prototype instanceof Function;
Function.prototype.isPrototypeOf(Function);
Function.prototype.prototype;
Function.prototype === Function;
Function.prototype.constructor === Function;
(function (x, y) {}).length;
(function (foo) {
  return typeof foo.bar;
})({ foo: { bar: 1 } });
var f = () => { x: 1 };
f();
function f() {};

f.bind(this).name;
var f = function() {};
var g = f.bind();

g.prototype;
function f(x, y) {
  return x + y;
}

f.bind(1)();
function f() {
  return this.value;
}

f.bind({ value: 1 }).call({ value: 2 });
var f = () => this;
var g = function() { return this }.bind(this);

f() === g();
function f() {}

var fBind = f.bind({});
var obj = new f();

[obj instanceof f, obj instanceof fBind];
function foo() {
  return Function.bind(null, 'console.log(bar);');
}

var bar = 1;

(function() {
  var bar = 2;
  foo()()();
})();
(function() {
  if (false) {
    let f = { g() => 1 };
  }

  return typeof f;
})();
var foo = 2410;
var bar = ['a', 'b'];
var baz = { first: true };

function f(x, y, z) {
  x = 3;
  y.push('c');
  y = ['c'];
  z.first = false;
  z = true;
}

f(foo, bar, baz);

[foo, bar, baz.first];
function f(name) {
  this.name = name;
}

var name = 'foo';
var person = f('bar');

[name, person];
var x = 0;

function f() {
  x++;
  this.x = x;
  return f;
}

var foo = new new f;

foo.x;
var c = 'constructor';

c[c][c]('console.log(c)')();
var f = Function.prototype.call;

f();
console.log.call.call.call.call.call.apply(x => x, [1, 2]);

Back to top

Default parameters

function f(x = 24, y = 10) {
  return x + y;
}

foo(undefined, 20);
foo(null, null);
function g(x, y = 24, z = 10) {
  return x + y + z;
}

g(1,,2);
var bar = 1;

function f(bar = bar) {
  return bar;
}

f();
var x = 1;

function f(y = function() { return x; }) {
  var x = 2;
  return y();
}

f();
function f(x, y = function() { return x; }) {
  console.log(x);
  var x = 1;
  console.log(y());
}

f(2);
function f(x, y = function() { console.log(x); x = 1; }) {
  var x;
  console.log(x);
  x = 2;
  y();
  console.log(x);
}

f(3);

Back to top

arguments

(function() {
  return typeof arguments;
})();
(function() {
  return arguments.toString();
})();
(function() {
  console.log(
    arguments.constructor === {}.constructor,
    arguments.constructor === [].constructor
  );
})();
(function() {
  var arguments;
  return arguments[0];
})(200);
function f(x, y, z) {
  arguments[2] = 10;
  return z;
}

f(1, 2, 3);
(() => arguments.toString())();
function f(x, y) {
  arguments[2] = 5;
  return y;
}

f(1);
function f(foo, bar, baz) {
  return Array.from(arguments);
}

f(...['foo', , 'bar']);
var g = function() {
  return arguments;
};

g() == g();

Back to top

Class

var Foo = class {};

class Foo {};
class AwesomeJS extends null {};

new AwesomeJS;
typeof (new (class F extends (String, Array) {})).substring;
typeof (new (class { class () {} }));
(function() {
  let f = this ? class g {} : class h {};
  return [
    typeof f,
    typeof h
  ];
})();
class A {
  foo() {
    console.log('A.foo');
  }
}

class B extends A {
  foo() {
    super.foo();
  }
}

class C {
  foo() {
    console.log('C.foo');
  }
}

var D = {
  foo: B.prototype.foo,
};

Object.setPrototypeOf(B, C.constructor);

D.foo();

Back to top

Generator function

function* g() {
  yield 'foo';
}

g[Symbol.toStringTag] === g()[Symbol.toStringTag];
function* g() {
  yield 'foo';
  yield yield 'bar';
  yield yield yield 'baz';
}

var gen = g();

[...gen];
(function* f() { yield f })().next()

Back to top

Promise

typeof Promise.resolve(2410);
Promise.reject(Promise.resolve());
new Promise((resolve, reject) => resolve(24))
  .then((res) => console.log(res))
  .then((res) => console.log(res));
Promise.resolve('foo')
  .then(Promise.resolve('bar'))
  .then((res) => console.log(res));
Promise.resolve('foo')
  .then((res) => Promise.resolve('bar'))
  .then((res) => console.log(res));
Promise.resolve(2)
  .then(3)
  .then((res) => console.log(res));
Promise.resolve({ x: 24 })
  .then((res) => delete res.x)
  .then((res) => console.log(res.x));
Promise.resolve(2410).then(
  (res) => { throw new Error(res) },
  (err) => { try {} catch(err) {} }
);
Promise.reject(24)
  .then(null, null)
  .then(null, (reason) => console.log(reason));
Promise.reject(24)
  .then(10, null)
  .then(null, (reason) => console.log(reason));
Promise.reject(24)
  .then(null, 10)
  .then(null, (reason) => console.log(reason));
Promise.resolve(24)
  .then(null, null)
  .then((res) => console.log(res), null);
Promise.resolve(24)
  .then(null, 10)
  .then((res) => console.log(res), null);
Promise.resolve(24)
  .then(10, null)
  .then((res) => console.log(res), null);

Back to top

Async function

async function f(x) {
  return x * x;
}

f(2) === 4;
var y = 2;
async function f(x = await y) {
  return x * x;
}

f();
(() => {
  'use strict';
  async function eval(x, y) {
    await x * y;
  }

  eval(1, 2);
})();
async function f(x) {
  return await x * (await x);
}

f(2).then(res => console.log(res));
async function User(firstname, lastname) {
  this.firstname = await firstname;
  this.lastname = await lastname;
}

var user = new User('John', 'Doe');
(async function(){}).__proto__.__proto__ == (function(){}).__proto__;

Back to top

Reflect

Reflect.get(Reflect, Reflect.get(Reflect, 'get').name);
Reflect.setPrototypeOf(Reflect, Array.prototype);

typeof Reflect.slice;
Reflect.preventExtensions(Reflect);

Reflect.isExtensible(Reflect);

Back to top

Proxy

var proxy = new Proxy({}, {});

proxy instanceof Proxy;
(() => {
  Proxy.prototype = null;

  class P extends Proxy {
    constructor() {
      super(window, {});
      this.foo = 'foo';
    }
  };

  new P;
  console.log(window.foo);
})();
(() => {
  Proxy.prototype = null;

  class P extends Proxy {
    constructor() {
      super(window, {
        getPrototypeOf() { return P.prototype }
      });
    }
  };

  console.log((new P) instanceof P === true);
})();

Back to top

Array

[].valueOf();
typeof [1, 2, 3];
var arr = [];

arr[1] = 1;
arr[24] = 24;

arr.length;
var arr = [];
var i = 3;

arr[--i] = ++i;

arr;
[].length = -2;
[,].length;
[,,].length;
[[[1], 2], 3].length;
new Array(null);
new Array(1)[0] + '';
new Array('100').length;
new Array(1, 2) == true;
new Array([], null, undefined, null) == ',,,';
var arr = new Array(3);

arr.map((value, index) => index);
[1, 2, 3].toString();
[1, 2, 3, 4, 5][0..toString().length];
[].unshift(0);
var arr = [2, 3, 5, 7, 11];

arr.indexOf(7, 2);
arr.indexOf(2, -3);
[NaN].indexOf(NaN);
'0'.split(void 0, 0);
Array(2).join();
[1, 2].join(undefined);
[,,,].join() === ',,';
Array(4).join('js!' - 4);
Array(5).join(',').length;
[].concat[1, 2, 3];
[].fill.call({ length: 3 }, 4);
Array.from({ '': '' });
[NaN].includes(NaN);
var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

arr.slice();
arr.slice(-2);
arr.slice(3, -6);
[1, 2, 3].slice(0, null);
Array(3).map(item => 'x');
Array.apply(null, new Array(4)).map((el, i) => i);
Array.apply(null, { length : 3 });
[...new Set([1, 1, 2, 3, 5, 8, 13])];
var arr = [1, 2, 3];
var pushResult = arr.push(4, 5, 6);

[pushResult, arr];
var arr = [undefined, , true];

arr.filter(() => true);
var arr = new Array(2);
var i = 0;

arr.forEach(() => i++);

i;
var arr = [80, 9, 34, 23, 5, 1];
arr.sort(); // => ?
new Array(10).map((el, i) => i + 1);
var bag = new Array(3).fill([]);
bag[0].push(1);
bag[1].push(1);
bag; // => ?
Array.isArray({
  constructor: Array,
  length: 0,
  __proto__: Array.prototype,
});
Array.prototype.push(1, 2, 3);
Array.prototype[1] = 'foo';

var arr = [undefined, ,];

0 in arr; // => ?
1 in arr; // => ?
arr.hasOwnProperty(1); // => ?

Back to top

Date

new Date(undefined);
new Date(null);
'2016/12/31' == new Date('2016/12/31');
typeof (new Date() + new Date());
new Date(-666).getUTCMonth();
new Date(0) - 0;
new Date(0);
new Date('0');
new Date(0, 0);
new Date(0, 0, 0);
var f = Date.bind.call(Date, 2000, 0, 1);
var g = Function.bind.call(Date, null, 2000, 0, 1);

new f().toString() === new g().toString();

Back to top

RegExp

/[a-z]/ === /[a-z]/;
RegExp.prototype.toString = function() {
  return this.source;
}

/3/3/ - /1/;
(() => {
    class CustomRegExp extends RegExp {
      constructor() {
        super();
      }
    }

    return new CustomRegExp;
})();
'foobar'.replace(/^/, "$'");
/foo.bar/.test('foo\nbar');
/^$/.test('');
/$^/.test('');
/^.$/.test('');
/^..$/.test('');
'xy'.split(/x*?/);
'xy'.split(/(?:xy)*/);
'xy'.split(/x*/);
'.'.split(/(.?)(.?)/);
'.'.split(/()()/);
''.split(/.?/);
'test'.split(/(?:)/, -1);
typeof (/()??/).exec('')[1];
/^$^$^$^$^$^$$$$^^^/.test('');
new RegExp(/xy+z/, 'i');
new RegExp([].join('|'));
var foo = /[/ + 'javascript'[0] + '///';
foo;

var bar = /\[/ + 'javascript'[0] + '///';
bar;

Back to top

Symbol

var foo = new Symbol();
Symbol('foo') === Symbol('foo');
class MySymbol extends Symbol {
  constructor() {
    super();
  }
}

var symbol = new MySymbol();
Symbol.for('bar') === Symbol.for('bar');
Symbol.keyFor(Symbol.iterator);
var obj = {
  [Symbol('foo')]: 'foo',
  [Symbol('bar')]: 'bar'
};

Object.keys(obj);
var obj = {};

obj[Symbol('foo')] = true;

obj[Symbol('foo')] = false;

Object.getOwnPropertySymbols(obj).length;

Back to top

String

String(1.23e+2);
String(['foo', 'bar']);
'' instanceof String;
'foo' == new function() { return String('foo') };
'foo'[-1] == 'foo'.charAt(-1);
'foo'.charAt(1) === 'foo'.substring(1, 2);
++'24'.split('')[0];

Back to top

Number

3 instanceof Number;
Number.MAX_VALUE > 0;
Number.MIN_VALUE > 0;
Number();
Number(undefined);
Number('');
Number([]);
Number([24, 10]);
Number({});
Number.isNaN('NaN') === window.isNaN('NaN');
Number('0.') === Number('.0');
Number.prototype.compare = function(value) {
  return this === value;
};

Number(123).compare(123);
Number.prototype.toString = function() {
  return typeof this;
};

(4).toString();

Back to top

Boolean

Boolean('true') === true;
Boolean([]);
Boolean('000');
Boolean(-Infinity);
if (new Boolean(false)) {
  console.log('Awesome JS');
}
new Boolean('').valueOf();
new Boolean(false).valueOf() === false;

Back to top

Math

Math instanceof Math;
Math.round(true + .501);
Math.round(-5.5);
Math.ceil(5.01) === -Math.floor(-5.01);
Math.max(2, []);
Math.max({}, 2);
Math.max() > Math.min();
Math.pow(+0, -1);
Math.pow(2, 53) === Math.pow(2, 53) + 1;
Math.pow(-0, -1);

Back to top

Window

typeof window;
typeof Window;
Object.getPrototypeOf(window) === Window;
Window.constructor === Function;
Window.prototype.constructor === Window;
(() => {
  console.log(window);
  var window = window;
})();

Back to top

Event loop

setTimeout(() => console.log(1), 1);
setTimeout(() => console.log(2), 1000);
setTimeout(() => console.log(3), 0);
console.log(4);
setTimeout(() => {
  console.log(1);
  setTimeout(() => console.log(2), 0);
}, 500);

setTimeout(() => {
  setTimeout(() => console.log(3), 500);
}, 250);
new Promise((resolve, reject) => {
  console.log(1);
  resolve();
}).then(() => {
  console.log(2);
});

console.log(3);
setTimeout(() => {
  console.log(1);
}, 300);

Promise.resolve()
  .then(() => console.log(2));

console.log(3);
setTimeout(() => {
  console.log(1);
}, 0);

Promise.resolve(2)
  .then((res) => {
    console.log(res);
    setTimeout(() => {
      console.log(3);
    }, 0);
    return Promise.resolve(4);
  })
  .then((res) => {
    console.log(res);
  });
async function f() {
  console.log(await new Promise(resolve => {
     setTimeout(() => resolve(2), 0);
  }));
}

console.log(1);
f();
console.log(3);
// Node.js
setTimeout(() => {
  console.log(1);
}, 1000);

process.nextTick(() => {
  console.log(2);
});

console.log(3);
// Node.js
process.nextTick(() => {
  console.log(1);
  while (true) {}
});

process.nextTick(() => {
  console.log(2);
});

Back to top

eval method

function foo() {
  return eval.bind(null, '(function() { return bar; })');
}

var bar = 1;

(function() {
  var bar = 2;
  foo()()(); // => ?
})();
function foo() {
  return '(function() { return bar; })';
}

var bar = 1;

(function() {
  var bar = 2;
  eval(foo())(); // => ?
})();

Back to top

with operator

var a = 1;

var obj = {
  b: 2
};

with (obj) {
  var b;
  console.log(a + b); // => ?
}
with ({ a: 1 }) {
  a = 2,
  b = 3
}

[window.a, window.b];
with (function (x, undefined) {}) {
  length; // => ?
}
({
  x: 10,
  foo() {
    function bar() {
      console.log(x);      // => ?
      console.log(y);      // => ?
      console.log(this.x); // => ?
    }

    with (this) {
      var x = 20;
      var y = 30;
      bar.call(this);
    }
  }
}).foo();
var foo = { bar: 'baz' && 'foobarbaz' };
with (foo) var bar = eval('bar, 24');

foo.bar;

Back to top

Miscellaneous

(![]+[])[+[]]+(![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]];
({[{}]:{[{}]:{}}})[{}][{}];
(function pewpew(Infinity, length, __proto__) {

  return [,,~0.[0|0]][pewpew.__proto__.length && Infinity,
                      -~String(this).length >> __proto__] << (0. === .0) + Infinity;

}).apply(typeof pewpew, [,,2]);

Back to top

About

❓ A simple quiz for JavaScript developers. Test yourself, your friends, your job applicants and simply enjoy JavaScript)

Topics

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published