Wondering what’s next for npm?Check out our public roadmap! »

    TypeScript icon, indicating that this package has built-in type declarations

    1.0.3 • Public • Published


    This microlibrary provides a deep copy of a given object or array.


    Install the library:

    npm install @ardentia/deep-copy

    Then, in the file where you want to use it:

    //ES6 / TypeScript
    import getItemCopy from '@ardentia/deep-copy';
    const copy = getItemCopy(<value>);
    const getItemCopy = require('@ardentia/deep-copy/node').default;
    const copy = getItemCopy(<value>);

    The library is built to be ES6-, TypeScript and node.js-compatible.


    The values of the given object are recursively traversed and are also deep copied in case they are not primitive types. If the value is a primitive type, a copy by value is returned.

    const myCustomObject = { 
      numberVal: 1,
      stringVal: 'string',
      arrayVal: [{ foo: 'bar' }, 1, 2, 3],
      objectVal: { foo: 'bar', innerArray: [1, 2, 3] }
    const objectCopy = getItemCopy(myCustomObject);
    console.log(Object.is(objectCopy, myCustomObject)); 
    //false -> deep copy of object
    console.log(Object.is(objectCopy.numberVal, myCustomObject.numberVal)); 
    //true -> primitive type copied by value
    console.log(Object.is(objectCopy.stringVal, myCustomObject.stringVal)); 
    //true -> primitive type copied by value
    console.log(Object.is(objectCopy.arrayVal, myCustomObject.arrayVal)); 
    //false -> deep copy of array
    console.log(Object.is(objectCopy.arrayVal[0], myCustomObject.arrayVal[0])); 
    //false -> deep copy of object
    console.log(Object.is(objectCopy.objectVal, myCustomObject.objectVal)); 
    //false -> deep copy of object
    console.log(Object.is(objectCopy.objectVal.innerArray, myCustomObject.objectVal.innerArray)); 
    //false -> deep copy of array

    Same deep copy logic applies to array members:

    const myCustomArray = [
      { foo: 'bar', innerArray: [1, 2, 3] },
      [{ foo: 'bar'}, 1, 2, 3]
    const arrayCopy = getItemCopy(myCustomArray);
    console.log(Object.is(arrayCopy, myCustomArray)); 
    //false -> deep copy of array
    console.log(Object.is(arrayCopy[0], myCustomArray[0]));
    //true -> primitive type copied by value
    console.log(Object.is(arrayCopy[1], myCustomArray[1]));
    //true -> primitive type copied by value
    console.log(Object.is(arrayCopy[2], myCustomArray[2]));
    //false -> deep copy of object
    console.log(Object.is(arrayCopy[2].innerArray, myCustomArray[2].innerArray));
    //false -> deep copy of array
    console.log(Object.is(arrayCopy[3], myCustomArray[3])); 
    //false -> deep copy of array
    console.log(Object.is(arrayCopy[3][0], myCustomArray[3][0])); 
    //false -> deep copy of object

    Note: If the object you are attempting to copy contains children that recursively reference their parent object, the call to getItemCopy(...) will cause a range error exception: Range Error: Maximum call stack size exceeded. If such an object structure is possible in your case, you need to place the call to getItemCopy(...) in a try-catch construction:

    import getItemCopy from '@ardentia/deep-copy';
    const rootObj = {
      childA: null,
      childB: null
    const childA = {
      a1: 'a1',
      a2: 'a2',
      root: rootObj
    rootObj.childA = childA;
    const childB = {
      b1: 'b1',
      b2: 'b2',
      root: rootObj
    try {
      const result = getItemCopy(rootObj);
    } catch(ex) {
      // handle the range error exception

    Local Development

    1. Fork the project and clone it locally
    2. npm install to install the library dependencies
    3. npm install -g typescript to install TypeScript globally
    4. npm test to run tests
    5. npm run build to build for production


    npm i @ardentia/deep-copy

    DownloadsWeekly Downloads






    Unpacked Size

    7.94 kB

    Total Files


    Last publish


    • avatar