Escape a given map of special characters

npm install string-escape-map

//const stringEscape = require ('string-escape-map') // v.1.x.x — CommonJS

import stringEscape from 'string-escape-map'         // v.2.x.x — ES6 module

// initialization
const MY_ESC = new stringEscape ([
  ['\t', '\\t'],
  ['\n', '\\n'],
  [ "'", "''"],
])

// possible later adjustment
MY_ESC.set ('\r', '')

// run time usage
const unsafeString = `Don't
you?`

const safeString = MY_ESC.escape (unsafeString)

The class provided by string-escape-map is derived from Map and shares its constructor argument format: if set, it must be an iterable of key-value pairs.

Additional restrictions on input are same as for the set method (see below).

The standard set method is overloaded to effectively store char codes to safe substring mapping. So:

• key and value must be (primitive) strings;
• key must be a single character string.

Under the hood, the key parameter is subject to charCodeAt.

Other than registering a map entry, it sets escape1 or escapeN as this.escape method.

This method executes the module's main task: replaces all the characters in question with their safe representations

const safeString = MY_ESC.escape (unsafeString)

unsafeString must be a primitive string.

null, undefined etc. values cause errors.

Zero length strings are allowed.

A primitive string with all occurrences of each character previously set replaced with corresponding substrings.

This method is used as escape in case when more than one entry is set in this map. It scans through unsafeString, detect unsafe chars with charCodeAt and concatenates the result from safe slices glued with replacement strings from this Map.

This method is used as escape when only one unsafe character is known, so this works as replaceAll. The unsafeString is scanned with indexOf, the result is assembled from the slices detected.

No replace nor replaceAll method is used.

No regular expression is constructed.

The given string is scanned with charCodeAt (which is significantly faster and more memory efficient than charAt).

If no unsafe character is ever found, the argument is passed through untouched, without creating any temporary object at all.

Otherwise, the resulting string is created by concatenating complete safe slices with replacement substrings for unsafe chars.