# deepobject

> Simple functions that allow you to assign, or read, nested object values using simple dot notation

Latest version **0.4.1** (published 2018-04-18) · 0 weekly downloads

> **Deprecated.** This package is deprecated.

## Install

```sh
npm install deepobject
pnpm add deepobject
yarn add deepobject
bun add deepobject
```

## Health

**Score 10/100 (F)** — status: deprecated.

Negative: deprecated.

## Facts

| | |
|---|---|
| Version | 0.4.1 |
| Published | 2018-04-18 |
| First published | 2013-11-01 |
| Weekly downloads | 0 |
| TypeScript types | none |
| Module format | CommonJS |
| Node | ~8.x |
| Dependencies | 0 |
| Unpacked size | 42.5 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 0 |
| Author | Tony Mobily |
| Maintainers | mercmobily |
| Keywords | objects, nested, javascript |

## Links

- npm: https://www.npmjs.com/package/deepobject
- Repository: https://github.com/mercmobily/deepobject
- Homepage: https://github.com/mercmobily/deepobject#readme
- Issues: https://github.com/mercmobily/deepobject/issues
- npm.io page: https://npm.io/package/deepobject

## Recent versions

- 0.4.1 (latest) — 2018-04-18
- 0.4.0 — 2018-03-09
- 0.3.9 — 2016-04-15
- 0.3.8 — 2016-04-09
- 0.3.7 — 2016-03-12
- 0.3.6 — 2016-03-06
- 0.3.5 — 2015-03-12
- 0.3.4 — 2015-03-10
- 0.3.3 — 2014-01-13
- 0.3.2 — 2013-11-22
- 0.3.1 — 2013-11-22
- 0.3.0 — 2013-11-14
- 0.1.1 — 2013-11-01

## README

deepobject
==========

DeepObject is the path to coding heaven where you never have to do this again:


    if( typeof( obj ) === 'object' && object !== null ){
      if( typeof( obj.a ) === 'object' && object.a !== null ){
        if( typeof( obj.b ) === 'object' && object.b !== null ){
          if( typeof( obj.c ) === 'object' && object.c !== null ){
            return obj.a.b.c;
          } else {
            return null;
          }
        } else {
          return null;
        }
      } else {
        return null;
      }
    } else {
      return null;
    }


You write this instead:

    DO.get( obj, 'a.b.c.d', null );


Sounds good? read on.

## Using deepobject with a constructor

This is the best option for objects that you are likely to set once, and query multiple times.

To create a DO object, just run:

    var do = new DO( { a: 10, b: { c: 20, d: 30 } } );

You can then query it for different paths:

    do.get( 'a' ) => 10
    do.get( 'a.b' ) => { c: 20, d: 30 }
    do.get( 'a.b.c' ) => 20
    do.get( 'z', 'something' ) => 'something'

You can also reset the object:

    do.set( { a: 40, b: { c: 50, d: 60 } } );
    do.get( 'a' ) => 40

Finally, you can manipulate the object:

    do.set( 'a.b.d' , 70 ) => 70
    do.get( 'a.b' ) =>  { c: 50, d: 70 }
    do.get( 'a.b.d' ) =>  70

    do.set( 'a.z1.z2.z3', 110 ) => 110
    do.get( 'a.z1.z2.z3' ) => 110

You can manipulate an existing object:

    var o = { a: 10, b: { c: 20, d: 30 } };
    var do = new DO( o );
    do.set( 'a.b.c.d', 10 ) => 10
    do.set( 'a.b.e', 20 ) => 20
    console.log( o ) => { a: { b: { c: { d: 10 }, e: 20 } }, b: { c: 20, d: 30 } }

Can you imagine assigning an object like that by hand?

You can do all of these things without ever worrying about checking if what you are reading is undefined, or worrying about the fact that `null` is `typeof object` and yet will throw errors when you don't want it to.


## Using deepobject as a function on any object (get and set)

DeepObject offers a simple way to do one-time queries:

    var obj = { a: 10, b: { c: 20, d: 30 } };
    DO.get( obj, 'a.b.d' ) => 30
    DO.get( obj, 'a.b.e', 10000 ) => 10000
    DO.set( obj, 'a.b.c', 100 ) => 100

This is handy when you have existing objects are are running one-time queries against it.

---
_Source: https://npm.io/package/deepobject · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._