Issue-2-DefaultWhenNotFound Issue #2 - Add optional third paramater to act as default if object is not truthy, key is not truthy, or full keypath does not exist on the object

Author: billneff79

README.md

@@ -1,15 +1,13 @@
 # `dlv(obj, keypath)` [![NPM](https://img.shields.io/npm/v/dlv.svg)](https://npmjs.com/package/dlv) [![Build](https://travis-ci.org/developit/dlv.svg?branch=master)](https://travis-ci.org/developit/dlv)
 
-> Safely get a dot-notated path within a nested object.
+> Safely get a dot-notated path within a nested object, with ability to return a default if the full key path does not exist
 
 ### Why?
 
-Smallest possible implementation: only **120 bytes.**
+Smallest possible implementation: only **165 bytes.**
 
 You could write this yourself, but then you'd have to write [tests].
 
-Implementation is ripped directly from [preact].
-
 Supports ES Modules, CommonJS and globals.
 
 ### Installation
@@ -19,22 +17,42 @@ Supports ES Modules, CommonJS and globals.
 
 ### Usage
 
+`delve(object, keypath, [default])`
+
 ```js
 import delve from 'dlv';
 
 let obj = {
 	a: {
 		b: {
 			c: 1
+			e: undefined
 		}
 	}
 };
 
+//use string dot notation for keys
 delve(obj, 'a.b.c') === 1;
 
+//or use an array key
+delve(obj, ['a', 'b', 'c']) === 1;
+
 delve(obj, 'a.b') === obj.a.b;
 
+//returns undefined if the full key path does not exist and no default is specified
 delve(obj, 'a.b.c.d') === undefined;
+
+//optional third parameter for default if the full key in path is missing
+delve(obj, 'a.b.c.d', 'foo') === 'foo';
+
+//default is only used if full keypath does not exist.
+//Non-truthy values are still returned if they exist at the full keypath
+delve(obj, 'a.b.c.e', 'foo') === undefined;
+
+//undefined obj or key returns undefined, unless a default is supplied
+delve(undefined, 'a.b.c') === undefined;
+delve(undefined, 'a.b.c', 'foo') === 'foo';
+delve(obj, undefined, 'foo') === 'foo';
 ```
 
 ### License

index.js

@@ -1,5 +1,7 @@
-export default function dlv(obj, key) {
+export default function dlv(obj, key, def) {
+	if(!obj || !key) return def;
 	if (key.split) key = key.split('.');
-	for (var i=0; i<key.length && obj; i++) obj = obj[key[i]];
-	return obj;
+	var i=0, keyLength=key.length;
+	for (; i<keyLength && obj.hasOwnProperty(key[i]); obj = obj[key[i++]]) ;
+	return i===keyLength ? obj : def;
 }

test.js

@@ -2,6 +2,8 @@ var assert = require('assert');
 var delve = require('.');
 
 var obj = {
+	undef: undefined,
+	zero: 0,
 	one: 1,
 	a: {
 		two: 2,
@@ -15,13 +17,17 @@ var obj = {
 };
 
 // assert equality of a given path, as dot notation and array.
-function check(path, value) {
-	assert.equal(delve(obj, path), value);
+//optional third argument is for default when object is not found
+function check(path, value, def) {
+
+	assert.equal(delve(obj, path, def), value);
 	console.log(' ✓ delve(obj, "'+path+'")');
 
-	var arr = path.split('.');
-	assert.equal(delve(obj, arr), value);
-	console.log(' ✓ delve(obj, '+JSON.stringify(arr)+')');
+	if(path) {
+		var arr = path.split('.');
+		assert.equal(delve(obj, arr, def), value);
+		console.log(' ✓ delve(obj, '+JSON.stringify(arr)+')');
+	}
 }
 
 check('', undefined);
@@ -34,5 +40,24 @@ check('a.b.three', obj.a.b.three);
 check('a.b.c', obj.a.b.c);
 check('a.b.c.four', obj.a.b.c.four);
 
+//test defaults
+check('', 'foo', 'foo');
+check('undef', undefined, 'foo');
+check('zero', 0, 'foo');
+check('a.badkey', 'foo', 'foo');
+check('a.badkey.anotherbadkey', 'foo', 'foo');
+
+//check undefined key doesn't throw errors and uses default
+check(undefined, undefined);
+check(undefined, 'foo', 'foo');
+
+//check undefined obj doesn't throw errors and uses default
+var backupObj = obj;
+obj = undefined;
+check('one', undefined);
+check('one', 'foo', 'foo');
+obj = backupObj;
+
+
 console.log('✅ Success!');
 process.exit(0);