JavaScript Katas

All unary operators (#8)

unary - an operation with only one operand

Unary "+" operator (#9)

converts its operand to the Number type

Unary "+" operator, in depth (#10)

converts its operand to the Number type

`[].sort()` basics (#1)

The `sort()` function sorts an array as if each element was a string.

`[].sort()` can take a compare function (#2)

Passing a callback to the `sort()` function, allows for any custom sorting.

`parseInt()` (#3)

`parseInt()` in depth (#4)

to boolean (#5)

to number (#6)

`Number.isInteger()` (#55)

`Number.isInteger()` determines if a value is an integer.

`Number.isNaN()` (#80)

`Number.isNaN()` determines if a value is `NaN`.

`Number.parseInt()` (#81)

`Number.parseInt()` parses a string and returns an integer.

`Array.from()` (#29)

Convert a not-array into an array.

`Array.of()` (#30)

`Array.of` creates an array with the given arguments as elements.

`[].fill()` (#31)

`[].fill` can fill up an array with one value.

`[].find()` (#32)

`[].find` makes finding items in arrays easier.

`[].findIndex()` (#33)

`[].findIndex` makes finding items in arrays easier.

`[].entries()` (#41)

`[].entries()` returns an iterator object with all entries.

`[].keys()` (#42)

`[].keys()` returns an iterator for all keys in the array.

`[].values()` (#43)

`[].values()` returns an iterator for all values in the array

creation (#22)

Create a class.

accessors (#23)

Getter+setters as class properties.

static (#24)

Use of the static keyword inside a class.

extends (#25)

How to do inheritance, using `extends`.

more extends (#26)

More in depth `extends` stuff

super in method (#27)

Use of `super` inside a method.

super in constructor (#28)

Use of `super` inside the constructor.

array (#10)

Destructuring arrays allows for more concise.

string (#11)

Destructuring can also be done on strings.

object (#12)

Destructuring objects is a core concepts for modules and more.

defaults (#13)

When destructuring you can also use default values.

parameters (#14)

Destructuring function parameters.

assign (#15)

Assign variables while destructuring.

creation (#49)

There are many ways to create a generator

iterator (#50)

Generators return iterable objects

yield expressions (#51)

The yield keyword is used to pause and resume a generator function

send value to a generator (#52)

By calling next() with a parameter, you can pass a value to a generator.

send function to a generator (#56)

By calling next() with a function, you can pass it to the generator.

`return` inside a generator function (#73)

Return statement in a generator function is special.

Basics (#44)

`map.get()` (#45)

`map.set()` (#46)

initialize (#53)

Initializing a map with values.

`map.has()` (#62)

Indicates whether an element with a key exists.

basics (#75)

A promise represents an operation that hasn`t completed yet, but is expected in the future.

creation (#76)

A promise can be created in multiple ways, learn them all here.

chaining `then()` (#77)

Chaining promises can enhance readability of asynchronous code.

the API (#78)

`Promise` API overview.

`promise.catch()` (#79)

Returns a Promise and deals with rejected cases only.

Basics (#58)

`Reflect.apply()` (#59)

Calls a target function with given scope and arguments.

`Reflect.getPrototypeOf()` (#60)

It returns the prototype of the given object.

`Reflect.construct()` (#68)

The `new` operator as a function.

`Reflect.defineProperty()` (#69)

Defines a property on a given object.

basics (#47)

`set.add()` (#48)

Appends a new element to the end of a Set object.

`set.delete()` (#64)

Removes an element from a set.

the API (#65)

`Set` API overview.

`set.clear()` (#70)

Removes all elements from a Set object.

array (#37)

string (#38)

protocol (#39)

usage (#40)

basics (#9)

ES6 has new shorthands for objects.

computed properties (#16)

Object literal properties may be computed values.

getter (#66)

A getter binds an object property to a function that will be called when that property is looked up.

setter (#67)

A setter binds an object property to a function to be called when there is an attempt to set that property.

`string.includes()` (#63)

Finds string within another string.

`string.repeat(count)` (#71)

Appends `count` copies of `string` to each other and returns it.

`string.startsWith()` (#72)

Determines whether a string begins with the characters of another string.

`string.endsWith()` (#74)

Determines whether a string begins with the characters of another string.

basics (#1)

A template string, is wrapped in backticks.

multiline (#2)

Template strings, can be multiline.

tagged template strings (#3)

Advanced form of template strings.

`raw` property (#4)

The `raw` property accesses the string as it was entered.

basics (#34)

Symbol basics.

`Symbol.for()` (#35)

`Symbol.for()` for registering Symbols globally.

`Symbol.keyFor()` (#36)

`Symbol.keyFor()` gets the symbol key for a given symbol.

basics (#5)

Arrow functions are a more convinient and shorter way to write a function.

function binding (#6)

Arrow functions have lexical `this`, no dynamic `this`.

`let` declaration (#7)

`let` restricts the scope of the variable to the current block.

`const` declaration (#8)

`const` is like `let` plus read-only.

as parameter (#18)

Use the rest operator as parameter.

with destructuring (#19)

Use the rest operator with destructuring.

with arrays (#20)

Spread syntax in use with arrays.

with strings (#21)

Spread syntax in use with strings.

Basics (#57)

Default parameters make function parameters more flexible.

`import` statement (#61)

Use `import` to import functions that have been exported somewhere else.

`Object.is()` (#54)

`Object.is()` compares if two values are the same.

in strings (#17)

How to use unicode in strings.

`[].includes()` (#1)

`Array.prototype.includes()` determines whether an array includes a certain value

`Object.entries()` (#2)

`Object.values()` (#3)

basics (#1)

`string.trimStart()` (#3)

`string.trimStart()` - removes whitespace from the beginning of a string

`Object.fromEntries()` (#1)

`Object.fromEntries()` converts key-value pairs into an object

`Object.fromEntries()` in depth (#2)

`Object.fromEntries()` converts key-value pairs into an object

`equalTo()` (#2)

The most common matcher `equalTo()`.

`strictlyEqualTo()` (#3)

The strict version of `equalTo()`, just like the `===`.

`anything()` (#4)

The matcher `anything()`, matches any value and never fails.

`defined()` (#5)

The matcher `defined()`, matches everything but `undefined`.

`assertThat()` (#1)

The core function needed for most assertions.

`indexOf()` (#1)

The `indexOf()` method returns the first index at which a given element can be found in the array