Skip to content

everget/javascript-quiz

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

173 Commits
LICENSE
LICENSE
 
 
README.md
README.md
 
 

Repository files navigation

JavaScript Quiz

Table of Contents

Category Topics
Language Fundamentals Labels · Semicolons · Template literals · Default parameters · Destructuring assignment
Type System & Coercion Coercions · Comparisons · Inequalities · Calculus · typeof · instanceof
Operators , operator · void · delete · ... (spread)
Control Flow & Error Handling Conditional statements · try-catch
Scope, Context & Execution Hoisting · Scopes & Closures & Hoisting · Context
Functions & Classes Function · arguments · class · GeneratorFunction · AsyncFunction
Core Language Objects Object · Array · String · Number · Boolean · Symbol · Math · Date · RegExp
Meta-Programming Reflect · Proxy
Asynchronous JavaScript Promise · Event loop
Browser Environment Window
Dangerous / Legacy Features eval · with
Miscellaneous Brainf_ck

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

Brainf_ck

(![]+[])[+[]]+(![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]];
({[{}]:{[{}]:{}}})[{}][{}];
(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

javascript js quiz javascript-quiz

Resources

Readme

License

MIT license
Activity

Stars

43 stars

Watchers

2 watching

Forks

10 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors