Place with explanations for each buzzword in the JS world.😀

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

JS Core:

A:

Array

Basic composing data type. More on in Complete guide to Arrays.

Abstract Equality

Comparison operator (x == y, where x and y are values, produces true or false).

More on in ECMA-262 7.2.12 Abstract Equality Comparison.

AJAX

Arrow Functions

C:

Call stack

A stack data structure that keeps information about active function call.

Cast

Explicit conversion a value from one data type to another: String(42).

Coercion

Implicit conversion a value from one data type to another: 42 + ''. Related terms: weak typing.

'1' + '1' // '11'

1 + '2' // '12'
'2' + 1 // '21'

true + '_foo' // 'true_foo'

[] + {} // '[object Object]'
[] + true // 'true'
[1, 2] + [3] // '1,23'

// !gotchas, here {} is empty block instead of object
{} + [] // 0

2 + true // 3
true + true // 2

'1' * '2' // 2
[2] * [3] // 6
[2] * true // 6
true * false // 0
'foo' * true // NaN
5 * { valueOf: () => 5 } // 25
5 * { toString: () => '7' } // 35
5 * { valueOf: () => 5, toString: () => '7' } // 25

D:

Data type

Abstraction that has a bounded set of available values and operations that can be performed on these values.

Dynamic typing

Means that variable can represents any value of any type. Related terms: Duck typing, Weak typing.

Duck typing

General term for “type checks” that make assumptions about a value’s “type” based on its shape (what properties are present). “If it looks like a duck, and quacks like a duck, it must be a duck”. Related terms: Dynamic typing, Weak typing.

E:

Event loop

The mechanism that performs moving functions from the event queue to call stack when it becomes empty. Read more about Event loop in JS.

F:

First-class Function

Functions are treated as values – you can assign a function into a variable, pass it around etc. Related terms: higher-order function.

G:

Generator

Function that can be paused in mid-completion with saving inner state. Related terms: iterator.

function *foo(a) {
  const sum = a + (yield)
  return sum
}

const it = foo(1)
// start
it.next()
// pass value instead of yield
const res = it.next(2) // { value: 3, done: true }
res.value // 3

function *foo(a) {
  const sum = a + (yield 'bar')
  return sum
}

const it = foo(1)
// start
const passedValue = it.next() // { value: 'bar', done: false }
// pass value instead of yield
const res = it.next(2) // { value: 3, done: true }

function *main() {
  try {
    const data = yield fetch('foo.bar')
    console.log(data)
  }
    catch (err) {
    console.error(err)
  }
}

const it = main()
const promise = it.next().value

promise
  .then((data) => it.next(data))
  .catch((err) => it.throw(err))

H:

Higher-order Function

A function that takes a function as an argument, or returns a function. Related terms: first-class function.

Hoisting

Moving all declarations to their respective scopes.

I:

Introspection

The ability of a program to examine the type or properties of an object at runtime. Read more in the Complete Guide to Objects.

Iterable

An object that contains an iterator that can iterate over its values.

const iterable = {
  [Symbol.iterator]() {
    let counter = 0
    const iterator = {
      next() {
        return {
          value: counter++,
          done: counter > 5,
        }
      },
    }
    return iterator
  }
}

for (const step of iterable) {
  console.log(step)
}

// 0
// 1
// ...

const iterable = {
  [Symbol.asyncIterator]() {
    let counter = 0
    const iterator = {
      async next() {
        return {
          value: counter++,
          done: counter > 5,
        }
      },
    }
    return iterator
  }
}

;(async () => {
  for await (const step of iterable) {
    console.log(step)
  }
})()

// 0
// ...

let counter = 0
const iterable = {
  [Symbol.iterator]() { return this },
  next: () => {
    return {
      done: counter > 5,
      value:  counter++,
    }
  }
}

console.log(...iterable) // 0 1 2 3 4 5

Iterator

An object that has the next(..) method on its interface. Related terms: generator.

const iterator = {
  counter: 0,
  next() {
    return {
      value: this.counter++,
      done: this.counter > 5,
    }
  },
}

const step1 = iterator.next() // { value: 0, done: false }
const step2 = iterator.next() // { value: 1, done: false }

const asyncIterator = {
  counter: 0,
  async next() {
    return {
      value: this.counter++,
      done: this.counter > 5,
    }
  },
}

const step1 = asyncIterator.next() // Promise
const step2 = asyncIterator.next() // Promise

J:

JSON

JSON-safe

JSON-safe values consist of values that can be represented as JSON. Not JSON-safe: undefineds, functions, symbols, objects with circular references, Dates, Infinity, RegExps, Maps, Sets, Blobs, FileLists, sparse Arrays, Typed Arrays or other complex types.

L:

Lexical scope

Scope that defined during the lexing time.

Let

Localstorage

M:

Map

N:

Number

Numeric data type, that represents both integer and fractional numbers. Read more in the Complete Guide to Numbers.

O:

Object

Basic data type. More on in Complete Guide to Objects.

P:

Promise

Proxy

ES6 feature that allows boxing software component with an interception of component handlers, like getting/setting/deleting/enumeration object properties, applying arguments to functions, etc.

R:

Reflect

Reflection

The ability for a program to manipulate the values, meta-data, properties and/or functions of an object at runtime.

Regular Expressions

S:

Scope

The accessibility of objects (variables/functions) in some part of your program.

Set

Symbol

New data type offered by ES6, a unique identifier for special object properties.

Stack frame

Block of the stack corresponds to some function call that keeps relative information about this call (local variables, parameters, a location where to be returned).

T:

TCO

Tail Call Optimization. Read more about Tail call optimization in JavaScript.

W:

Weak typing

Means that compiler can use coercion. Related terms: dynamic typing, duck typing.

WeakMap

WeakSet