Skip to main content
100%

Gist from mistakes.io

✓ Published0🌍 Public
Aapburnes
Last edited Feb 21, 2014
Created on Feb 21, 2014

This example demonstrates how to extend a plain JavaScript object with properties and methods from another object using a custom `extend` function. It shows the result of merging an `obj1` object—containing a `name`, a `value`, and a `multiply` method—into an empty `data` object, then invoking the merged method to compute a calculated return value. The code relies on native JavaScript array methods (`Array.prototype.slice`, `forEach`) and object property assignment, with no external libraries or rendering APIs. The visualization is purely computational, displaying the numeric output of the method call.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist from mistakes.io

This example demonstrates a small JavaScript utility that extends an object with custom methods using a custom `extend` function. It defines an `L` object with a `fn` method returning the string “coolio,” and an `L.Util.extend` method that copies properties from arguments into a target object. The code then creates a `coolio` object with `cool` and `age` methods, and invokes `L.fn()`, `coolio.cool()`, and `coolio.age(1985)` to test the results. It uses plain JavaScript object manipulation rather than any visualization library or rendering API.

Aapburnes
77% match
Loading thumbnail…

Gist 58ea1113852500390cf7cb5f0bd2d88c

This example demonstrates two JavaScript methods for converting between JavaScript objects and JSON format. It uses the native `JSON.parse()` function to transform a JSON string into an object, then accesses its properties to display "John, 30" via `document.getElementById().innerHTML`. A second example uses `JSON.stringify()` to convert a JavaScript array of names into a JSON string for output. The code relies on standard JavaScript APIs and renders results directly into HTML elements, illustrating basic data serialization without external libraries.

MMistyBlunch
65% match
Loading thumbnail…

Gist ed016e61300636e5a809

This example presents a JavaScript quiz that tests understanding of type coercion, string concatenation, and array manipulation. The visualization shows a series of code samples with their expected return values and written explanations, demonstrating behaviors like `typeof` returning "number" for `NaN`, string concatenation with numbers, and the effects of `pop()`, `push()`, `unshift()`, `join()`, and `split()`. The data is a static Gist containing plain text code questions and answers, rendered as a linear educational reference. No external libraries or frameworks are used; it relies purely on the raw text structure of the gist.

RRyan-321
60% match
Loading thumbnail…

An approach to deep cloning objects in JavaScript

This example shows a recursive approach to deep cloning plain JavaScript objects, where each nested object is duplicated rather than shared by reference. The code defines a `cloneDeep` function that iterates over an object’s own enumerable properties using `Object.entries`, checks whether each value is an object with `typeof value === 'object'`, and if so, calls itself recursively; otherwise, it assigns the primitive value directly. The visualization likely demonstrates this process step by step, perhaps animating the traversal of a sample object tree. However, the code explicitly notes it does not support arrays, converting them into object-like structures with numeric keys, as seen in the comment about `['foo', 'bar']` becoming `{0: 'foo', 1: 'bar'}`. No external libraries are used—only native JavaScript methods and operators.

115Dkatz
59% match
Loading thumbnail…

Gist 4b6eacbdba8bf3b35fea

This example demonstrates how to flatten nested JavaScript objects into a single-level key-value structure. The code defines a `flatten` function that recursively traverses each object property, building new keys by concatenating parent keys with child keys using a dot separator. It checks whether a value is an instance of `Object` to determine whether to recurse further or store the final value in the result object. The visualization gallery displays the function’s logic and its recursive traversal pattern, though no external libraries or rendering APIs are used in the provided code.

YYonet
59% match
Loading thumbnail…

objects and arrays

This example demonstrates how to combine two arrays of objects by matching a common property and then logs the results to the console. It also shows how to find and print the intersection of two simple arrays. The code uses plain JavaScript with `forEach` loops to compare object fields (`name` against `state`) and array elements, assigning a new `id` property to the first array. No D3 visualization is rendered; the example focuses purely on data manipulation and console output.

Aannalabrozzi
59% match
Loading thumbnail…

Sample problems: objects and arrays

This example presents five JavaScript practice problems focused on manipulating objects and arrays, with output intended for the browser’s developer console rather than SVG or other visual rendering. The code demonstrates basic data operations such as merging object properties by matching names, finding common elements between arrays using nested loops and the `includes` method, sorting an array of state objects by population, and using a loop with the modulus operator to filter numbers. It relies on vanilla JavaScript for most tasks and uses the D3 v4 library’s `d3.range` function to generate a sequence of integers from 1 to 10.

CCraftbd
59% match
Loading thumbnail…

Using the equivalent of php trait

This example demonstrates how to apply PHP-like traits to JavaScript objects using a custom `addMixin` function. It shows a flexible method for copying property descriptors from multiple source objects onto a target object, enabling code reuse without traditional inheritance. The function leverages `Object.keys`, `Object.getOwnPropertyDescriptor`, and `Object.defineProperties` to transfer both regular and enumerable symbol-based properties. The implementation is adapted from Caleb Porzio’s approach, and the mixin.js file contains the complete logic for this composition pattern.

NNaoray
58% match