String.js

  1. /**
  2.  * @namespace String
  3.  */
  5. /**
  6.  * Calculate edit distance between string a and b
  7.  *
  8.  * @memberof String
  9.  * @see {@link https://en.wikipedia.org/wiki/Edit_distance|Article on Wikipedia}
  10.  * @param {string} a A
  11.  * @param {string} b B
  12.  * @returns {number} Distance
  13.  */
  14. function editDistance(a, b) {
  15.   let matrix = [], i, j;
  17.   if(a.length === 0) { return b.length; }
  18.   if(b.length === 0) { return a.length; }
  19.   if(a === b) { return 0; }
  21.   // increment along the first column of each row
  22.   for(i = 0; i <= b.length; i++) {
  23.     matrix[i] = [i];
  24.   }
  26.   // increment each column in the first row
  27.   for(j = 0; j <= a.length; j++){
  28.     matrix[0][j] = j;
  29.   }
  31.   // Fill in the rest of the matrix
  32.   for(i = 1; i <= b.length; i++){
  33.     for(j = 1; j <= a.length; j++){
  34.       if(b.charAt(i-1) === a.charAt(j-1)){
  35.         matrix[i][j] = matrix[i-1][j-1];
  36.       } else {
  37.         matrix[i][j] = Math.min(matrix[i-1][j-1] + 1, // substitution
  38.           Math.min(matrix[i][j-1] + 1, // insertion
  39.             matrix[i-1][j] + 1)); // deletion
  40.       }
  41.     }
  42.   }
  44.   return matrix[b.length][a.length];
  45. }
  47. /**
  48.  * Get similarity ratio based on edit distance
  49.  *
  50.  * @memberof String
  51.  * @see {@link String.editDistance}
  52.  * @param {string} a A
  53.  * @param {string} b B
  54.  * @returns {number} Ratio
  55.  */
  56. function getSimilarity(a, b) {
  57.   const l = Math.max(a.length, b.length);
  58.   return (l - String.editDistance(a, b)) / l;
  59. }
  61. /**
  62.  * Checks is given value is String and is empty
  63.  *
  64.  * @memberof String
  65.  * @param {string} sth Something to check
  66.  * @returns {boolean} Verdict
  67.  */
  68. function isEmpty (sth) {
  69.   return typeof sth === 'string' && sth.length === 0;
  70. }
  72. /**
  73.  * Checks is given value is String and is not empty
  74.  *
  75.  * @memberof String
  76.  * @param {string} sth Something to check
  77.  * @returns {boolean} Verdict
  78.  */
  79. function isNotEmpty (sth) {
  80.   return typeof sth === 'string' && sth.length > 0;
  81. }
  83. /**
  84.  * Checks is given value isn't a String, or it is empty
  85.  *
  86.  * @memberof String
  87.  * @param {string} sth Something to check
  88.  * @returns {boolean} Verdict
  89.  */
  90. function isInvalidOrEmpty (sth) {
  91.   return typeof sth !== 'string' || sth.length === 0;
  92. }
  94. /**
  95.  * Returns string with capitalised first letter
  96.  *
  97.  * @memberof String.prototype
  98.  * @param {boolean} [lower=false] Flag if it should lower all letters first
  99.  * @returns {string} New string
  100.  */
  101. function capitaliseFirstLetter(lower) {
  102.   let value = this.valueOf();
  104.   if(lower) {
  105.     value = value.toLowerCase();
  106.   }
  108.   return value.replace(/[a-z]/i, function(m) { return m.toUpperCase(); });
  109. }
  111. /**
  112.  * Returns string with lower first letter
  113.  *
  114.  * @memberof String.prototype
  115.  * @returns {string} New string
  116.  */
  117. function lowerFirstLetter() {
  118.   return this.valueOf().replace(/[a-z]/i, function(m) { return m.toLowerCase(); });
  119. }
  121. /**
  122.  * Returns string with removed cases
  123.  *
  124.  * @memberof String.prototype
  125.  * @returns {string} New string
  126.  */
  127. function noCase() {
  128.   let value = this.valueOf();
  130.   // detect capitalized snake case
  131.   if(/^[A-Z0-9_]+$/.test(value)) {
  132.     return value.replace(/_/g, ' ').toLowerCase();
  133.   }
  135.   // clean kebab and snake case
  136.   value = value.replace(/[-_]/g, ' ');
  138.   // clean special characters
  139.   value = value.replace(/[^a-z0-9 ]/gi, '');
  141.   // clean pascal case
  142.   value = value.lowerFirstLetter();
  144.   // clean camel case
  145.   value = value.replace(/([A-Za-z])([0-9])/g, function(m, m1, m2) { return m1 + ' ' + m2; });
  146.   value = value.replace(/[A-Z][a-z]/g, function(m) { return ' ' + m.toLowerCase(); });
  147.   value = value.replace(/([a-z0-9])([A-Z])/g, function(m, m1, m2) { return m1 + ' ' + m2; });
  149.   // minimize white spaces
  150.   value = value.trim().replace(/\s{2,}/g, ' ');
  152.   return value;
  153. }
  155. /**
  156.  * Returns string in camelCase
  157.  *
  158.  * @memberof String.prototype
  159.  * @returns {string} String in camelCase
  160.  */
  161. function toCamelCase() {
  162.   let value = this.valueOf();
  164.   // normalize
  165.   value = value.noCase();
  167.   // replace
  168.   value = value.replace(/ [a-z0-9]/gi, function(m) { return m[1].toUpperCase(); });
  170.   return value;
  171. }
  173. /**
  174.  * Returns string in PascalCase
  175.  *
  176.  * @memberof String.prototype
  177.  * @returns {string} String in PascalCase
  178.  */
  179. function toPascalCase() {
  180.   return this.toCamelCase().capitaliseFirstLetter(false);
  181. }
  183. /**
  184.  * Returns string in kebab-case
  185.  *
  186.  * @memberof String.prototype
  187.  * @returns {string} String in kebab-case
  188.  */
  189. function toKebabCase() {
  190.   let value = this.valueOf();
  192.   // normalize
  193.   value = value.noCase();
  195.   // replace
  196.   value = value.replace(/\s/g, '-');
  198.   return value;
  199. }
  201. /**
  202.  * Returns string in snake_case
  203.  *
  204.  * @memberof String.prototype
  205.  * @param {boolean} [convertToUpperCase=false] Set this flag to convert to UpperCase
  206.  * @returns {string} String in snake_case
  207.  */
  208. function toSnakeCase(convertToUpperCase) {
  210.   const toUpperCase = convertToUpperCase || false;
  212.   let value = this.valueOf();
  214.   // normalize
  215.   value = value.noCase();
  217.   // replace
  218.   value = value.replace(/\s/g, '_');
  220.   if(toUpperCase) return value.toUpperCase();
  222.   return value;
  223. }
  225. /**
  226.  * Returns checksum crc32
  227.  *
  228.  * @memberof String.prototype
  229.  * @author joelpt
  230.  * @author schnaader
  231.  * @see {@link https://stackoverflow.com/a/3276730 | Stack Overflow Answer}
  232.  * @returns {string} Checksum
  233.  */
  234. function toChecksum() {
  235.   let value, i, chk;
  237.   value = this.valueOf();
  238.   chk = 0x12345678;
  240.   for (i = 0; i < value.length; i++) {
  241.     chk += value.charCodeAt(i) * (i + 1);
  242.   }
  244.   return chk;
  245. }
  247. /**
  248.  * Returns string in boolean
  249.  *
  250.  * @memberof String.prototype
  251.  * @returns {boolean} True if string looks somehow like 'true'
  252.  */
  253. function toBoolean() {
  254.   return this.valueOf().toLowerCase() === 'true';
  255. }
  257. /**
  258.  * Returns reversed string
  259.  *
  260.  * @memberof String.prototype
  261.  * @returns {string} Reversed string
  262.  */
  263. function reverse() {
  264.   return this.valueOf().split('').reverse().join('');
  265. }
  267. /**
  268.  * Check if string is like given query (you can use regexp notation)
  269.  *
  270.  * @memberof String.prototype
  271.  * @param {string} query Query
  272.  * @returns {boolean} Verdict
  273.  */
  274. function isLike(query) {
  275.   return new RegExp('^' + query + '$').test(this.valueOf());
  276. }
  278. /**
  279.  * Polyfill for ECMAScript 2015 for String.prototype.includes
  280.  *
  281.  * @memberof String.prototype
  282.  * @param {string} search Search for
  283.  * @param {number} [start=0] Searching start position
  284.  * @returns {boolean} Verdict
  285.  */
  286. function includes(search, start) {
  287.   const _start = typeof start !== 'number' ? 0 : start;
  289.   if (_start + search.length > this.length) {
  290.     return false;
  291.   }
  293.   return this.indexOf(search, _start) !== -1;
  294. }
  297. export default {
  298.   static: {
  299.     editDistance,
  300.     getSimilarity,
  301.     isEmpty,
  302.     isNotEmpty,
  303.     isInvalidOrEmpty
  304.   },
  306.   method: {
  307.     capitaliseFirstLetter,
  308.     lowerFirstLetter,
  309.     noCase,
  310.     toCamelCase,
  311.     toPascalCase,
  312.     toKebabCase,
  313.     toSnakeCase,
  314.     toChecksum,
  315.     toBoolean,
  316.     reverse,
  317.     isLike,
  318.     includes
  319.   }
  320. };