Path Operations

/**
 * Get value at the specified path
 * @param {Array} path - Array of property keys representing the path
 * @returns {*} Value at the path, or undefined if path doesn't exist
 */
traverse(obj).get(path)

// Functional version
traverse.get(obj, path)

const traverse = require('traverse');

const obj = { 
    a: { 
        b: [1, 2, { c: 'hello' }] 
    } 
};

// Get nested values
const value1 = traverse(obj).get(['a', 'b', 2, 'c']); // 'hello'
const value2 = traverse(obj).get(['a', 'b', 0]);      // 1
const value3 = traverse(obj).get(['a', 'b']);         // [1, 2, { c: 'hello' }]
const value4 = traverse(obj).get(['nonexistent']);    // undefined

// Empty path returns the root object
const root = traverse(obj).get([]);                   // obj

// Functional approach
const value = traverse.get(obj, ['a', 'b', 2, 'c']); // 'hello'

/**
 * Set value at the specified path, creating intermediate objects as needed
 * @param {Array} path - Array of property keys representing the path
 * @param {*} value - Value to set at the path
 * @returns {*} The value that was set
 */
traverse(obj).set(path, value)

// Functional version
traverse.set(obj, path, value)

const traverse = require('traverse');

const obj = { a: { b: 1 } };

// Set existing path
traverse(obj).set(['a', 'b'], 42);
// obj is now: { a: { b: 42 } }

// Create new nested path
traverse(obj).set(['a', 'c', 'd'], 'hello');
// obj is now: { a: { b: 42, c: { d: 'hello' } } }

// Set array index
const arr = { items: [1, 2, 3] };
traverse(arr).set(['items', 1], 'modified');
// arr is now: { items: [1, 'modified', 3] }

// Functional approach
traverse.set(obj, ['x', 'y', 'z'], 'deep value');

/**
 * Check if the specified path exists in the object
 * @param {Array} path - Array of property keys representing the path
 * @returns {boolean} True if path exists, false otherwise
 */
traverse(obj).has(path)

// Functional version
traverse.has(obj, path)

const traverse = require('traverse');

const obj = { 
    a: { 
        b: [1, 2, { c: null }] 
    } 
};

// Check existing paths
traverse(obj).has(['a']);                    // true
traverse(obj).has(['a', 'b']);               // true  
traverse(obj).has(['a', 'b', 2, 'c']);      // true (even though value is null)
traverse(obj).has(['a', 'b', 0]);           // true

// Check non-existent paths
traverse(obj).has(['a', 'b', 'nonexistent']); // false
traverse(obj).has(['x']);                     // false
traverse(obj).has(['a', 'b', 5]);            // false (array index out of bounds)

// Empty path
traverse(obj).has([]);                        // true (root always exists)

// Functional approach
const exists = traverse.has(obj, ['a', 'b', 2, 'c']); // true

// String keys for object properties
['property', 'nested', 'key']

// Number keys for array indices  
['items', 0, 'name']

// Mixed keys for complex structures
['users', 1, 'addresses', 0, 'street']

// Symbol keys (when includeSymbols: true)
const sym = Symbol('key');
[sym, 'property']

const sym = Symbol('hidden');
const obj = { 
    normal: 'value',
    [sym]: { data: 'secret' }
};

// Default behavior - symbols ignored
traverse(obj).has([sym]); // false

// With symbol support
traverse(obj, { includeSymbols: true }).has([sym]); // true
traverse(obj, { includeSymbols: true }).get([sym, 'data']); // 'secret'