Skip to main content
100%

Some handy string functions written in TypeScript

✓ Published0🌍 Public
Aabonello
Last edited Apr 20, 2021
Created on Dec 30, 2021

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.

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
62% match
Loading thumbnail…

Title Case in JS

The example demonstrates a straightforward text-transformation utility that converts any given string to Title Case, capitalizing the first letter of each word while lowercasing the remaining characters. It operates on a single string input and returns the formatted result. The code relies on the native JavaScript `String.replace()` method with a regular expression (`/\w\S*/g`) to match word boundaries, and applies a callback function that uses `charAt()`, `toUpperCase()`, and `substr()` to restructure each word. No external libraries or frameworks are involved, and the function is self-contained, making it a reusable snippet for formatting labels or headings in web applications.

Aabehmiel
60% match
Loading thumbnail…

A set of pure and immutable ES2015 functions aimed to make functional JavaScript more idiomatic.

This example presents a collection of pure, immutable ES2015 utility functions for idiomatic functional JavaScript. It includes array operations such as `combine`, `compact`, `difference`, and `intersection`, object helpers like `merge` and `toMap`, math functions (`min`, `max`, `sum`, `product`), and function decorators including `curry`, `once`, `maybe`, and `pipeline`. The code relies on native JavaScript features like `Array.prototype.includes`, `Set`, `Map`, `Object.assign`, and spread syntax. No external libraries or data sources are used; the gist demonstrates standalone, reusable functional patterns.

JJaxonDvl
59% match
Loading thumbnail…

Normalizer

This example demonstrates a string normalization function that converts accented and special characters into plain ASCII equivalents. It builds a character mapping from two parallel strings, then processes each input character, replacing matches with their mapped counterparts and lowercasing the final result. The implementation relies on standard JavaScript string methods such as `charAt`, `hasOwnProperty`, `join`, and `toLowerCase`. The code is presented as a standalone JavaScript function, with no external libraries or data sources involved, showing the raw logic behind text sanitization in a compact form.

LLuisSevillano
59% match
Loading thumbnail…

Gist 70922fede9732c9cfa48f5d5a4025d40

This example demonstrates a simple JavaScript routine that removes all spaces from each of three strings in a loop, printing the cleaned result alongside its index. The code defines a utility object with a method that splits a string on spaces, filters out empty entries, and concatenates the remaining characters. It uses no external libraries, relying only on native JavaScript string and array methods, such as `split` and a `for` loop, to process the data. The output is logged to the console, showing the transformation for each iteration.

MMistyBlunch
57% 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
57% 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
56% 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
55% match