Support array indexes

index.d.ts

@@ -4,7 +4,7 @@ declare const dotProp: {
 	/**
 	Get the value of the property at the given path.
 
-	@param object - Object to get the `path` value.
+	@param object - Object or array to get the `path` value.
 	@param path - Path of the property in the object, using `.` to separate each nested key. Use `\\.` if you have a `.` in the key.
 	@param defaultValue - Default value.
 
@@ -23,18 +23,21 @@ declare const dotProp: {
 
 	dotProp.get({foo: {'dot.dot': 'unicorn'}}, 'foo.dot\\.dot');
 	//=> 'unicorn'
+
+	dotProp.get({foo: [{bar: 'unicorn'}]}, 'foo[0].bar');
+	//=> 'unicorn'
 	```
 	*/
 	get: <ObjectType, PathType extends string, DefaultValue = undefined>(
 		object: ObjectType,
 		path: PathType,
 		defaultValue?: DefaultValue
-	) => ObjectType extends Record<string, unknown> ? (Get<ObjectType, PathType> extends unknown ? DefaultValue : Get<ObjectType, PathType>) : undefined; // TODO: When adding array index support (https://github.com/sindresorhus/dot-prop/issues/71) add ` | unknown[]` after `Record<string, unknown>`
+	) => ObjectType extends Record<string, unknown> | unknown[] ? (Get<ObjectType, PathType> extends unknown ? DefaultValue : Get<ObjectType, PathType>) : undefined;
 
 	/**
 	Set the property at the given path to the given value.
 
-	@param object - Object to set the `path` value.
+	@param object - Object or array to set the `path` value.
 	@param path - Path of the property in the object, using `.` to separate each nested key. Use `\\.` if you have a `.` in the key.
 	@param value - Value to set at `path`.
 	@returns The object.
@@ -55,6 +58,10 @@ declare const dotProp: {
 	dotProp.set(object, 'foo.baz', 'x');
 	console.log(object);
 	//=> {foo: {bar: 'b', baz: 'x'}}
+
+	dotProp.set(object, 'foo.biz.0', 'a');
+	console.log(object);
+	//=> {foo: {bar: 'b', baz: 'x', biz: ['a']}}
 	```
 	*/
 	set: <ObjectType extends {[key: string]: any}>(
@@ -66,7 +73,7 @@ declare const dotProp: {
 	/**
 	Check whether the property at the given path exists.
 
-	@param object - Object to test the `path` value.
+	@param object - Object or array to test the `path` value.
 	@param path - Path of the property in the object, using `.` to separate each nested key. Use `\\.` if you have a `.` in the key.
 
 	@example
@@ -82,7 +89,7 @@ declare const dotProp: {
 	/**
 	Delete the property at the given path.
 
-	@param object - Object to delete the `path` value.
+	@param object - Object or array to delete the `path` value.
 	@param path - Path of the property in the object, using `.` to separate each nested key. Use `\\.` if you have a `.` in the key.
 	@returns A boolean of whether the property existed before being deleted.
 

index.js

@@ -7,25 +7,138 @@ const disallowedKeys = new Set([
 	'constructor'
 ]);
 
-const isValidPath = pathSegments => !pathSegments.some(segment => disallowedKeys.has(segment));
-
 function getPathSegments(path) {
-	const pathArray = path.split('.');
 	const parts = [];
 
-	for (let i = 0; i < pathArray.length; i++) {
-		let p = pathArray[i];
+	let isIgnoring = false;
+	let isPath = true;
+	let isIndex = false;
+	let currentPathSegment = '';
+
+	for (const character of path) {
+		switch (character) {
+			case '\\':
+				if (isIgnoring) {
+					isIgnoring = false;
+					currentPathSegment += '\\';
+				}
+
+				isIgnoring = !isIgnoring;
+				break;
+
+			case '.':
+				if (isIgnoring) {
+					isIgnoring = false;
+					currentPathSegment += '.';
+					break;
+				}
+
+				if (isIndex) {
+					isIndex = false;
+					parts.push(`${parts.pop() || ''}[${currentPathSegment}`);
+					currentPathSegment = '';
+				}
+
+				if (isPath && currentPathSegment.length > 0) {
+					if (disallowedKeys.has(currentPathSegment)) {
+						return [];
+					}
+
+					parts.push(currentPathSegment);
+					currentPathSegment = '';
+				}
+
+				isPath = true;
+				break;
+
+			case '[':
+				if (isIgnoring) {
+					isIgnoring = false;
+					currentPathSegment += '[';
+					break;
+				}
+
+				if (isPath) {
+					if (currentPathSegment !== '' || parts.length === 0) {
+						isPath = false;
+						isIndex = true;
+
+						if (currentPathSegment.length > 0) {
+							if (disallowedKeys.has(currentPathSegment)) {
+								return [];
+							}
+
+							parts.push(currentPathSegment);
+							currentPathSegment = '';
+						}
+					} else {
+						currentPathSegment += '[';
+					}
+
+					break;
+				}
+
+				if (isIndex) {
+					isPath = true;
+					currentPathSegment = `${parts.pop() || ''}[${currentPathSegment}[`;
+				}
+
+				isIndex = !isIndex;
+				break;
+
+			case ']':
+				if (isIgnoring && isIndex) {
+					isIgnoring = false;
+					isIndex = false;
+					isPath = true;
+					currentPathSegment = `${parts.pop()}[${currentPathSegment}]`;
+					break;
+				}
+
+				if (isIndex) {
+					isIndex = false;
+					isPath = true;
+					const index = Number.parseInt(currentPathSegment, 10);
+					if (Number.isNaN(index)) {
+						if (disallowedKeys.has(currentPathSegment)) {
+							return [];
+						}
+
+						parts.push(currentPathSegment);
+					} else {
+						parts.push(index);
+					}
+
+					currentPathSegment = '';
+					break;
+				}
+
+				// Falls through
+
+			default:
+				if (isIgnoring) {
+					isIgnoring = false;
+					currentPathSegment += '\\';
+				}
 
-		while (p[p.length - 1] === '\\' && pathArray[i + 1] !== undefined) {
-			p = p.slice(0, -1) + '.';
-			p += pathArray[++i];
+				currentPathSegment += character;
 		}
+	}
 
-		parts.push(p);
+	if (isIndex) {
+		currentPathSegment = `${parts.pop()}[${currentPathSegment}`;
 	}
 
-	if (!isValidPath(parts)) {
-		return [];
+	if (isIgnoring) {
+		currentPathSegment += '\\';
+	}
+
+	if (currentPathSegment.length > 0 || parts.length === 0) {
+		if (disallowedKeys.has(currentPathSegment)) {
+			return [];
+		}
+
+		parts.push(currentPathSegment);
 	}
 
 	return parts;
@@ -43,12 +156,20 @@ module.exports = {
 		}
 
 		for (let i = 0; i < pathArray.length; i++) {
-			object = object[pathArray[i]];
+			const key = pathArray[i];
+			const index = Number.parseInt(key, 10);
+
+			// Disallow string indexes
+			if (!Number.isInteger(key) && Array.isArray(object) && !Number.isNaN(index) && object[index] === object[key]) {
+				object = i === pathArray.length - 1 ? undefined : null;
+			} else {
+				object = object[key];
+			}
 
 			if (object === undefined || object === null) {
 				// `object` is either `undefined` or `null` so we want to stop the loop, and
 				// if this is not the last bit of the path, and
-				// if it did't return `undefined`
+				// if it didn't return `undefined`
 				// it would return `null` if `object` is `null`
 				// but we want `get({foo: null}, 'foo.bar')` to equal `undefined`, or the supplied value, not `null`
 				if (i !== pathArray.length - 1) {
@@ -74,7 +195,11 @@ module.exports = {
 			const p = pathArray[i];
 
 			if (!isObject(object[p])) {
-				object[p] = {};
+				if (Number.isInteger(pathArray[i + 1])) {
+					object[p] = [];
+				} else {
+					object[p] = {};
+				}
 			}
 
 			if (i === pathArray.length - 1) {

readme.md

@@ -26,6 +26,9 @@ dotProp.get({foo: {bar: 'a'}}, 'foo.notDefined.deep', 'default value');
 dotProp.get({foo: {'dot.dot': 'unicorn'}}, 'foo.dot\\.dot');
 //=> 'unicorn'
 
+dotProp.get({foo: [{bar: 'unicorn'}]}, 'foo[0].bar');
+//=> 'unicorn'
+
 // Setter
 const object = {foo: {bar: 'a'}};
 dotProp.set(object, 'foo.bar', 'b');
@@ -40,6 +43,10 @@ dotProp.set(object, 'foo.baz', 'x');
 console.log(object);
 //=> {foo: {bar: 'b', baz: 'x'}}
 
+dotProp.set(object, 'foo.biz.0', 'a');
+console.log(object);
+//=> {foo: {bar: 'b', baz: 'x', biz: ['a']}}
+
 // Has
 dotProp.has({foo: {bar: 'unicorn'}}, 'foo.bar');
 //=> true
@@ -84,9 +91,9 @@ Returns a boolean of whether the property existed before being deleted.
 
 #### object
 
-Type: `object`
+Type: `object | array`
 
-Object to get, set, or delete the `path` value.
+Object or array to get, set, or delete the `path` value.
 
 You are allowed to pass in `undefined` as the object to the `get` and `has` functions.