Package Exports

@locustjs/extensions-object
@locustjs/extensions-object/index.cjs.js
@locustjs/extensions-object/index.esm.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@locustjs/extensions-object) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

About

This library contains extension methods for Object.

Install

npm i @locustjs/extensions-object

Usage

CommonJs

var someFn = require('@locustjs/extensions-object').someFn;

ES6

import { someFn } from '@locustjs/extensions-object'

function methods

`isSubClassOf(obj, classType)`

Checks whether obj is a sub-class of classType or not and returns true | false.

Example:

class Foo { }
class Bar extends Foo { }
class Buz { }

const x = new Bar();

// call directly
console.log(isSubClassOf(x, Bar));  // true
console.log(isSubClassOf(x, Foo));  // true
console.log(isSubClassOf(x, Buz));  // false

// as an extension method
console.log(x.isSubClassOf(Bar));  // true
console.log(x.isSubClassOf(Foo));  // true
console.log(x.isSubClassOf(Buz));  // false

`toJson(obj, replacer, space)`

Serializes obj into json format using JSON.stringify function.

Example:

const x = { name: 'John Doe', age: 23 };

// call directly
console.log(toJson(x));  // { "name": "John Doe", "age": 23 }

// as an extension method
console.log(x.toJson());  // { "name": "John Doe", "age": 23 }

`merge(obj, obj1, obj2, ...)`

Performs a deep merge on obj by given objects. obj will be affected.

Example:

const x = { name: 'John' };
const a = { a: 10 }
const b = { b: 'test' }

// call directly
console.log(merge(x, a, b));  // { name: 'John', a: 10, b: 'test' }

// as an extension method
console.log(x.merge(a, b));  // { name: 'John', a: 10, b: 'test' }

`flatten(obj, separator)`

Flattens obj properties and returns an object whose properties has only primitive values. The default separator in separating property names is dot character.

Example:

const x = {
    name: 'John',
    address: {
        city: { id: 10, name: 'Tehran' },
        zip: '12345678'
    }
};

// call directly
console.log(flatten(x));
/*
{
    'name': 'John',
    'address.city.id': 10,
    'address.city.name': 'Tehran',
    'address.zip': '12345678',
}
*/

// as an extension method
console.log(x.flatten());

`unflatten(obj, separator)`

Unflattens a flattened obj. See flatten method.

Example:

const x = {
    name: 'John',
    address: {
        city: { id: 10, name: 'Tehran' },
        zip: '12345678'
    }
};

// call directly
const f1 = flatten(x);
const y1 = f1.unflatten();

// as an extension method
const f2 = x.flatten();
const y2 = f2.unflatten();

console.log(y1);
console.log(y2);
/*
{
    name: 'John',
    address: {
        city: { id: 10, name: 'Tehran' },
        zip: '12345678'
    }
}
*/

`toArray(obj, type)`

Converts an object to an array. The result depends on type. Possible values are as follows:

key-value: returns an array of key/value items where each key/value is an array with 2 items, the first item is key, the second is value.
values: retuns only values of properties as an array.
keys or schema: returns only property names as an array.

toArray is similar to Object.entries(). It performs a recursive/nested invokation on object property values whereas Object.entries() only acts on the first-level of properties.

Example:

const x = {
    name: 'John',
    address: {
        city: { id: 10, name: 'Tehran' },
        zip: '12345678'
    },
    age: 23
};

// ==== type: key-value =====
// call directly
console.log(toArray(x, `key-value`));
// as an extension method
console.log(x.toArray('key-value'));
/*
[
    ["name", "John"],
    [
        "address",
        [
            [
                "city",
                [
                    ["id", 10],
                    ["name", "Tehran"]
                ]
            ],
            ["zip", "12345678"]
        ]
    ],
    ["age", 23]
]
*/

// ==== type: values =====
// call directly
console.log(toArray(x, `values`));
// as an extension method
console.log(x.toArray('values'));
/*
[
    "ali",
    [
        [10, "Tehran"],
        "123456789"
    ],
    23
]
*/

// ==== type: keys =====
// call directly
console.log(toArray(x, 'keys'));
// as an extension method
console.log(x.toArray('keys'));
/*
[
    "name",
    [
        "address",
        [
            [
                "city",
                [
                    "id",
                    "name"
                ]
            ],
            "zip"
        ]
    ],
    "age"
]
*/

This function carries out reverse of toObject() extension method in @locustjs/extensions-array.