Gist d41b2d287647d1e9686cd28b744df4fb

100%

Gist d41b2d287647d1e9686cd28b744df4fb

✓ Published0🌍 Public

Last edited Jan 14, 2020

Created on Jan 14, 2020

This example shows a TypeScript class that defines a user entity with a computed full name property. It demonstrates how the `formatName` helper function is imported and used to combine first and last names into a single formatted string. The `User` class exposes a getter that calls `formatName` with the hardcoded values "John" and "Doe". The code relies on TypeScript's class syntax and module import system, specifically the `~/utils/helpers/format-name` path alias to access the utility function.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist b1e70db6d1c2d4fad7ea1782731c749d

This example demonstrates a simple utility function that formats a person's name by combining a first and last name with a space. It shows how to use TypeScript's type annotations and template literal syntax to create a readable, reusable function. The code defines `formatName`, which takes two string parameters and returns a single formatted string using the `${}` template literal syntax. It is a straightforward illustration of basic string manipulation and function export in a TypeScript module, suitable for use in web applications or Node.js projects.

TTipTopCoder

76% match

Loading thumbnail…

Gist 4b6077fe737b33df1934b8eb4bc57c79

This example demonstrates the behavior of getters in a TypeScript class, showing how a getter can return a function that logs a user’s name to the console. It defines a `User` class with private `name` and `email` fields, and a `speak` getter returns an inner function that accesses the instance’s name. The code uses TypeScript’s class syntax and type annotations, and the sample instantiates a `User`, calls `speak()`, and attempts to override the getter on the prototype, which throws a `TypeError`. The illustration focuses on prototypal getter semantics in a scripting context.

PPeleke

69% match

Loading thumbnail…

Gist 7d6a7404e99051bb7d2f36c61f0113ae

This example demonstrates functional programming techniques in JavaScript, including currying, composition, and generator functions. It shows how currying enables partial application, as seen with the `sum` function and reusable helpers like `getName` and `mapUserNames`. The code uses `compose` with `reduceRight` to chain array transformations, filtering user names by length. It also illustrates generator behavior with `next(true)` to control iteration completion. The data is a hardcoded array of user objects, and output is logged to the console via `console.log`.

IIliaIdakiev

57% match

Loading thumbnail…

Gist 73a21b3937f99b5d45f0

This example demonstrates a simple class definition in C#. A single class, `A`, contains a string field named `name`, with no constructors, methods, or inheritance shown. The visualization uses no external libraries or rendering APIs, presenting the code structure directly as plain text. The data source is the Gist file `test.cs`, and the rendering approach is limited to displaying the raw source code without any graphical or interactive elements.

LLastSamurai03

52% match

Loading thumbnail…

inheritance-0.js

The example demonstrates JavaScript prototype-based inheritance through a `Person` constructor function, where `getInfoCard` is defined on `Person.prototype` and returns a formatted name-and-age string. It shows how a `Student` constructor inherits this method, allowing an instance created with `new Student('John', 18, 'MIT')` to call it successfully. It also highlights a common pitfall: invoking `Student` without `new` assigns properties to the global object and causes `getInfoCard` to fail, since the returned value is not an object with that method. No external libraries are used; the code relies solely on core JavaScript constructors, `prototype`, and `instanceof` checks (commented out).

Aalessioalex

52% match

Loading thumbnail…

Gist 362622e653494c155e16a41bd222e099

This example shows a single user card for a character named Sam, displaying a portrait image from the file frodo.png. The HTML structure consists of a div containing a user title and an image, with the code referencing a force simulation for potential layout calculations. It uses basic HTML and CSS class assignments, though no JavaScript libraries are imported in the visible markup, and the rendering relies on static image embedding rather than dynamic data visualization.

115Dkatz

52% match

Loading thumbnail…

Some handy string functions written in TypeScript

This example demonstrates a set of pure TypeScript string-manipulation functions that convert between naming conventions such as snake_case, kebab-case, camelCase, and PascalCase. It shows how regular expressions and string methods like `replace`, `match`, `map`, and `join` transform input text. The code defines exported functions `toSpaces`, `toSnakeCase`, `toKebabCase`, `toCamelCase`, and `toPascalCase`, each with documented example inputs and outputs. No external libraries are used; the logic relies solely on native JavaScript string APIs and TypeScript type annotations.

Aabonello

51% match

Loading thumbnail…

ModelJS Example

This example demonstrates reactive data binding with the Model.js library, showing how a full name updates automatically as users type into first and last name input fields. The page contains a simple HTML form where two text inputs feed values into a model instance, and a `model.when` listener combines the firstName and lastName properties into a fullName string. The full name is then rendered into a span element and logged to the console using D3.js selection and text methods. The example illustrates how Model.js tracks property dependencies and triggers callbacks asynchronously.

CCurran Kelleher

51% match