data-structures

Master JavaScript objects and arrays including manipulation methods, prototypal inheritance, and complex data structure patterns.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

This Claude skill serves as a comprehensive technical reference for mastering JavaScript data structures, specifically focusing on advanced object and array manipulation. It provides production-grade patterns for immutable updates, deep cloning, and efficient data transformation using modern ES6+ syntax. By offering quick-reference cheat sheets and troubleshooting guides, it helps developers write cleaner, more performant, and bug-free JavaScript code.

Use Cases

  • Data Transformation: Efficiently converting complex API responses into UI-ready formats using declarative methods like .reduce(), .flatMap(), and Object.fromEntries().
  • State Management: Implementing safe, immutable state updates in frameworks like React or Redux using spread operators and non-mutating array patterns to prevent side-effect bugs.
  • Performance Optimization: Utilizing Sets for unique value extraction and object indexing for O(1) search complexity in large datasets.
  • Code Modernization: Refactoring legacy JavaScript to utilize modern features such as optional chaining (?.), nullish coalescing (??), and structuredClone() for robust data handling.
namedata-structures
descriptionMaster JavaScript objects and arrays including manipulation methods, prototypal inheritance, and complex data structure patterns.
sasmp_version"1.3.0"
bonded_agent03-objects-arrays
bond_typePRIMARY_BOND
skill_typereference
response_formatcode_first
max_tokens1500
required[topic]
optional[method_type]
on_ambiguityask_clarification
fallbackshow_method_list
entry_log"Data structures skill activated"
exit_log"Data structures reference provided"

Data Structures Skill

Quick Reference Card

Object Operations

// Create
const obj = { name: 'Alice', age: 30 };

// Access
obj.name;           // Dot notation
obj['name'];        // Bracket notation
obj?.address?.city; // Optional chaining

// Modify
obj.email = 'a@b.com';       // Add/update
delete obj.age;              // Remove
const { name, ...rest } = obj; // Destructure

Object Methods

Object.keys(obj);       // ['name', 'age']
Object.values(obj);     // ['Alice', 30]
Object.entries(obj);    // [['name','Alice'], ['age',30]]
Object.fromEntries(entries);  // Reverse

Object.assign({}, a, b);  // Shallow merge
{ ...a, ...b };           // Spread merge (preferred)

Object.freeze(obj);       // Immutable
Object.seal(obj);         // No add/delete

Array Methods Cheat Sheet

Transform (new array)

arr.map(x => x * 2);         // Transform each
arr.filter(x => x > 0);      // Keep matches
arr.slice(1, 3);             // Extract portion
arr.flat(2);                 // Flatten nested
arr.flatMap(x => [x, x*2]);  // Map + flatten

Search

arr.find(x => x > 5);        // First match
arr.findIndex(x => x > 5);   // First index
arr.findLast(x => x > 5);    // Last match (ES2023)
arr.includes(5);             // Boolean check
arr.indexOf(5);              // Index or -1

Reduce

arr.reduce((acc, x) => acc + x, 0);  // Sum
arr.reduce((acc, x) => ({ ...acc, [x.id]: x }), {});  // Index by

Check

arr.every(x => x > 0);       // All pass
arr.some(x => x > 0);        // Any pass

Mutate (modify original)

arr.push(x);     // Add end
arr.pop();       // Remove end
arr.unshift(x);  // Add start
arr.shift();     // Remove start
arr.splice(i, n, ...items);  // Remove/insert
arr.sort((a,b) => a - b);    // Sort
arr.reverse();   // Reverse

Destructuring

// Object
const { name, age = 0 } = user;
const { name: userName } = user;  // Rename
const { address: { city } } = user;  // Nested

// Array
const [first, , third] = arr;  // Skip
const [head, ...tail] = arr;   // Rest
[a, b] = [b, a];               // Swap

Data Transformation Patterns

// Group by
const byRole = users.reduce((acc, u) => {
  (acc[u.role] ??= []).push(u);
  return acc;
}, {});

// Unique values
const unique = [...new Set(arr)];

// Index by ID
const byId = arr.reduce((acc, x) => ({ ...acc, [x.id]: x }), {});

Troubleshooting

Common Issues

Problem Symptom Fix
Shallow copy bug Nested changes shared Use structuredClone()
Mutation side effect Original changed Use spread/map
undefined access Property doesn't exist Use ?. optional chain
Sort not working Wrong order Provide compare function

Deep Clone

// Modern (preferred)
const deep = structuredClone(original);

// JSON (limited - no functions, dates)
const deep = JSON.parse(JSON.stringify(original));

Debug Checklist

// 1. Inspect structure
console.log(JSON.stringify(obj, null, 2));

// 2. Check array vs object
console.log(Array.isArray(value));

// 3. Check prototype
console.log(Object.getPrototypeOf(obj));

Production Patterns

Immutable Update

// Object
const updated = { ...user, name: 'New Name' };

// Array
const added = [...arr, newItem];
const removed = arr.filter(x => x.id !== id);
const updated = arr.map(x => x.id === id ? { ...x, ...changes } : x);

Safe Access

const city = user?.address?.city ?? 'Unknown';
const first = arr?.[0] ?? defaultValue;
  • Agent 03: Objects & Arrays (detailed learning)
  • Skill: fundamentals: Variables and types
  • Skill: modern-javascript: ES6+ features