Gist 97d75332d2b298eab79a8849008bce9c

100%

Gist 97d75332d2b298eab79a8849008bce9c

✓ Published0🌍 Public

Last edited Oct 24, 2017

Created on Oct 24, 2017

This example demonstrates how a closure in JavaScript can capture a mutable variable, causing a seemingly pure function to change behavior over time. The code defines `fn1`, which returns an object with `get` and `set` methods that share access to the parameter `a`. Initially, `get()` returns the string `"hello"`, but after calling `set()`, the same `get()` returns `"Good bye!"`, and the outer variable `a` is also updated. The visualization shows this state change through console output, using plain JavaScript without external libraries.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 3745f53a79313afd139b4eb0a4e97bd2

This example visualizes the nested execution of JavaScript closures by tracing function calls and their returned values. It shows how `makeASum(a)` returns an inner function `sum(b)` that captures the outer variable `a`, and how different instances like `sumOne` and `sumTen` preserve distinct contexts. The rendering uses a custom SVG-based trace, likely driven by D3’s `d3.forceSimulation` for layout and `d3.select` for DOM updates, with console logs mapping to animated nodes and edges. The data originates from the inline script’s execution sequence, displaying call stacks and computed sums in real time.

MMistyBlunch

67% match

Loading thumbnail…

Gist 5ef57ecbfb116e6b42706fb6a30b0987

This example demonstrates a common JavaScript scoping pitfall with the `var` keyword, contrasting it with `let`. It shows that declaring multiple variables in a single statement like `var i, r = 0;` only initializes the last variable (`r`), leaving `i` as `undefined`. Consequently, while loops testing `i < 10` never execute, while loops on `r` run ten times, printing "chau". The visualization, presented as a code gist, uses plain JavaScript console output via `console.log` within `while` loops, relying on the browser's or Node.js runtime rather than any external libraries. The gist highlights the importance of explicit initialization for each variable.

MMistyBlunch

64% match

Loading thumbnail…

Gist 23733

This example visualizes the distinction between local variables, instance variables, and block scoping in Ruby through a sequence of short code snippets. It shows how assignment semantics affect values across method calls and blocks, culminating in a Numeric class monkey-patch. The visualization likely renders each snippet as annotated code blocks with output values, using a custom layout or a library like D3.js to arrange the snippets and highlight variable bindings. The data originates from the gist’s source code, presented without external datasets, focusing on the logic of variable scope rather than numerical or spatial data.

DDylanFM

61% 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

61% match

Loading thumbnail…

Gist 89193bd17e57c1339fdc4888b072d7ed

This example visualizes the caching behavior of a JavaScript `memoize` function. It shows how repeated calls with the same argument return a cached result, while new arguments trigger a fresh computation and expand the internal cache object. The code implements the memoization pattern manually, using a plain object as a cache and the spread operator to merge new entries. It does not rely on external libraries or rendering APIs; the visualization likely depicts the function’s execution flow and cache state changes, though the specific display mechanism is not defined in the provided source. The data originates from the `memoize.js` file, demonstrating the logic in isolation.

RRestuta

61% match

Loading thumbnail…

Gist 54292

This example demonstrates how Ruby’s `instance_variable_set` and `instance_variable_get` can dynamically alter and read an instance variable defined on a class, using a module-scoped `@foo` that starts as `"bar"` and is changed to `"changed"` via a nested class method. The code defines a `What` module containing `@foo` and a `Whatever` class whose `change_foo` method mutates that variable, then prints its initial and updated values using `p`. The output, shown as comments (`# >> "bar"` and `# >> "changed"`), confirms the state change. No external libraries or rendering APIs are used; the example relies solely on Ruby’s core object model and metaprogramming features.

DDylanFM

60% match

Loading thumbnail…

Gist e8ba8b98cbdee1807cd1

This example creates a simple test function that logs "test" to the console. It defines `testFun()` and immediately invokes it, demonstrating basic JavaScript function declaration and execution. The visualization relies on standard JavaScript syntax rather than external libraries or data sources, showing a minimal code execution pattern with console output.

OOrkish

60% match

Loading thumbnail…

[Power Query] [m] Closures

This example visualizes the inner workings of a TypeScript-based function-closure mechanism, showing how parameter lists are programmatically overwritten and restricted. It demonstrates the step-by-step process of copying a function (`fnCopy`) and applying `setParameters` to limit its arguments to a specific range, then wrapping that operation with another `setParameters` call to further constrain the allowed parameter indices to 1–9. The code uses TypeScript’s type system and higher-order functions (like `setParameters`) to manipulate closures at runtime. The rendering approach is textual, highlighting the sequential logic through code snippets, with no graphical or data-driven output beyond the functional transformation.

HHugoberry

60% match