Object

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 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 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")

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(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.

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 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")

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}

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 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 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 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 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 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 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 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