JavaScript Lists

A random collection of different lists related to the JavaScript language.


Primitive Literals
bigint 1n, 0xFn, 0o7n, 0b1n
boolean true, false
null null
number 1, 1.2, 0xF, 0o7, 0b1, 1e2, 1e-2
string 'string', "string", `string`
symbol none
undefined none (though accessible via global undefined)

Be on the look out for the upcoming BigDecimal.

Object Literals

Object Literals
Object { key0: value0, key1: value1, keyN: valueN }
Array [ value0, value1, valueN ]
RegExp /expression/flags

Primitive Objects

Object Type Constructor Conversion
BigInt No Yes
Boolean Yes Yes
Number Yes Yes
String Yes Yes
Symbol No No

BigInt vs. Number

Where value in the examples represents a BigInt or Number value.

BigInt Number
Constructor No Yes
Exponential Notation No Yes
Supports Decimal Values No Yes
Supported in JSON No Yes
typeof value 'bigint' 'number', -value) where value is 0 true false
1 + value (or other arithmetic operatation) Error Number
1n + value (or other arithmetic operatation) BigInt Error
1 ^ value (or other bitwise operatation) Error Number
1n ^ value (or other bitwise operatation) BigInt Error
+value Error Number
Math.round(value) (or other Math operation) Error Number
Array index in methods (e.g. array.slice(value)) Error Yes


Where name is the identifier being created and /* scope */ represents the scope where that identifier is available

Kind Example
Catch error binding try { } catch (name) { /* scope */ }
Class /* scope */ class name {}
Named class name (class name { /* scope */ })
Const /* scope */ const name = value;
Function /* scope */ function name () {}
Function parameter (function (name /* scope */ ) { /* scope */ })
Named function expression name (function name ( /* scope */ ) { /* scope */ })
Import /* scope */ import name from 'path'
Label name: { /* scope */ }
Let /* scope */ let name;
Var /* scope */ var name;

Note: Scopes within the parameter list refers to default parameter expressions.

Assign vs. Define

Assign sets a property through getter/setters (if they exist) while define will not.

Operation Example Method
Assignment Operator object.prop = value Assign
Array Methods object.push(value)
Object.assign Object.assign(object, { prop: value }) Assign
Reflect.set Reflect.set(object, 'prop', value) Assign
Array Literal [ value ] Define
Array Spread [ ...[ value ] ] Define
Class Declaration Fields class { prop = value } Define
Class Declaration Methods class { prop() {} } Define
JSON.parse JSON.parse('{"prop":value}') Define
Object Literal { prop: value } Define
Object Spread { ...{ prop: value } } Define
Object.create Object.create(object, { prop: { value } }) Define
Object.defineProperty Object.defineProperty(object, 'prop', { value }) Define
Object.fromEntries Object.fromEntries([['prop', value]]) Define

Default Property Descriptors

Operation Example Default Descriptor
Assignment object.prop = value configurable: true
enumerable: true
writable: true
Global var Declaration var prop = value configurable: false
enumerable: true
writable: true
Class Field class { prop = value } configurable: true
enumerable: true
writable: true
Class Method class { prop () {} } configurable: true
enumerable: false
writable: true
Define Property Object.defineProperty(object, 'prop', { value }) configurable: false
enumerable: false
writable: false
Imports (prop in Module) import * as Module from './module.js' configurable: false
enumerable: true
writable: true

Every assign operation as well as many of the other define operations (those that don't explicitly say "define") will use the same Assignment descriptor configuration.



Statement Loops Over
do...while User-defined condition
for User-defined condition Objects
for...of Iterables
for await...of Async Iterables
while User-defined condition

Collection Methods

Method Return Value Early Exit In Array In Map In Set
every Boolean Yes Yes No No
some Boolean Yes Yes No No
filter any No Yes No No
find any Yes Yes No No
findIndex Number Yes Yes No No
flatMap Array No Yes No No
forEach none No Yes Yes Yes
map Array No Yes No No
reduce any No Yes No No
reduceRight any No Yes No No

Metadata Collections

Metadata collections can be created for objects and iterated over.

For Operation Returns
Array/Map/Set value.entries() Iterable
Array/Map/Set value.keys() Iterable
Array/Map/Set value.values() Iterable
non-null Object.entries(value) Array
non-null Object.keys(value) Array
non-null Object.values(value) Array
non-null Object.getOwnPropertyDescriptors(value) Object
non-null Object.getOwnPropertyNames(value) Array
non-null Object.getOwnPropertySymbols(value) Array
Object Reflect.ownKeys(object) Array

Object Iteration Values

When iterating over an object, what values are used for that iteration.

Operation String Keys Symbol Keys Own Inherited Non-enumerable Yes No Yes Yes No
JSON.stringify Yes No Yes No No
Object.entries Yes No Yes No No
Object.keys Yes No Yes No No
Object.values Yes No Yes No No
Object.assign Yes Yes Yes No No
Object.defineProperties Yes Yes Yes No No
Object.getOwnPropertyDescriptors Yes Yes Yes No Yes
Object.getOwnPropertyNames Yes No Yes No Yes
Object.getOwnPropertySymbols No Yes Yes No Yes
Reflect.ownKeys Yes Yes Yes No Yes
Object Spread Yes Yes Yes No No

Creating Functions

Creating functions named name (or anonymous).

Kind Example Name Constructable
Function Declaration function name () {} Explicit Yes
Default Function Declaration export default function () {} Anonymous Yes
Async Function Declaration async function name () {} Explicit No
Generator Function Declaration function * name () {} Explicit No
Async Generator Function Declaration async function * name () {} Explicit No
Function Expression (function () {}) Anonymous Yes
Async Function Expression (async function () {}) Anonymous No
Generator Function Expression (function * () {}) Anonymous No
Async Generator Function Expression (async function * () {}) Anonymous No
Named Function Expression (function name () {}) Explicit Yes
Named Async Function Expression (async function name () {}) Explicit No
Named Generator Function Expression (function * name () {}) Explicit No
Named Async Generator Function Expression (async function * name () {}) Explicit No
Arrow Function () => {} Anonymous No
Async Arrow Function async () => {} Anonymous No
Class Declaration class name { constructor () {} } Explicit Yes
Class Expression (class { constructor () {} }) Anonymous Yes
Named Class Expression (class name { constructor () {} }) Explicit Yes
Class Method class { name () {} } Explicit No
Async Class Method class { async name () {} } Explicit No
Class Method Generator class { * name () {} } Explicit No
Async Class Method Generator class { async * name() {} } Explicit No
Class Getter class { get name() {} } Explicit No
Class Setter class { set name(value) {} } Explicit No
Object Method (Shorthand) ({ name () {} }) Explicit No
Async Object Method (Shorthand) ({ async name () {} }) Explicit No
Object Method Generator (Shorthand) ({ * name () {} }) Explicit No
Async Object Method Generator (Shorthand) ({ async * name() {} }) Explicit No
Object Getter ({ get name() {} }) Explicit No
Object Setter ({ set name(value) {} }) Explicit No
Function Constructor new Function(), Function() Anonymous Yes
AsyncFunction Constructor new AsyncFunction(), AsyncFunction() Anonymous No
GeneratorFunction Constructor new GeneratorFunction(), GeneratorFunction() Anonymous No
AsyncGeneratorFunction Constructor new AsyncGeneratorFunction(), AsyncGeneratorFunction() Anonymous No

Note: Any expression context will work for expression variations, not just the grouping (()) used in the examples shown.

Note: The AsyncFunction, GeneratorFunction and AsyncGeneratorFunction constructors are not globally accessible but can be obtained from existing instances/declarations.

Function Syntax

Square brackets ([]) represent optional keywords or names whereas angle brackets (<>) represents a required item. Not all combinations are compatible.

Kind Syntax
Function Declaration or Expression [async] function [*] [name] () {}
Arrow Function [async] () => {}
Class Declaration or Expression [@<decorator>] class [name] [extends <expression>] {}
Class Method class { [@<decorator>] [static] [async] [get] [set] [*] [#]<name> () {} }
Object Method (Shorthand) { [async] [get] [set] [*] <name> () {} }

Calling Functions

Calling a function identified as name.

Kind Call
Call name()
Call name.apply()
Template Literal Tag (Call) name``
Construct new name
Construct new name()
Call Refect.apply(name)
Construct Reflect.construct(name)

Additional Ways to Make Calls

This lists more obscure ways of function calling which may require special function definitions.

Kind Definition Call
Getter obj = { get name () {} }
Setter obj = { set name (value) {} } = null
Thenable obj = { then () {} } await obj
Iterator obj = { [Symbol.iterator] () {} } [...obj]
Iterator obj = { [Symbol.iterator] () {} } for (let i of obj);
Asynchronous Iterator obj = { [Symbol.asyncIterator] () {} } for await (let i of obj);
To Primitive obj = { toString () {} } Object[obj]
To Primitive obj = { valueOf () {} } +obj
To Primitive obj = { [Symbol.toPrimitive] () {} } +obj
Has Instance obj = { [Symbol.hasInstance] () {} } null instanceof obj

To Primitive Precedence

Different methods get prioritization when converting objects to primitives. If present, a Symbol.toPrimitive will always be used. If not, conversion will rely on toString() and valueOf(), using the other as a fallback if the first attempted fails to produce a primitive. Which is called first depends on the "hint" of the operation. This can have one of 3 values: "string", "number", or "default". "string" prefers toString() while "number" and "default" prefer valueOf(). If Symbol.toPrimitive is available, the hint will be passed in as an argument.

Where value is an ordinary object.

Operation Primary Hint Secondary Backup
'' == value Symbol.toPrimitive "default" valueOf toString
'' + value Symbol.toPrimitive "default" valueOf toString
1 > value (or other relational operation) Symbol.toPrimitive "number" valueOf toString
1 * value (or other arithmetic operation) Symbol.toPrimitive "number" valueOf toString
1 ^ value (or other bitwise operation) Symbol.toPrimitive "number" valueOf toString
+value (or other unary operation) Symbol.toPrimitive "number" valueOf toString
Math.round(value) (or other Math operation) Symbol.toPrimitive "number" valueOf toString
Number(value) Symbol.toPrimitive "number" valueOf toString
BigInt(value) Symbol.toPrimitive "number" valueOf toString
`${value}` Symbol.toPrimitive "string" toString valueOf
String(value) Symbol.toPrimitive "string" toString valueOf
Symbol(value) Symbol.toPrimitive "string" toString valueOf
Object[value] Symbol.toPrimitive "string" toString valueOf
value in object Symbol.toPrimitive "string" toString valueOf

ASI Considerations

There can be ambiguity between operations when starting a line with the following characters where ASI (Automatic Semicolon Insertion) will not insert a semicolon to terminate the previous line's expression.

Line Starts With Semicolon Before No Semicolon Before
[ Array literal Array access
( Grouping Function call
` Template literal Tagged template literal
+ Unary + Addition
- Unary - Subtraction
* Generator method Multiplication (of preceding field initializer)
/ RegExp literal Division


These were older lists entries that no longer apply.


Iteration Order

A specification-defined order known as [[OwnPropertyKeys]] is set for some operations. Other operations (like do not have to follow this order and are implementation-dependent. [[OwnPropertyKeys]] ordering uses:

  1. Integer keys between 0 and 2^53-1 (inclusive) in ascending order
  2. Other non-symbol keys in creation order
  3. Symbol keys in creation order
Operation Ordering Not guaranteed
JSON.stringify Not guaranteed
JSON.parse Not guaranteed
Object.entries Not guaranteed
Object.keys Not guaranteed
Object.values Not guaranteed
Object.assign Well-defined
Object.defineProperties Well-defined
Object.getOwnPropertyDescriptors Well-defined
Object.getOwnPropertyNames Well-defined
Object.getOwnPropertySymbols Well-defined
Reflect.ownKeys Well-defined

Where well-defined refers to [[OwnPropertyKeys]] ordering.

:put_litter_in_its_place:   Deprecation: As of ES2020's for-in mechanics, iteration order is now well defined for the places where before it was not guaranteed.