Github Medium

@angular-ru/cdk/object

  • sortByAsc

const objectList: A[] = [{ a: 1 }, { a: 3 }, { a: 2 }, { a: -1 }, { a: 0 }];

expect(objectList.slice().sort((a, b) => sortByAsc('a', a, b))).toEqual([
    { a: -1 },
    { a: 0 },
    { a: 1 },
    { a: 2 },
    { a: 3 }
]);

  • sortByDesc

const objectList: A[] = [{ a: 1 }, { a: 3 }, { a: 2 }, { a: -1 }, { a: 0 }];

expect(objectList.slice().sort((a, b) => sortByDesc('a', a, b))).toEqual([
    { a: 3 },
    { a: 2 },
    { a: 1 },
    { a: 0 },
    { a: -1 }
]);

  • isObject - check inheritance of object

import { isObject } from '@angular-ru/cdk/object';

class A {}

expect(isObject(NaN)).toBe(false);
expect(isObject(null)).toBe(false);
expect(isObject(undefined)).toBe(false);
expect(isObject(1)).toBe(false);
expect(isObject(Infinity)).toBe(false);
expect(isObject('')).toBe(false);
// non primitive
expect(isObject([])).toBe(true);
expect(isObject({})).toBe(true);
expect(isObject(new A())).toBe(true);
expect(isObject(new Date())).toBe(true);
expect(isObject(new Map())).toBe(true);
expect(isObject(() => {})).toBe(true);
expect(isObject(new Number(6))).toBe(true);
expect(isObject(Math)).toBe(true);
expect(isObject(Object.create(null))).toBe(true);
expect(isObject(document.createElement('div'))).toBe(true);
expect(isObject(new (function Foo() {})())).toBe(true);
expect(isObject(window)).toBe(true);

  • isPlainObject - check only literal object (non instance object)

import { isPlainObject } from '@angular-ru/cdk/object';

class A {}

expect(isPlainObject(NaN)).toBe(false);
expect(isPlainObject(null)).toBe(false);
expect(isPlainObject(undefined)).toBe(false);
expect(isPlainObject(1)).toBe(false);
expect(isPlainObject(Infinity)).toBe(false);
expect(isPlainObject('')).toBe(false);
// plain object
expect(isPlainObject({})).toBe(true);
expect(isPlainObject(Object.create(null))).toBe(true);
// complex object (not plain literal)
expect(isPlainObject([])).toBe(false);
expect(isPlainObject(new A())).toBe(false);
expect(isPlainObject(new Date())).toBe(false);
expect(isPlainObject(new Map())).toBe(false);
expect(isPlainObject(() => {})).toBe(false);
expect(isPlainObject(new Number(6))).toBe(false);
expect(isPlainObject(Math)).toBe(false);
expect(isPlainObject(document.createElement('div'))).toBe(false);
expect(isPlainObject(new (function Foo() {})())).toBe(false);

  • isSimpleObject - check only instance object or literal (non complex structure - Array, DOM, Set, Map, Date, other structure)

import { isSimpleObject } from '@angular-ru/cdk/object';

class A {}

expect(isSimpleObject(NaN)).toBe(false);
expect(isSimpleObject(null)).toBe(false);
expect(isSimpleObject(undefined)).toBe(false);
expect(isSimpleObject(1)).toBe(false);
expect(isSimpleObject(Infinity)).toBe(false);
expect(isSimpleObject('')).toBe(false);
// instance object, literal object
expect(isSimpleObject(new A())).toBe(true);
expect(isSimpleObject(Object.create(null))).toBe(true);
expect(isSimpleObject({})).toBe(true);
expect(isSimpleObject(new (function Foo() {})())).toBe(true);
// complex object (Array, DOM, Set, Map, other structure)
expect(isSimpleObject([])).toBe(false);
expect(isSimpleObject(new Date())).toBe(false);
expect(isSimpleObject(new Map())).toBe(false);
expect(isSimpleObject(() => {})).toBe(false);
expect(isSimpleObject(new Number(6))).toBe(false);
expect(isSimpleObject(Math)).toBe(false);
expect(isSimpleObject(document.createElement('div'))).toBe(false);

  • isGetter

import { isGetter } from '@angular-ru/cdk/object';

class A {
    public get a(): number {
        return 1;
    }

    public b: string = '2';
}

expect(isGetter(new A(), 'a')).toEqual(true);
expect(isGetter(new A(), 'b')).toEqual(false);

expect(
    isGetter(
        {
            get a() {
                return 2;
            }
        },
        'a'
    )
).toEqual(true);

expect(
    isGetter(
        {
            _a: null,
            set a(value: any) {
                this._a = value;
            }
        },
        'a'
    )
).toEqual(false);

expect(isGetter({ a: 2 }, 'a')).toEqual(false);

  • isIterable

expect(isIterable([1, 2])).toBe(true);
expect(isIterable('Some String')).toBe(true);
expect(isIterable(new Set([1, 2]))).toBe(true);
expect(
    isIterable(
        new Map([
            ['a', 1],
            ['b', 2]
        ])
    )
).toBe(true);
expect(
    isIterable(
        new Map([
            ['a', 1],
            ['b', 2]
        ]).entries()
    )
).toBe(true);

expect(isIterable({ a: 1, b: 2 })).toBe(false);
expect(isIterable(null)).toBe(false);
expect(isIterable(undefined)).toBe(false);
expect(isIterable(0)).toBe(false);
expect(isIterable(true)).toBe(false);
expect(isIterable(() => {})).toBe(false);

  • deepClone

import { deepClone } from '@angular-ru/cdk/object';
import { Origin } from './origin';

const origin: Origin = { a: 1, b: { c: 2 } };
const copy: Origin = deepClone(origin);
expect(Object.is(origin, copy)).toEqual(false);

copy.b.c = 4;
expect(origin.b.c).toEqual(2);

origin.b.c = 3;
expect(origin.b.c).toEqual(3);
expect(copy.b.c).toEqual(4);

  • deepFreeze

import { deepFreeze } from '@angular-ru/cdk/object';
import { Origin } from './origin';

const origin: Origin = deepFreeze({ a: 1, b: { c: 2 } });
let message: string | null = null;

try {
    origin.b.c = 5;
} catch (e) {
    message = e.message;
}

expect(message).toEqual(`Cannot assign to read only property 'c' of object '[object Object]'`);

  • replaceWithNull

import { PlainObject } from '@angular-ru/cdk/typings';
import { replaceWithNull } from '@angular-ru/cdk/object';

const wrongElem: PlainObject = {
    a: '',
    b: [
        { c: NaN, d: 1 },
        { c: '   ', d: undefined },
        { c: 0, d: 0 }
    ],
    e: Infinity
};

expect(replaceWithNull(wrongElem)).toEqual({
    a: null,
    b: [
        { c: null, d: 1 },
        { c: null, d: null },
        { c: 0, d: 0 }
    ],
    e: null
});

  • clean

import { PlainObject } from '@angular-ru/cdk/typings';
import { clean } from '@angular-ru/cdk/object';

const A: PlainObject = clean({
    a: 1,
    b: undefined,
    c: '',
    d: null,
    e: NaN,
    f: [
        {
            a: 2,
            b: undefined,
            c: '',
            d: Infinity
        },
        {
            a: 3,
            b: undefined,
            c: '',
            d: Infinity
        }
    ],
    g: {
        a: 4,
        b: undefined,
        c: '',
        d: Infinity
    },
    h: Infinity
});

const B: PlainObject = { a: 1, f: [{ a: 2 }, { a: 3 }], g: { a: 4 } };

expect(A).toEqual(B);

  • getValueByPath

import { PlainObject } from '@angular-ru/cdk/typings';
import { getValueByPath } from '@angular-ru/cdk/object';

const obj: PlainObject = { a: 1, f: [{ a: 2 }, { a: 3 }], g: { a: 4 } };

expect(getValueByPath(obj, 'g.a')).toEqual(4);
expect(getValueByPath(obj, 'f.0')).toEqual({ a: 2 });
expect(getValueByPath(obj, 'f.0.a')).toEqual(2);
expect(getValueByPath(obj, 'abc')).toEqual(undefined);
expect(getValueByPath(obj, 'f.0.a.Z', [])).toEqual([]);

  • checkIsShallowEmpty

import { checkIsShallowEmpty } from '@angular-ru/cdk/object';

expect(checkIsShallowEmpty({ a: 0 })).toEqual(false);
expect(checkIsShallowEmpty({ a: { b: '' } })).toEqual(false);
expect(checkIsShallowEmpty({ a: 'hello' })).toEqual(false);
// shallow empty object
expect(checkIsShallowEmpty({})).toEqual(true);
expect(checkIsShallowEmpty({ a: null })).toEqual(true);
expect(checkIsShallowEmpty({ a: '', b: undefined, c: NaN, d: '   ' })).toEqual(true);

  • equals, objectToString, flatten, strictEquals, shallowTrimProperties

it('should be object A equals object B', (): void => {
    const A: PlainObject = { a: 1, b: [1, 2] };
    const B: PlainObject = { a: 1, b: [1, 2] };

    expect(equals(A, B)).toBe(true);
});

it('should be not equals A and B when shallow comparison unsorted keys', (): void => {
    const A: PlainObject = { a: 1, c: { e: 2, d: 1 }, b: [1, 2] };
    const B: PlainObject = { b: [1, 2], a: 1, c: { d: 1, e: 2 } };

    expect(equals(A, B)).toBe(false);
});

it('should be not equals A and B when deep comparison unsorted keys', (): void => {
    const A: PlainObject = { a: 1, c: { e: 2, d: 1 }, b: [1, 2] };
    const B: PlainObject = { b: [1, 2], a: 1, c: { d: 1, e: 2 } };
    const D: PlainObject = { a: 1, b: 2, c: [{ e: 2, d: 1 }] };
    const E: PlainObject = { a: 1, b: 2, c: [{ d: 1, e: 2 }] };

    expect(equals(A, B, { deep: true })).toBe(true);
    expect(equals(D, E, { deep: true })).toBe(true);
});

it('should be return true for equals primitive types', (): void => {
    expect(equals(null!, null!)).toBe(true);
    expect(equals(undefined!, undefined!)).toBe(true);
    expect(equals(NaN as NaN as any)).toBe(true);
    expect(equals(Infinity as Infinity as any)).toBe(true);
    expect(equals('' as '' as any)).toBe(true);
    expect(equals(1 as 1 as any)).toBe(true);

    expect(equals('1' as 1 as any)).toBe(false);
    expect(equals(null!, undefined!)).toBe(false);
    expect(equals(NaN as !undefined, { deep: true })).toBe(false);
});

it('should be a proper comparison with a weak and strict type', (): void => {
    expect(equals({ a: '1' }, { a: 1 })).toBe(false);
    expect(equals({ a: '1' }, { a: 1 }, { weekType: true })).toBe(true);
});

it('should be correct work objectToString', (): void => {
    expect(objectToString(1 as any)).toBe('1');
    expect(objectToString('1' as any)).toBe('"1"');
    expect(objectToString(null!)).toBe('null');
    expect(objectToString(undefined!)).toBe(undefined);

    expect(objectToString({ a: 1, b: 2 })).toBe('{"a":1,"b":2}');

    expect(objectToString([{ b: 2, a: 1 }])).toBe('[{"b":2,"a":1}]');

    expect(objectToString([{ b: 2, a: 1 }], { deep: true })).toBe('[{"a":1,"b":2}]');

    expect(objectToString({ a: 1, b: 2, c: [{ e: 2, d: 1 }] })).toBe('{"a":1,"b":2,"c":[{"e":2,"d":1}]}');

    expect(objectToString({ a: 1, b: 2, c: [{ e: 2, d: 1 }] }, { deep: true })).toBe(
        '{"a":1,"b":2,"c":[{"d":1,"e":2}]}'
    );
});

it('should be correct flatten object', (): void => {
    const actual: PlainObject = {
        a: {
            b: 1,
            c: {
                d: 2
            },
            d: [{ e: 3 }, { f: 4 }]
        },
        g: 5
    };

    const expected: PlainObject = { 'a.b': 1, 'a.c.d': 2, 'a.d.0.e': 3, 'a.d.1.f': 4, g: 5 };

    expect(flatten<number>(actual)).toEqual(expected);
});

it('should be correct deep equals with week type', (): void => {
    expect(
        strictEquals(
            {
                a: 1,
                b: 2,
                c: { d: { f: { g: 'd' } } }
            },
            {
                a: 1,
                b: 2,
                c: { d: { f: { g: 'i' } } }
            }
        )
    ).toEqual(false);

    expect(
        strictEquals(
            {
                a: null,
                b: undefined,
                c: NaN
            },
            {
                a: null,
                b: null,
                c: null
            }
        )
    ).toEqual(true);

    expect(
        strictEquals(
            {
                a: null,
                b: undefined
            },
            {
                a: null,
                b: null,
                c: null
            }
        )
    ).toEqual(false);
});

  • shallowMapObject

import { shallowMapObject } from '@angular-ru/cdk/object';

const oneTypeObject = { a: 1, b: 3, c: 5 };
expect(shallowMapObject(oneTypeObject, (a: number): number => a * 2)).toEqual({
    a: 2,
    b: 6,
    c: 10
});

const complexObject = { a: 1, b: 'two', c: true, d: undefined, e: null, f: { field: 'value' }, g: [1, 2, 3] };
expect(shallowMapObject(complexObject, (a): string => JSON.stringify(a))).toEqual({
    a: '1',
    b: '"two"',
    c: 'true',
    d: undefined,
    e: 'null',
    f: '{"field":"value"}',
    g: '[1,2,3]'
});
Previous@angular-ru/cdk/arrayNext@angular-ru/cdk/regexp

Last updated