API / Core / Object

Object

empty

RESCRIPT
let empty: unit => {..}

empty create a new object that inherits the properties and methods from the standard built-in Object, such as toString. See Object on MDN

Examples

RESCRIPT
let x = Object.empty() x->Object.keysToArray->Array.length // 0 x->Object.get("toString")->Option.isSome // true

is

RESCRIPT
let is: ('a, 'a) => bool

is determines if two objects are identical in all contexts. Objects, arrays, records, and other non-primitives are only identical if they reference the exact same object in memory. Primitives like ints, floats, and strings are identical if they have the same value. +0 and -0 are distinct. NaN is equal to itself. See Object.is on MDN

In most scenarios use == or === or the custom equals function (if provided) for the type.

Examples

RESCRIPT
Object.is(25, 13) // false Object.is("abc", "abc") // true Object.is(undefined, undefined) // true Object.is(undefined, null) // false Object.is(-0.0, 0.0) // false Object.is(list{1, 2}, list{1, 2}) // false Object.is([1, 2, 3], [1, 2, 3]) // false [1, 2, 3] == [1, 2, 3] // true [1, 2, 3] === [1, 2, 3] // false let fruit = {"name": "Apple" } Object.is(fruit, fruit) // true Object.is(fruit, {"name": "Apple" }) // false fruit == {"name": "Apple" } // true fruit === {"name": "Apple" } // false

create

RESCRIPT
let create: {..} => {..}

create creates a new object, using an existing object as the prototype of the new object. See Object.create on MDN

Note: ReScript provides first-class support for immutable objects and records. This is often safer and more convenient than using create and other functions in this module.

Examples

RESCRIPT
let x = {"fruit": "banana"} let y = Object.create(x) y->Object.get("fruit") // Some("banana")

createWithProperties

RESCRIPT
let createWithProperties: ({..}, {..}) => {..}

createWithNull

RESCRIPT
let createWithNull: unit => {..}

createWithNullAndProperties

RESCRIPT
let createWithNullAndProperties: {..} => {..}

assign

RESCRIPT
let assign: ({..}, {..}) => {..}

assign(target, source) copies enumerable own properties from the source to the target, overwriting properties with the same name. It returns the modified target object. A deep clone is not created; properties are copied by reference.

Warning: ReScript provides compile-time support for type-safe access to JavaScript objects. This eliminates common errors such as accessing properties that do not exist, or using a property of type x as if it were a y. Using assign can bypass these safety checks and lead to run-time errors (if you are not careful). ReScript provides first-class support for immutable objects and records. This is often safer and more convenient than using assign and other functions in this module.

See Object.assign on MDN or ECMAScript Language Specification.

Examples

RESCRIPT
Object.assign({"a": 1}, {"a": 2}) // {"a": 2} Object.assign({"a": 1, "b": 2}, {"a": 0}) // {"a": 0, "b": 2} Object.assign({"a": 1}, {"a": null}) // {"a": null}

assignMany

RESCRIPT
let assignMany: ({..}, array<{..}>) => {..}

assignMany(target, sources) copies enumerable own properties from each source to the target, overwriting properties with the same name. Later sources' properties overwrite earlier ones. It returns the modified target object. A deep clone is not created; properties are copied by reference.

Note: ReScript provides first-class support for immutable objects, including spreading one object into another. This is often more convenient than using assign or assignMany.

See Object.assign on MDN or ECMAScript Language Specification.

copy

RESCRIPT
let copy: ({..} as 'a) => 'a

get

RESCRIPT
let get: ({..}, string) => option<'a>

get gets the value of a property by name. Returns None if the property does not exist or has the value undefined. Otherwise returns Some, including if the value is null.

Examples

RESCRIPT
{"a": 1}->Object.get("a") // Some(1) {"a": 1}->Object.get("b") // None {"a": undefined}->Object.get("a") // None {"a": null}->Object.get("a") // Some(null) {"a": 1}->Object.get("toString")->Option.isSome // true

getSymbol

RESCRIPT
let getSymbol: ({..}, Core__Symbol.t) => option<'a>

getSymbol gets the value of a property by symbol. Returns None if the property does not exist or has the value undefined. Otherwise returns Some, including if the value is null.

Examples

RESCRIPT
let fruit = Symbol.make("fruit") let x = Object.empty() x->Object.setSymbol(fruit, "banana") x->Object.getSymbol(fruit) // Some("banana")

getSymbolUnsafe

RESCRIPT
let getSymbolUnsafe: ({..}, Core__Symbol.t) => 'a

set

RESCRIPT
let set: ({..}, string, 'a) => unit

set(name, value) assigns a value to the named object property, overwriting the previous value if any. See Working with Objects on MDN

Examples

RESCRIPT
{"a": 1}->Object.set("a", 2) // {"a": 2} {"a": 1}->Object.set("a", None) // {"a": None} {"a": 1}->Object.set("b", 2) // {"a": 1, "b": 2}

setSymbol

RESCRIPT
let setSymbol: ({..}, Core__Symbol.t, 'a) => unit

keysToArray

RESCRIPT
let keysToArray: {..} => array<string>

keysToArray returns an array of an object's own enumerable string-keyed property names. See ECMAScript Language Specification or Object.keys on MDN.

Examples

RESCRIPT
{"a": 1, "b": 2}->Object.keysToArray // ["a", "b"] {"a": None}->Object.keysToArray // ["a"] Object.empty()->Object.keysToArray // []

hasOwnProperty

RESCRIPT
let hasOwnProperty: ({..}, string) => bool

hasOwnProperty determines whether the object has the specified property as its own property, as opposed to inheriting it. See hasOwnProperty on MDN

Examples

RESCRIPT
let point = {"x": 1, "y": 2} {"a": 1}->hasOwnProperty("a") // true {"a": 1}->hasOwnProperty("b") // false {"a": 1}->hasOwnProperty("toString") // false

seal

RESCRIPT
let seal: ({..} as 'a) => 'a

seal seals an object. Sealing an object prevents extensions and makes existing properties non-configurable. A sealed object has a fixed set of properties. Unlike freeze, values of existing properties can still be changed as long as they are writable.

Note: seal returns the same object that was passed in; it does not create a copy. Any attempt to delete or add properties to a sealed object will fail, either silently or by throwing an error.

See ECMAScript Language Specification and Object.seal on MDN

Examples

RESCRIPT
let point = {"x": 1, "y": 2} point->Object.set("x", -7) // succeeds point->Object.seal->ignore point->Object.set("z", 9) // fails point->Object.set("x", 13) // succeeds

preventExtensions

RESCRIPT
let preventExtensions: ({..} as 'a) => 'a

preventExtensions prevents new properties from being added to the object. It modifies the object (rather than creating a copy) and returns it.

See ECMAScript Language Specification and Object.preventExtensions on MDN

Examples

RESCRIPT
let obj = {"a": 1} obj->Object.set("b", 2) // succeeds obj->Object.preventExtensions->ignore obj->Object.set("c", 3) // fails

freeze

RESCRIPT
let freeze: ({..} as 'a) => 'a

freeze freezes an object. Freezing an object makes existing properties non-writable and prevents extensions. Once an object is frozen, new properties cannot be be added, existing properties cannot be removed, and their values cannot be changed.

Note: freeze returns the same object that was passed in; it does not create a frozen copy. Any attempt to change a frozen object will fail, either silently or by throwing an exception.

See ECMAScript Language Specification and Object.isFrozen on MDN.

Examples

RESCRIPT
let obj = {"a": 1} obj->Object.set("a", 2) // succeeds obj->Object.freeze->ignore obj->Object.set("a", 3) // fails

isSealed

RESCRIPT
let isSealed: 'a => bool

isSealed determines if an object is sealed. A sealed object has a fixed set of properties.

See ECMAScript Language Specification and Object.isSealed on MDN

Examples

RESCRIPT
let point = {"x": 1, "y": 3}->Object.seal let pointIsSealed = point->Object.isSealed // true let fruit = {"name": "Apple" } let fruitIsSealed = fruit->Object.isSealed // false

isFrozen

RESCRIPT
let isFrozen: 'a => bool

isFrozen determines if an object is frozen. An object is frozen if an only if it is not extensible, all its properties are non-configurable, and all its data properties are non-writable.

See ECMAScript Language Specification and Object.isFrozen on MDN.

Examples

RESCRIPT
let point = {"x": 1, "y": 3}->Object.freeze let pointIsFrozen = point->Object.isFrozen // true let fruit = {"name": "Apple" } let fruitIsFrozen = fruit->Object.isFrozen // false

isExtensible

RESCRIPT
let isExtensible: 'a => bool

isExtensible determines if an object is extensible (whether it can have new properties added to it).

See ECMAScript Language Specification and Object.isExtensible on MDN

Examples

RESCRIPT
let obj = {"a": 1} obj->Object.isExtensible // true obj->Object.preventExtensions->ignore obj->Object.isExtensible // false