Object
make
let make: unit => {..}
make
create a new object that inherits the properties and methods from the standard built-in Object, such as toString
. See Object on MDN
Examples
RESCRIPTlet x = Object.make()
x->Object.keysToArray->Array.length // 0
x->Object.get("toString")->Option.isSome // true
is
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
RESCRIPTObject.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
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
RESCRIPTlet x = {"fruit": "banana"}
let y = Object.create(x)
y->Object.get("fruit") // Some("banana")
createWithProperties
let createWithProperties: ({..}, {..}) => {..}
createWithNull
let createWithNull: unit => {..}
createWithNullAndProperties
let createWithNullAndProperties: {..} => {..}
assign
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
RESCRIPTObject.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
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
let copy: ({..} as 'a) => 'a
get
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
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
RESCRIPTlet fruit = Symbol.make("fruit")
let x = Object.make()
x->Object.setSymbol(fruit, "banana")
x->Object.getSymbol(fruit) // Some("banana")
getSymbolUnsafe
let getSymbolUnsafe: ({..}, Core__Symbol.t) => 'a
set
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
let setSymbol: ({..}, Core__Symbol.t, 'a) => unit
keysToArray
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.make()->Object.keysToArray // []
hasOwnProperty
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
RESCRIPTlet point = {"x": 1, "y": 2}
{"a": 1}->Object.hasOwnProperty("a") // true
{"a": 1}->Object.hasOwnProperty("b") // false
{"a": 1}->Object.hasOwnProperty("toString") // false
seal
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
RESCRIPTlet 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
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
RESCRIPTlet obj = {"a": 1}
obj->Object.set("b", 2) // succeeds
obj->Object.preventExtensions->ignore
obj->Object.set("c", 3) // fails
freeze
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
RESCRIPTlet obj = {"a": 1}
obj->Object.set("a", 2) // succeeds
obj->Object.freeze->ignore
obj->Object.set("a", 3) // fails
isSealed
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
RESCRIPTlet point = {"x": 1, "y": 3}->Object.seal
let pointIsSealed = point->Object.isSealed // true
let fruit = {"name": "Apple" }
let fruitIsSealed = fruit->Object.isSealed // false
isFrozen
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
RESCRIPTlet point = {"x": 1, "y": 3}->Object.freeze
let pointIsFrozen = point->Object.isFrozen // true
let fruit = {"name": "Apple" }
let fruitIsFrozen = fruit->Object.isFrozen // false
isExtensible
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
RESCRIPTlet obj = {"a": 1}
obj->Object.isExtensible // true
obj->Object.preventExtensions->ignore
obj->Object.isExtensible // false