| // Copyright 2006 The Closure Library Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS-IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| /** |
| * @fileoverview Utilities for string manipulation. |
| */ |
| |
| |
| /** |
| * Namespace for string utilities |
| */ |
| goog.provide('goog.string'); |
| goog.provide('goog.string.Unicode'); |
| |
| |
| /** |
| * Common Unicode string characters. |
| * @enum {string} |
| */ |
| goog.string.Unicode = { |
| NBSP: '\xa0' |
| }; |
| |
| |
| /** |
| * Fast prefix-checker. |
| * @param {string} str The string to check. |
| * @param {string} prefix A string to look for at the start of {@code str}. |
| * @return {boolean} True if {@code str} begins with {@code prefix}. |
| */ |
| goog.string.startsWith = function(str, prefix) { |
| return str.lastIndexOf(prefix, 0) == 0; |
| }; |
| |
| |
| /** |
| * Fast suffix-checker. |
| * @param {string} str The string to check. |
| * @param {string} suffix A string to look for at the end of {@code str}. |
| * @return {boolean} True if {@code str} ends with {@code suffix}. |
| */ |
| goog.string.endsWith = function(str, suffix) { |
| var l = str.length - suffix.length; |
| return l >= 0 && str.indexOf(suffix, l) == l; |
| }; |
| |
| |
| /** |
| * Case-insensitive prefix-checker. |
| * @param {string} str The string to check. |
| * @param {string} prefix A string to look for at the end of {@code str}. |
| * @return {boolean} True if {@code str} begins with {@code prefix} (ignoring |
| * case). |
| */ |
| goog.string.caseInsensitiveStartsWith = function(str, prefix) { |
| return goog.string.caseInsensitiveCompare( |
| prefix, str.substr(0, prefix.length)) == 0; |
| }; |
| |
| |
| /** |
| * Case-insensitive suffix-checker. |
| * @param {string} str The string to check. |
| * @param {string} suffix A string to look for at the end of {@code str}. |
| * @return {boolean} True if {@code str} ends with {@code suffix} (ignoring |
| * case). |
| */ |
| goog.string.caseInsensitiveEndsWith = function(str, suffix) { |
| return goog.string.caseInsensitiveCompare( |
| suffix, str.substr(str.length - suffix.length, suffix.length)) == 0; |
| }; |
| |
| |
| /** |
| * Does simple python-style string substitution. |
| * subs("foo%s hot%s", "bar", "dog") becomes "foobar hotdog". |
| * @param {string} str The string containing the pattern. |
| * @param {...*} var_args The items to substitute into the pattern. |
| * @return {string} A copy of {@code str} in which each occurrence of |
| * {@code %s} has been replaced an argument from {@code var_args}. |
| */ |
| goog.string.subs = function(str, var_args) { |
| // This appears to be slow, but testing shows it compares more or less |
| // equivalent to the regex.exec method. |
| for (var i = 1; i < arguments.length; i++) { |
| // We cast to String in case an argument is a Function. Replacing $&, for |
| // example, with $$$& stops the replace from subsituting the whole match |
| // into the resultant string. $$$& in the first replace becomes $$& in the |
| // second, which leaves $& in the resultant string. Also: |
| // $$, $`, $', $n $nn |
| var replacement = String(arguments[i]).replace(/\$/g, '$$$$'); |
| str = str.replace(/\%s/, replacement); |
| } |
| return str; |
| }; |
| |
| |
| /** |
| * Converts multiple whitespace chars (spaces, non-breaking-spaces, new lines |
| * and tabs) to a single space, and strips leading and trailing whitespace. |
| * @param {string} str Input string. |
| * @return {string} A copy of {@code str} with collapsed whitespace. |
| */ |
| goog.string.collapseWhitespace = function(str) { |
| // Since IE doesn't include non-breaking-space (0xa0) in their \s character |
| // class (as required by section 7.2 of the ECMAScript spec), we explicitly |
| // include it in the regexp to enforce consistent cross-browser behavior. |
| return str.replace(/[\s\xa0]+/g, ' ').replace(/^\s+|\s+$/g, ''); |
| }; |
| |
| |
| /** |
| * Checks if a string is empty or contains only whitespaces. |
| * @param {string} str The string to check. |
| * @return {boolean} True if {@code str} is empty or whitespace only. |
| */ |
| goog.string.isEmpty = function(str) { |
| // testing length == 0 first is actually slower in all browsers (about the |
| // same in Opera). |
| // Since IE doesn't include non-breaking-space (0xa0) in their \s character |
| // class (as required by section 7.2 of the ECMAScript spec), we explicitly |
| // include it in the regexp to enforce consistent cross-browser behavior. |
| return /^[\s\xa0]*$/.test(str); |
| }; |
| |
| |
| /** |
| * Checks if a string is null, empty or contains only whitespaces. |
| * @param {*} str The string to check. |
| * @return {boolean} True if{@code str} is null, empty, or whitespace only. |
| */ |
| goog.string.isEmptySafe = function(str) { |
| return goog.string.isEmpty(goog.string.makeSafe(str)); |
| }; |
| |
| |
| /** |
| * Checks if a string is all breaking whitespace. |
| * @param {string} str The string to check. |
| * @return {boolean} Whether the string is all breaking whitespace. |
| */ |
| goog.string.isBreakingWhitespace = function(str) { |
| return !/[^\t\n\r ]/.test(str); |
| }; |
| |
| |
| /** |
| * Checks if a string contains all letters. |
| * @param {string} str string to check. |
| * @return {boolean} True if {@code str} consists entirely of letters. |
| */ |
| goog.string.isAlpha = function(str) { |
| return !/[^a-zA-Z]/.test(str); |
| }; |
| |
| |
| /** |
| * Checks if a string contains only numbers. |
| * @param {*} str string to check. If not a string, it will be |
| * casted to one. |
| * @return {boolean} True if {@code str} is numeric. |
| */ |
| goog.string.isNumeric = function(str) { |
| return !/[^0-9]/.test(str); |
| }; |
| |
| |
| /** |
| * Checks if a string contains only numbers or letters. |
| * @param {string} str string to check. |
| * @return {boolean} True if {@code str} is alphanumeric. |
| */ |
| goog.string.isAlphaNumeric = function(str) { |
| return !/[^a-zA-Z0-9]/.test(str); |
| }; |
| |
| |
| /** |
| * Checks if a character is a space character. |
| * @param {string} ch Character to check. |
| * @return {boolean} True if {code ch} is a space. |
| */ |
| goog.string.isSpace = function(ch) { |
| return ch == ' '; |
| }; |
| |
| |
| /** |
| * Checks if a character is a valid unicode character. |
| * @param {string} ch Character to check. |
| * @return {boolean} True if {code ch} is a valid unicode character. |
| */ |
| goog.string.isUnicodeChar = function(ch) { |
| return ch.length == 1 && ch >= ' ' && ch <= '~' || |
| ch >= '\u0080' && ch <= '\uFFFD'; |
| }; |
| |
| |
| /** |
| * Takes a string and replaces newlines with a space. Multiple lines are |
| * replaced with a single space. |
| * @param {string} str The string from which to strip newlines. |
| * @return {string} A copy of {@code str} stripped of newlines. |
| */ |
| goog.string.stripNewlines = function(str) { |
| return str.replace(/(\r\n|\r|\n)+/g, ' '); |
| }; |
| |
| |
| /** |
| * Replaces Windows and Mac new lines with unix style: \r or \r\n with \n. |
| * @param {string} str The string to in which to canonicalize newlines. |
| * @return {string} {@code str} A copy of {@code} with canonicalized newlines. |
| */ |
| goog.string.canonicalizeNewlines = function(str) { |
| return str.replace(/(\r\n|\r|\n)/g, '\n'); |
| }; |
| |
| |
| /** |
| * Normalizes whitespace in a string, replacing all whitespace chars with |
| * a space. |
| * @param {string} str The string in which to normalize whitespace. |
| * @return {string} A copy of {@code str} with all whitespace normalized. |
| */ |
| goog.string.normalizeWhitespace = function(str) { |
| return str.replace(/\xa0|\s/g, ' '); |
| }; |
| |
| |
| /** |
| * Normalizes spaces in a string, replacing all consecutive spaces and tabs |
| * with a single space. Replaces non-breaking space with a space. |
| * @param {string} str The string in which to normalize spaces. |
| * @return {string} A copy of {@code str} with all consecutive spaces and tabs |
| * replaced with a single space. |
| */ |
| goog.string.normalizeSpaces = function(str) { |
| return str.replace(/\xa0|[ \t]+/g, ' '); |
| }; |
| |
| |
| /** |
| * Removes the breaking spaces from the left and right of the string and |
| * collapses the sequences of breaking spaces in the middle into single spaces. |
| * The original and the result strings render the same way in HTML. |
| * @param {string} str A string in which to collapse spaces. |
| * @return {string} Copy of the string with normalized breaking spaces. |
| */ |
| goog.string.collapseBreakingSpaces = function(str) { |
| return str.replace(/[\t\r\n ]+/g, ' ').replace( |
| /^[\t\r\n ]+|[\t\r\n ]+$/g, ''); |
| }; |
| |
| |
| /** |
| * Trims white spaces to the left and right of a string. |
| * @param {string} str The string to trim. |
| * @return {string} A trimmed copy of {@code str}. |
| */ |
| goog.string.trim = function(str) { |
| // Since IE doesn't include non-breaking-space (0xa0) in their \s character |
| // class (as required by section 7.2 of the ECMAScript spec), we explicitly |
| // include it in the regexp to enforce consistent cross-browser behavior. |
| return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, ''); |
| }; |
| |
| |
| /** |
| * Trims whitespaces at the left end of a string. |
| * @param {string} str The string to left trim. |
| * @return {string} A trimmed copy of {@code str}. |
| */ |
| goog.string.trimLeft = function(str) { |
| // Since IE doesn't include non-breaking-space (0xa0) in their \s character |
| // class (as required by section 7.2 of the ECMAScript spec), we explicitly |
| // include it in the regexp to enforce consistent cross-browser behavior. |
| return str.replace(/^[\s\xa0]+/, ''); |
| }; |
| |
| |
| /** |
| * Trims whitespaces at the right end of a string. |
| * @param {string} str The string to right trim. |
| * @return {string} A trimmed copy of {@code str}. |
| */ |
| goog.string.trimRight = function(str) { |
| // Since IE doesn't include non-breaking-space (0xa0) in their \s character |
| // class (as required by section 7.2 of the ECMAScript spec), we explicitly |
| // include it in the regexp to enforce consistent cross-browser behavior. |
| return str.replace(/[\s\xa0]+$/, ''); |
| }; |
| |
| |
| /** |
| * A string comparator that ignores case. |
| * -1 = str1 less than str2 |
| * 0 = str1 equals str2 |
| * 1 = str1 greater than str2 |
| * |
| * @param {string} str1 The string to compare. |
| * @param {string} str2 The string to compare {@code str1} to. |
| * @return {number} The comparator result, as described above. |
| */ |
| goog.string.caseInsensitiveCompare = function(str1, str2) { |
| var test1 = String(str1).toLowerCase(); |
| var test2 = String(str2).toLowerCase(); |
| |
| if (test1 < test2) { |
| return -1; |
| } else if (test1 == test2) { |
| return 0; |
| } else { |
| return 1; |
| } |
| }; |
| |
| |
| /** |
| * Regular expression used for splitting a string into substrings of fractional |
| * numbers, integers, and non-numeric characters. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.string.numerateCompareRegExp_ = /(\.\d+)|(\d+)|(\D+)/g; |
| |
| |
| /** |
| * String comparison function that handles numbers in a way humans might expect. |
| * Using this function, the string "File 2.jpg" sorts before "File 10.jpg". The |
| * comparison is mostly case-insensitive, though strings that are identical |
| * except for case are sorted with the upper-case strings before lower-case. |
| * |
| * This comparison function is significantly slower (about 500x) than either |
| * the default or the case-insensitive compare. It should not be used in |
| * time-critical code, but should be fast enough to sort several hundred short |
| * strings (like filenames) with a reasonable delay. |
| * |
| * @param {string} str1 The string to compare in a numerically sensitive way. |
| * @param {string} str2 The string to compare {@code str1} to. |
| * @return {number} less than 0 if str1 < str2, 0 if str1 == str2, greater than |
| * 0 if str1 > str2. |
| */ |
| goog.string.numerateCompare = function(str1, str2) { |
| if (str1 == str2) { |
| return 0; |
| } |
| if (!str1) { |
| return -1; |
| } |
| if (!str2) { |
| return 1; |
| } |
| |
| // Using match to split the entire string ahead of time turns out to be faster |
| // for most inputs than using RegExp.exec or iterating over each character. |
| var tokens1 = str1.toLowerCase().match(goog.string.numerateCompareRegExp_); |
| var tokens2 = str2.toLowerCase().match(goog.string.numerateCompareRegExp_); |
| |
| var count = Math.min(tokens1.length, tokens2.length); |
| |
| for (var i = 0; i < count; i++) { |
| var a = tokens1[i]; |
| var b = tokens2[i]; |
| |
| // Compare pairs of tokens, returning if one token sorts before the other. |
| if (a != b) { |
| |
| // Only if both tokens are integers is a special comparison required. |
| // Decimal numbers are sorted as strings (e.g., '.09' < '.1'). |
| var num1 = parseInt(a, 10); |
| if (!isNaN(num1)) { |
| var num2 = parseInt(b, 10); |
| if (!isNaN(num2) && num1 - num2) { |
| return num1 - num2; |
| } |
| } |
| return a < b ? -1 : 1; |
| } |
| } |
| |
| // If one string is a substring of the other, the shorter string sorts first. |
| if (tokens1.length != tokens2.length) { |
| return tokens1.length - tokens2.length; |
| } |
| |
| // The two strings must be equivalent except for case (perfect equality is |
| // tested at the head of the function.) Revert to default ASCII-betical string |
| // comparison to stablize the sort. |
| return str1 < str2 ? -1 : 1; |
| }; |
| |
| |
| /** |
| * Regular expression used for determining if a string needs to be encoded. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.string.encodeUriRegExp_ = /^[a-zA-Z0-9\-_.!~*'()]*$/; |
| |
| |
| /** |
| * URL-encodes a string |
| * @param {*} str The string to url-encode. |
| * @return {string} An encoded copy of {@code str} that is safe for urls. |
| * Note that '#', ':', and other characters used to delimit portions |
| * of URLs *will* be encoded. |
| */ |
| goog.string.urlEncode = function(str) { |
| str = String(str); |
| // Checking if the search matches before calling encodeURIComponent avoids an |
| // extra allocation in IE6. This adds about 10us time in FF and a similiar |
| // over head in IE6 for lower working set apps, but for large working set |
| // apps like Gmail, it saves about 70us per call. |
| if (!goog.string.encodeUriRegExp_.test(str)) { |
| return encodeURIComponent(str); |
| } |
| return str; |
| }; |
| |
| |
| /** |
| * URL-decodes the string. We need to specially handle '+'s because |
| * the javascript library doesn't convert them to spaces. |
| * @param {string} str The string to url decode. |
| * @return {string} The decoded {@code str}. |
| */ |
| goog.string.urlDecode = function(str) { |
| return decodeURIComponent(str.replace(/\+/g, ' ')); |
| }; |
| |
| |
| /** |
| * Converts \n to <br>s or <br />s. |
| * @param {string} str The string in which to convert newlines. |
| * @param {boolean=} opt_xml Whether to use XML compatible tags. |
| * @return {string} A copy of {@code str} with converted newlines. |
| */ |
| goog.string.newLineToBr = function(str, opt_xml) { |
| return str.replace(/(\r\n|\r|\n)/g, opt_xml ? '<br />' : '<br>'); |
| }; |
| |
| |
| /** |
| * Escape double quote '"' characters in addition to '&', '<', and '>' so that a |
| * string can be included in an HTML tag attribute value within double quotes. |
| * |
| * It should be noted that > doesn't need to be escaped for the HTML or XML to |
| * be valid, but it has been decided to escape it for consistency with other |
| * implementations. |
| * |
| * NOTE(user): |
| * HtmlEscape is often called during the generation of large blocks of HTML. |
| * Using statics for the regular expressions and strings is an optimization |
| * that can more than half the amount of time IE spends in this function for |
| * large apps, since strings and regexes both contribute to GC allocations. |
| * |
| * Testing for the presence of a character before escaping increases the number |
| * of function calls, but actually provides a speed increase for the average |
| * case -- since the average case often doesn't require the escaping of all 4 |
| * characters and indexOf() is much cheaper than replace(). |
| * The worst case does suffer slightly from the additional calls, therefore the |
| * opt_isLikelyToContainHtmlChars option has been included for situations |
| * where all 4 HTML entities are very likely to be present and need escaping. |
| * |
| * Some benchmarks (times tended to fluctuate +-0.05ms): |
| * FireFox IE6 |
| * (no chars / average (mix of cases) / all 4 chars) |
| * no checks 0.13 / 0.22 / 0.22 0.23 / 0.53 / 0.80 |
| * indexOf 0.08 / 0.17 / 0.26 0.22 / 0.54 / 0.84 |
| * indexOf + re test 0.07 / 0.17 / 0.28 0.19 / 0.50 / 0.85 |
| * |
| * An additional advantage of checking if replace actually needs to be called |
| * is a reduction in the number of object allocations, so as the size of the |
| * application grows the difference between the various methods would increase. |
| * |
| * @param {string} str string to be escaped. |
| * @param {boolean=} opt_isLikelyToContainHtmlChars Don't perform a check to see |
| * if the character needs replacing - use this option if you expect each of |
| * the characters to appear often. Leave false if you expect few html |
| * characters to occur in your strings, such as if you are escaping HTML. |
| * @return {string} An escaped copy of {@code str}. |
| */ |
| goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) { |
| |
| if (opt_isLikelyToContainHtmlChars) { |
| return str.replace(goog.string.amperRe_, '&') |
| .replace(goog.string.ltRe_, '<') |
| .replace(goog.string.gtRe_, '>') |
| .replace(goog.string.quotRe_, '"'); |
| |
| } else { |
| // quick test helps in the case when there are no chars to replace, in |
| // worst case this makes barely a difference to the time taken |
| if (!goog.string.allRe_.test(str)) return str; |
| |
| // str.indexOf is faster than regex.test in this case |
| if (str.indexOf('&') != -1) { |
| str = str.replace(goog.string.amperRe_, '&'); |
| } |
| if (str.indexOf('<') != -1) { |
| str = str.replace(goog.string.ltRe_, '<'); |
| } |
| if (str.indexOf('>') != -1) { |
| str = str.replace(goog.string.gtRe_, '>'); |
| } |
| if (str.indexOf('"') != -1) { |
| str = str.replace(goog.string.quotRe_, '"'); |
| } |
| return str; |
| } |
| }; |
| |
| |
| /** |
| * Regular expression that matches an ampersand, for use in escaping. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.string.amperRe_ = /&/g; |
| |
| |
| /** |
| * Regular expression that matches a less than sign, for use in escaping. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.string.ltRe_ = /</g; |
| |
| |
| /** |
| * Regular expression that matches a greater than sign, for use in escaping. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.string.gtRe_ = />/g; |
| |
| |
| /** |
| * Regular expression that matches a double quote, for use in escaping. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.string.quotRe_ = /\"/g; |
| |
| |
| /** |
| * Regular expression that matches any character that needs to be escaped. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.string.allRe_ = /[&<>\"]/; |
| |
| |
| /** |
| * Unescapes an HTML string. |
| * |
| * @param {string} str The string to unescape. |
| * @return {string} An unescaped copy of {@code str}. |
| */ |
| goog.string.unescapeEntities = function(str) { |
| if (goog.string.contains(str, '&')) { |
| // We are careful not to use a DOM if we do not have one. We use the [] |
| // notation so that the JSCompiler will not complain about these objects and |
| // fields in the case where we have no DOM. |
| if ('document' in goog.global) { |
| return goog.string.unescapeEntitiesUsingDom_(str); |
| } else { |
| // Fall back on pure XML entities |
| return goog.string.unescapePureXmlEntities_(str); |
| } |
| } |
| return str; |
| }; |
| |
| |
| /** |
| * Unescapes an HTML string using a DOM to resolve non-XML, non-numeric |
| * entities. This function is XSS-safe and whitespace-preserving. |
| * @private |
| * @param {string} str The string to unescape. |
| * @return {string} The unescaped {@code str} string. |
| */ |
| goog.string.unescapeEntitiesUsingDom_ = function(str) { |
| var seen = {'&': '&', '<': '<', '>': '>', '"': '"'}; |
| var div = document.createElement('div'); |
| // Match as many valid entity characters as possible. If the actual entity |
| // happens to be shorter, it will still work as innerHTML will return the |
| // trailing characters unchanged. Since the entity characters do not include |
| // open angle bracket, there is no chance of XSS from the innerHTML use. |
| // Since no whitespace is passed to innerHTML, whitespace is preserved. |
| return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) { |
| // Check for cached entity. |
| var value = seen[s]; |
| if (value) { |
| return value; |
| } |
| // Check for numeric entity. |
| if (entity.charAt(0) == '#') { |
| // Prefix with 0 so that hex entities (e.g. ) parse as hex numbers. |
| var n = Number('0' + entity.substr(1)); |
| if (!isNaN(n)) { |
| value = String.fromCharCode(n); |
| } |
| } |
| // Fall back to innerHTML otherwise. |
| if (!value) { |
| // Append a non-entity character to avoid a bug in Webkit that parses |
| // an invalid entity at the end of innerHTML text as the empty string. |
| div.innerHTML = s + ' '; |
| // Then remove the trailing character from the result. |
| value = div.firstChild.nodeValue.slice(0, -1); |
| } |
| // Cache and return. |
| return seen[s] = value; |
| }); |
| }; |
| |
| |
| /** |
| * Unescapes XML entities. |
| * @private |
| * @param {string} str The string to unescape. |
| * @return {string} An unescaped copy of {@code str}. |
| */ |
| goog.string.unescapePureXmlEntities_ = function(str) { |
| return str.replace(/&([^;]+);/g, function(s, entity) { |
| switch (entity) { |
| case 'amp': |
| return '&'; |
| case 'lt': |
| return '<'; |
| case 'gt': |
| return '>'; |
| case 'quot': |
| return '"'; |
| default: |
| if (entity.charAt(0) == '#') { |
| // Prefix with 0 so that hex entities (e.g. ) parse as hex. |
| var n = Number('0' + entity.substr(1)); |
| if (!isNaN(n)) { |
| return String.fromCharCode(n); |
| } |
| } |
| // For invalid entities we just return the entity |
| return s; |
| } |
| }); |
| }; |
| |
| |
| /** |
| * Regular expression that matches an HTML entity. |
| * See also HTML5: Tokenization / Tokenizing character references. |
| * @private |
| * @type {!RegExp} |
| */ |
| goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g; |
| |
| |
| /** |
| * Do escaping of whitespace to preserve spatial formatting. We use character |
| * entity #160 to make it safer for xml. |
| * @param {string} str The string in which to escape whitespace. |
| * @param {boolean=} opt_xml Whether to use XML compatible tags. |
| * @return {string} An escaped copy of {@code str}. |
| */ |
| goog.string.whitespaceEscape = function(str, opt_xml) { |
| return goog.string.newLineToBr(str.replace(/ /g, '  '), opt_xml); |
| }; |
| |
| |
| /** |
| * Strip quote characters around a string. The second argument is a string of |
| * characters to treat as quotes. This can be a single character or a string of |
| * multiple character and in that case each of those are treated as possible |
| * quote characters. For example: |
| * |
| * <pre> |
| * goog.string.stripQuotes('"abc"', '"`') --> 'abc' |
| * goog.string.stripQuotes('`abc`', '"`') --> 'abc' |
| * </pre> |
| * |
| * @param {string} str The string to strip. |
| * @param {string} quoteChars The quote characters to strip. |
| * @return {string} A copy of {@code str} without the quotes. |
| */ |
| goog.string.stripQuotes = function(str, quoteChars) { |
| var length = quoteChars.length; |
| for (var i = 0; i < length; i++) { |
| var quoteChar = length == 1 ? quoteChars : quoteChars.charAt(i); |
| if (str.charAt(0) == quoteChar && str.charAt(str.length - 1) == quoteChar) { |
| return str.substring(1, str.length - 1); |
| } |
| } |
| return str; |
| }; |
| |
| |
| /** |
| * Truncates a string to a certain length and adds '...' if necessary. The |
| * length also accounts for the ellipsis, so a maximum length of 10 and a string |
| * 'Hello World!' produces 'Hello W...'. |
| * @param {string} str The string to truncate. |
| * @param {number} chars Max number of characters. |
| * @param {boolean=} opt_protectEscapedCharacters Whether to protect escaped |
| * characters from being cut off in the middle. |
| * @return {string} The truncated {@code str} string. |
| */ |
| goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) { |
| if (opt_protectEscapedCharacters) { |
| str = goog.string.unescapeEntities(str); |
| } |
| |
| if (str.length > chars) { |
| str = str.substring(0, chars - 3) + '...'; |
| } |
| |
| if (opt_protectEscapedCharacters) { |
| str = goog.string.htmlEscape(str); |
| } |
| |
| return str; |
| }; |
| |
| |
| /** |
| * Truncate a string in the middle, adding "..." if necessary, |
| * and favoring the beginning of the string. |
| * @param {string} str The string to truncate the middle of. |
| * @param {number} chars Max number of characters. |
| * @param {boolean=} opt_protectEscapedCharacters Whether to protect escaped |
| * characters from being cutoff in the middle. |
| * @param {number=} opt_trailingChars Optional number of trailing characters to |
| * leave at the end of the string, instead of truncating as close to the |
| * middle as possible. |
| * @return {string} A truncated copy of {@code str}. |
| */ |
| goog.string.truncateMiddle = function(str, chars, |
| opt_protectEscapedCharacters, opt_trailingChars) { |
| if (opt_protectEscapedCharacters) { |
| str = goog.string.unescapeEntities(str); |
| } |
| |
| if (opt_trailingChars && str.length > chars) { |
| if (opt_trailingChars > chars) { |
| opt_trailingChars = chars; |
| } |
| var endPoint = str.length - opt_trailingChars; |
| var startPoint = chars - opt_trailingChars; |
| str = str.substring(0, startPoint) + '...' + str.substring(endPoint); |
| } else if (str.length > chars) { |
| // Favor the beginning of the string: |
| var half = Math.floor(chars / 2); |
| var endPos = str.length - half; |
| half += chars % 2; |
| str = str.substring(0, half) + '...' + str.substring(endPos); |
| } |
| |
| if (opt_protectEscapedCharacters) { |
| str = goog.string.htmlEscape(str); |
| } |
| |
| return str; |
| }; |
| |
| |
| /** |
| * Special chars that need to be escaped for goog.string.quote. |
| * @private |
| * @type {Object} |
| */ |
| goog.string.specialEscapeChars_ = { |
| '\0': '\\0', |
| '\b': '\\b', |
| '\f': '\\f', |
| '\n': '\\n', |
| '\r': '\\r', |
| '\t': '\\t', |
| '\x0B': '\\x0B', // '\v' is not supported in JScript |
| '"': '\\"', |
| '\\': '\\\\' |
| }; |
| |
| |
| /** |
| * Character mappings used internally for goog.string.escapeChar. |
| * @private |
| * @type {Object} |
| */ |
| goog.string.jsEscapeCache_ = { |
| '\'': '\\\'' |
| }; |
| |
| |
| /** |
| * Encloses a string in double quotes and escapes characters so that the |
| * string is a valid JS string. |
| * @param {string} s The string to quote. |
| * @return {string} A copy of {@code s} surrounded by double quotes. |
| */ |
| goog.string.quote = function(s) { |
| s = String(s); |
| if (s.quote) { |
| return s.quote(); |
| } else { |
| var sb = ['"']; |
| for (var i = 0; i < s.length; i++) { |
| var ch = s.charAt(i); |
| var cc = ch.charCodeAt(0); |
| sb[i + 1] = goog.string.specialEscapeChars_[ch] || |
| ((cc > 31 && cc < 127) ? ch : goog.string.escapeChar(ch)); |
| } |
| sb.push('"'); |
| return sb.join(''); |
| } |
| }; |
| |
| |
| /** |
| * Takes a string and returns the escaped string for that character. |
| * @param {string} str The string to escape. |
| * @return {string} An escaped string representing {@code str}. |
| */ |
| goog.string.escapeString = function(str) { |
| var sb = []; |
| for (var i = 0; i < str.length; i++) { |
| sb[i] = goog.string.escapeChar(str.charAt(i)); |
| } |
| return sb.join(''); |
| }; |
| |
| |
| /** |
| * Takes a character and returns the escaped string for that character. For |
| * example escapeChar(String.fromCharCode(15)) -> "\\x0E". |
| * @param {string} c The character to escape. |
| * @return {string} An escaped string representing {@code c}. |
| */ |
| goog.string.escapeChar = function(c) { |
| if (c in goog.string.jsEscapeCache_) { |
| return goog.string.jsEscapeCache_[c]; |
| } |
| |
| if (c in goog.string.specialEscapeChars_) { |
| return goog.string.jsEscapeCache_[c] = goog.string.specialEscapeChars_[c]; |
| } |
| |
| var rv = c; |
| var cc = c.charCodeAt(0); |
| if (cc > 31 && cc < 127) { |
| rv = c; |
| } else { |
| // tab is 9 but handled above |
| if (cc < 256) { |
| rv = '\\x'; |
| if (cc < 16 || cc > 256) { |
| rv += '0'; |
| } |
| } else { |
| rv = '\\u'; |
| if (cc < 4096) { // \u1000 |
| rv += '0'; |
| } |
| } |
| rv += cc.toString(16).toUpperCase(); |
| } |
| |
| return goog.string.jsEscapeCache_[c] = rv; |
| }; |
| |
| |
| /** |
| * Takes a string and creates a map (Object) in which the keys are the |
| * characters in the string. The value for the key is set to true. You can |
| * then use goog.object.map or goog.array.map to change the values. |
| * @param {string} s The string to build the map from. |
| * @return {Object} The map of characters used. |
| */ |
| // TODO(arv): It seems like we should have a generic goog.array.toMap. But do |
| // we want a dependency on goog.array in goog.string? |
| goog.string.toMap = function(s) { |
| var rv = {}; |
| for (var i = 0; i < s.length; i++) { |
| rv[s.charAt(i)] = true; |
| } |
| return rv; |
| }; |
| |
| |
| /** |
| * Checks whether a string contains a given character. |
| * @param {string} s The string to test. |
| * @param {string} ss The substring to test for. |
| * @return {boolean} True if {@code s} contains {@code ss}. |
| */ |
| goog.string.contains = function(s, ss) { |
| return s.indexOf(ss) != -1; |
| }; |
| |
| |
| /** |
| * Removes a substring of a specified length at a specific |
| * index in a string. |
| * @param {string} s The base string from which to remove. |
| * @param {number} index The index at which to remove the substring. |
| * @param {number} stringLength The length of the substring to remove. |
| * @return {string} A copy of {@code s} with the substring removed or the full |
| * string if nothing is removed or the input is invalid. |
| */ |
| goog.string.removeAt = function(s, index, stringLength) { |
| var resultStr = s; |
| // If the index is greater or equal to 0 then remove substring |
| if (index >= 0 && index < s.length && stringLength > 0) { |
| resultStr = s.substr(0, index) + |
| s.substr(index + stringLength, s.length - index - stringLength); |
| } |
| return resultStr; |
| }; |
| |
| |
| /** |
| * Removes the first occurrence of a substring from a string. |
| * @param {string} s The base string from which to remove. |
| * @param {string} ss The string to remove. |
| * @return {string} A copy of {@code s} with {@code ss} removed or the full |
| * string if nothing is removed. |
| */ |
| goog.string.remove = function(s, ss) { |
| var re = new RegExp(goog.string.regExpEscape(ss), ''); |
| return s.replace(re, ''); |
| }; |
| |
| |
| /** |
| * Removes all occurrences of a substring from a string. |
| * @param {string} s The base string from which to remove. |
| * @param {string} ss The string to remove. |
| * @return {string} A copy of {@code s} with {@code ss} removed or the full |
| * string if nothing is removed. |
| */ |
| goog.string.removeAll = function(s, ss) { |
| var re = new RegExp(goog.string.regExpEscape(ss), 'g'); |
| return s.replace(re, ''); |
| }; |
| |
| |
| /** |
| * Escapes characters in the string that are not safe to use in a RegExp. |
| * @param {*} s The string to escape. If not a string, it will be casted |
| * to one. |
| * @return {string} A RegExp safe, escaped copy of {@code s}. |
| */ |
| goog.string.regExpEscape = function(s) { |
| return String(s).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1'). |
| replace(/\x08/g, '\\x08'); |
| }; |
| |
| |
| /** |
| * Repeats a string n times. |
| * @param {string} string The string to repeat. |
| * @param {number} length The number of times to repeat. |
| * @return {string} A string containing {@code length} repetitions of |
| * {@code string}. |
| */ |
| goog.string.repeat = function(string, length) { |
| return new Array(length + 1).join(string); |
| }; |
| |
| |
| /** |
| * Pads number to given length and optionally rounds it to a given precision. |
| * For example: |
| * <pre>padNumber(1.25, 2, 3) -> '01.250' |
| * padNumber(1.25, 2) -> '01.25' |
| * padNumber(1.25, 2, 1) -> '01.3' |
| * padNumber(1.25, 0) -> '1.25'</pre> |
| * |
| * @param {number} num The number to pad. |
| * @param {number} length The desired length. |
| * @param {number=} opt_precision The desired precision. |
| * @return {string} {@code num} as a string with the given options. |
| */ |
| goog.string.padNumber = function(num, length, opt_precision) { |
| var s = goog.isDef(opt_precision) ? num.toFixed(opt_precision) : String(num); |
| var index = s.indexOf('.'); |
| if (index == -1) { |
| index = s.length; |
| } |
| return goog.string.repeat('0', Math.max(0, length - index)) + s; |
| }; |
| |
| |
| /** |
| * Returns a string representation of the given object, with |
| * null and undefined being returned as the empty string. |
| * |
| * @param {*} obj The object to convert. |
| * @return {string} A string representation of the {@code obj}. |
| */ |
| goog.string.makeSafe = function(obj) { |
| return obj == null ? '' : String(obj); |
| }; |
| |
| |
| /** |
| * Concatenates string expressions. This is useful |
| * since some browsers are very inefficient when it comes to using plus to |
| * concat strings. Be careful when using null and undefined here since |
| * these will not be included in the result. If you need to represent these |
| * be sure to cast the argument to a String first. |
| * For example: |
| * <pre>buildString('a', 'b', 'c', 'd') -> 'abcd' |
| * buildString(null, undefined) -> '' |
| * </pre> |
| * @param {...*} var_args A list of strings to concatenate. If not a string, |
| * it will be casted to one. |
| * @return {string} The concatenation of {@code var_args}. |
| */ |
| goog.string.buildString = function(var_args) { |
| return Array.prototype.join.call(arguments, ''); |
| }; |
| |
| |
| /** |
| * Returns a string with at least 64-bits of randomness. |
| * |
| * Doesn't trust Javascript's random function entirely. Uses a combination of |
| * random and current timestamp, and then encodes the string in base-36 to |
| * make it shorter. |
| * |
| * @return {string} A random string, e.g. sn1s7vb4gcic. |
| */ |
| goog.string.getRandomString = function() { |
| var x = 2147483648; |
| return Math.floor(Math.random() * x).toString(36) + |
| Math.abs(Math.floor(Math.random() * x) ^ goog.now()).toString(36); |
| }; |
| |
| |
| /** |
| * Compares two version numbers. |
| * |
| * @param {string|number} version1 Version of first item. |
| * @param {string|number} version2 Version of second item. |
| * |
| * @return {number} 1 if {@code version1} is higher. |
| * 0 if arguments are equal. |
| * -1 if {@code version2} is higher. |
| */ |
| goog.string.compareVersions = function(version1, version2) { |
| var order = 0; |
| // Trim leading and trailing whitespace and split the versions into |
| // subversions. |
| var v1Subs = goog.string.trim(String(version1)).split('.'); |
| var v2Subs = goog.string.trim(String(version2)).split('.'); |
| var subCount = Math.max(v1Subs.length, v2Subs.length); |
| |
| // Iterate over the subversions, as long as they appear to be equivalent. |
| for (var subIdx = 0; order == 0 && subIdx < subCount; subIdx++) { |
| var v1Sub = v1Subs[subIdx] || ''; |
| var v2Sub = v2Subs[subIdx] || ''; |
| |
| // Split the subversions into pairs of numbers and qualifiers (like 'b'). |
| // Two different RegExp objects are needed because they are both using |
| // the 'g' flag. |
| var v1CompParser = new RegExp('(\\d*)(\\D*)', 'g'); |
| var v2CompParser = new RegExp('(\\d*)(\\D*)', 'g'); |
| do { |
| var v1Comp = v1CompParser.exec(v1Sub) || ['', '', '']; |
| var v2Comp = v2CompParser.exec(v2Sub) || ['', '', '']; |
| // Break if there are no more matches. |
| if (v1Comp[0].length == 0 && v2Comp[0].length == 0) { |
| break; |
| } |
| |
| // Parse the numeric part of the subversion. A missing number is |
| // equivalent to 0. |
| var v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10); |
| var v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10); |
| |
| // Compare the subversion components. The number has the highest |
| // precedence. Next, if the numbers are equal, a subversion without any |
| // qualifier is always higher than a subversion with any qualifier. Next, |
| // the qualifiers are compared as strings. |
| order = goog.string.compareElements_(v1CompNum, v2CompNum) || |
| goog.string.compareElements_(v1Comp[2].length == 0, |
| v2Comp[2].length == 0) || |
| goog.string.compareElements_(v1Comp[2], v2Comp[2]); |
| // Stop as soon as an inequality is discovered. |
| } while (order == 0); |
| } |
| |
| return order; |
| }; |
| |
| |
| /** |
| * Compares elements of a version number. |
| * |
| * @param {string|number|boolean} left An element from a version number. |
| * @param {string|number|boolean} right An element from a version number. |
| * |
| * @return {number} 1 if {@code left} is higher. |
| * 0 if arguments are equal. |
| * -1 if {@code right} is higher. |
| * @private |
| */ |
| goog.string.compareElements_ = function(left, right) { |
| if (left < right) { |
| return -1; |
| } else if (left > right) { |
| return 1; |
| } |
| return 0; |
| }; |
| |
| |
| /** |
| * Maximum value of #goog.string.hashCode, exclusive. 2^32. |
| * @type {number} |
| * @private |
| */ |
| goog.string.HASHCODE_MAX_ = 0x100000000; |
| |
| |
| /** |
| * String hash function similar to java.lang.String.hashCode(). |
| * The hash code for a string is computed as |
| * s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1], |
| * where s[i] is the ith character of the string and n is the length of |
| * the string. We mod the result to make it between 0 (inclusive) and 2^32 |
| * (exclusive). |
| * @param {string} str A string. |
| * @return {number} Hash value for {@code str}, between 0 (inclusive) and 2^32 |
| * (exclusive). The empty string returns 0. |
| */ |
| goog.string.hashCode = function(str) { |
| var result = 0; |
| for (var i = 0; i < str.length; ++i) { |
| result = 31 * result + str.charCodeAt(i); |
| // Normalize to 4 byte range, 0 ... 2^32. |
| result %= goog.string.HASHCODE_MAX_; |
| } |
| return result; |
| }; |
| |
| |
| /** |
| * The most recent unique ID. |0 is equivalent to Math.floor in this case. |
| * @type {number} |
| * @private |
| */ |
| goog.string.uniqueStringCounter_ = Math.random() * 0x80000000 | 0; |
| |
| |
| /** |
| * Generates and returns a string which is unique in the current document. |
| * This is useful, for example, to create unique IDs for DOM elements. |
| * @return {string} A unique id. |
| */ |
| goog.string.createUniqueString = function() { |
| return 'goog_' + goog.string.uniqueStringCounter_++; |
| }; |
| |
| |
| /** |
| * Converts the supplied string to a number, which may be Ininity or NaN. |
| * This function strips whitespace: (toNumber(' 123') === 123) |
| * This function accepts scientific notation: (toNumber('1e1') === 10) |
| * |
| * This is better than Javascript's built-in conversions because, sadly: |
| * (Number(' ') === 0) and (parseFloat('123a') === 123) |
| * |
| * @param {string} str The string to convert. |
| * @return {number} The number the supplied string represents, or NaN. |
| */ |
| goog.string.toNumber = function(str) { |
| var num = Number(str); |
| if (num == 0 && goog.string.isEmpty(str)) { |
| return NaN; |
| } |
| return num; |
| }; |
| |
| |
| /** |
| * A memoized cache for goog.string.toCamelCase. |
| * @type {Object.<string>} |
| * @private |
| */ |
| goog.string.toCamelCaseCache_ = {}; |
| |
| |
| /** |
| * Converts a string from selector-case to camelCase (e.g. from |
| * "multi-part-string" to "multiPartString"), useful for converting |
| * CSS selectors and HTML dataset keys to their equivalent JS properties. |
| * @param {string} str The string in selector-case form. |
| * @return {string} The string in camelCase form. |
| */ |
| goog.string.toCamelCase = function(str) { |
| return goog.string.toCamelCaseCache_[str] || |
| (goog.string.toCamelCaseCache_[str] = |
| String(str).replace(/\-([a-z])/g, function(all, match) { |
| return match.toUpperCase(); |
| })); |
| }; |
| |
| |
| /** |
| * A memoized cache for goog.string.toSelectorCase. |
| * @type {Object.<string>} |
| * @private |
| */ |
| goog.string.toSelectorCaseCache_ = {}; |
| |
| |
| /** |
| * Converts a string from camelCase to selector-case (e.g. from |
| * "multiPartString" to "multi-part-string"), useful for converting JS |
| * style and dataset properties to equivalent CSS selectors and HTML keys. |
| * @param {string} str The string in camelCase form. |
| * @return {string} The string in selector-case form. |
| */ |
| goog.string.toSelectorCase = function(str) { |
| return goog.string.toSelectorCaseCache_[str] || |
| (goog.string.toSelectorCaseCache_[str] = |
| String(str).replace(/([A-Z])/g, '-$1').toLowerCase()); |
| }; |