Base64 encode N times

100%

Base64 encode N times

✓ Published0🌍 Public

Last edited Feb 8, 2018

Created on Feb 8, 2018

This example visualizes the process of repeatedly encoding a text string using Base64 sixteen times. The code defines a text variable and uses the `encode` function, which pipes data through the `utf8.encode` and `base64.encode` functions from the `utf8` and `base-64` libraries, respectively. It then constructs `encodeN` by applying the `encode` function repeatedly using Ramda’s `R.pipe` and `R.times`. The program logs the final encoded output for the input 'hello', demonstrating how iterative encoding transforms the original string.

AI-generated description

Similar vizzes

Loading thumbnail…

Base64.js

This example demonstrates a compact implementation of Base64 encoding in JavaScript, showing how binary data can be converted into a six-bit character representation using the standard Base64 alphabet. The code defines a function, `encode`, that iterates over the input string’s character codes and constructs the output by bit-shifting values and selecting characters from a lookup string. It uses standard JavaScript string methods like `charCodeAt` and `charAt` alongside bitwise operators, with no external libraries or visualization components involved. The example serves as a clear, minimal demonstration of encoding logic rather than a data-driven graphic.

Mmbostock

68% match

Loading thumbnail…

Ramda Title Case

This example demonstrates how to build a text-transformation pipeline using the Ramda functional library, converting a plain string into title case. The visualization shows the step-by-step composition of small, reusable functions, starting with splitting the input on spaces. The code defines a `capitalize` function using `R.converge` to concatenate an uppercased first character with the remaining tail, and then composes a `toTitleCase` function with `R.compose`, `R.join`, and `R.map`. The entire transformation is expressed through pure function composition rather than imperative loops.

66ewis

50% match

Loading thumbnail…

Huffman Encoding Ruby Implementation

This example visualizes the Huffman encoding algorithm as implemented in Ruby, using the source text "MISSISSIPPI_RIVER" as its input data. It shows how character frequencies are tallied and then assembled into a binary tree via a priority-queue-like process, with each node’s value representing a combined count. The code’s `Node` and `CountObject` classes build the tree, while the `collect_binary_values` method recursively assigns binary codes by traversing left (0) and right (1). The final output prints the character-to-code mapping and the encoded binary string, but does not use any external visualization libraries—the display is purely textual, relying on console output for both the tree construction steps and the resulting code table.

AAndrelton

50% match

Loading thumbnail…

binary-param

This example interactively demonstrates binary-to-Base64 encoding through a row of 500 checkboxes, where each checkbox represents a single bit. Toggling any checkbox updates the displayed binary string, its Base64 encoding, and the decoded binary output. The implementation uses D3.js selections and event handlers to manage the checkboxes, while custom JavaScript functions perform the conversion between binary arrays and a custom Base64 alphabet string.

11wheel

49% match

Loading thumbnail…

fussing with UTF-16 surrogate encoding in Javascript

This example demonstrates how JavaScript encodes Unicode code points above U+FFFF into UTF-16 surrogate pairs, using functions like `escapeUTF16` and `makeSurrogate` to convert a code point such as U+1F339 (a rose emoji) into the escaped `\ud83c\udf39` sequence. The code implements the surrogate math from the Wikipedia UTF-16 specification, applying bitwise shifts and masking to derive lead and trail surrogates for supplementary planes. It then verifies the result by parsing the escaped string with `JSON.parse` and comparing it to the literal surrogate pair. The source is a standalone gist with no external libraries or data visualization dependencies.

RRandomEtc

49% match

Loading thumbnail…

square I

Each nucleotide in the sequence is rendered as a column of four black-bordered squares, one per DNA base, whose fill opacity encodes its relative frequency at that position. The visualization highlights compositional patterns across the sequence, with darker squares indicating more abundant bases. Built with React components and D3’s `csv` loader, the data comes from a remote `nucleon.csv` file. The SVG rendering is handled through custom `Nucleon`, `Nucleotide`, and `Square` components, each drawing a fixed-size `rect` with an opacity value derived from the base’s proportion.

FFloweringDeathStar

47% match

Loading thumbnail…

Extra escapey JSON encoding for node.js

This example demonstrates how to encode JavaScript objects into JSON strings with extra escaping for safety and compatibility. The code defines a function, `escapedStringify`, which wraps the native `JSON.stringify` to apply three additional transformations: escaping forward slashes as `\/`, converting angle brackets to uppercase Unicode escape sequences, and converting all characters in the `\u007f` to `\uffff` range into lowercase hex escapes. The implementation uses the `JSON` stringify API and regular expressions with callback functions to perform the character replacements. The example’s data source is the Gist’s own JSON test input, and the rendering approach is purely textual output.

RRandomEtc

47% match

Loading thumbnail…

Gist 6ca203fa1eab16a0f3c98d442ba9eea0

This example demonstrates a JavaScript function that transforms an input string into a "mumbling" pattern, where each character is repeated incrementally, capitalized at the start, and joined by hyphens. The visualization shows the result of applying this logic to sample strings like "abcd," "cwAt," and "RqaEzty" using the built-in `split`, `toLowerCase`, `toUpperCase`, `slice`, `map`, and `join` methods, along with custom `capitalize` and `accum` functions. The code relies on plain JavaScript string array manipulation without external libraries, producing outputs such as "A-Bb-Ccc-Dddd" for the first example.

MMistyBlunch

47% match