Plato on Github
Report Home
node_modules/selenium-webdriver/lib/goog/string/string.js
Maintainability
70.90
Lines of code
1435
Difficulty
102.16
Estimated Errors
8.59
Function weight
By Complexity
By SLOC
// 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'); /** * @define {boolean} Enables HTML escaping of lowercase letter "e" which helps * with detection of double-escaping as this letter is frequently used. */ goog.define('goog.string.DETECT_DOUBLE_ESCAPING', false); /** * 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; }; /** * Case-insensitive equality checker. * @param {string} str1 First string to check. * @param {string} str2 Second string to check. * @return {boolean} True if {@code str1} and {@code str2} are the same string, * ignoring case. */ goog.string.caseInsensitiveEquals = function(str1, str2) { return str1.toLowerCase() == str2.toLowerCase(); }; /** * 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) { var splitParts = str.split('%s'); var returnString = ''; var subsArguments = Array.prototype.slice.call(arguments, 1); while (subsArguments.length && // Replace up to the last split part. We are inserting in the // positions between split parts. splitParts.length > 1) { returnString += splitParts.shift() + subsArguments.shift(); } return returnString + splitParts.join('%s'); // Join unused '%s' }; /** * 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, undefined, empty or contains only whitespaces. * @param {*} str The string to check. * @return {boolean} True if{@code str} is null, undefined, 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; }; /** * 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) { return encodeURIComponent(String(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>'); }; /** * Escapes double quote '"' and single quote '\'' characters in addition to * '&', '<', and '>' so that a string can be included in an HTML tag attribute * value within double or single 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. * * With goog.string.DETECT_DOUBLE_ESCAPING, this function escapes also the * lowercase letter "e". * * 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) { str = str.replace(goog.string.AMP_RE_, '&') .replace(goog.string.LT_RE_, '<') .replace(goog.string.GT_RE_, '>') .replace(goog.string.QUOT_RE_, '"') .replace(goog.string.SINGLE_QUOTE_RE_, ''') .replace(goog.string.NULL_RE_, '�'); if (goog.string.DETECT_DOUBLE_ESCAPING) { str = str.replace(goog.string.E_RE_, 'e'); } return str; } 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.ALL_RE_.test(str)) return str; // str.indexOf is faster than regex.test in this case if (str.indexOf('&') != -1) { str = str.replace(goog.string.AMP_RE_, '&'); } if (str.indexOf('<') != -1) { str = str.replace(goog.string.LT_RE_, '<'); } if (str.indexOf('>') != -1) { str = str.replace(goog.string.GT_RE_, '>'); } if (str.indexOf('"') != -1) { str = str.replace(goog.string.QUOT_RE_, '"'); } if (str.indexOf('\'') != -1) { str = str.replace(goog.string.SINGLE_QUOTE_RE_, '''); } if (str.indexOf('\x00') != -1) { str = str.replace(goog.string.NULL_RE_, '�'); } if (goog.string.DETECT_DOUBLE_ESCAPING && str.indexOf('e') != -1) { str = str.replace(goog.string.E_RE_, 'e'); } return str; } }; /** * Regular expression that matches an ampersand, for use in escaping. * @const {!RegExp} * @private */ goog.string.AMP_RE_ = /&/g; /** * Regular expression that matches a less than sign, for use in escaping. * @const {!RegExp} * @private */ goog.string.LT_RE_ = /</g; /** * Regular expression that matches a greater than sign, for use in escaping. * @const {!RegExp} * @private */ goog.string.GT_RE_ = />/g; /** * Regular expression that matches a double quote, for use in escaping. * @const {!RegExp} * @private */ goog.string.QUOT_RE_ = /"/g; /** * Regular expression that matches a single quote, for use in escaping. * @const {!RegExp} * @private */ goog.string.SINGLE_QUOTE_RE_ = /'/g; /** * Regular expression that matches null character, for use in escaping. * @const {!RegExp} * @private */ goog.string.NULL_RE_ = /\x00/g; /** * Regular expression that matches a lowercase letter "e", for use in escaping. * @const {!RegExp} * @private */ goog.string.E_RE_ = /e/g; /** * Regular expression that matches any character that needs to be escaped. * @const {!RegExp} * @private */ goog.string.ALL_RE_ = (goog.string.DETECT_DOUBLE_ESCAPING ? /[\x00&<>"'e]/ : /[\x00&<>"']/); /** * 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 a HTML string using the provided document. * * @param {string} str The string to unescape. * @param {!Document} document A document to use in escaping the string. * @return {string} An unescaped copy of {@code str}. */ goog.string.unescapeEntitiesWithDocument = function(str, document) { if (goog.string.contains(str, '&')) { return goog.string.unescapeEntitiesUsingDom_(str, document); } 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. * @param {Document=} opt_document An optional document to use for creating * elements. If this is not specified then the default window.document * will be used. * @return {string} The unescaped {@code str} string. */ goog.string.unescapeEntitiesUsingDom_ = function(str, opt_document) { var seen = {'&': '&', '<': '<', '>': '>', '"': '"'}; var div; if (opt_document) { div = opt_document.createElement('div'); } else { div = goog.global.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) { // This doesn't use goog.string.preserveSpaces for backwards compatibility. return goog.string.newLineToBr(str.replace(/ /g, '  '), opt_xml); }; /** * Preserve spaces that would be otherwise collapsed in HTML by replacing them * with non-breaking space Unicode characters. * @param {string} str The string in which to preserve whitespace. * @return {string} A copy of {@code str} with preserved whitespace. */ goog.string.preserveSpaces = function(str) { return str.replace(/(^|[\n ]) /g, '$1' + goog.string.Unicode.NBSP); }; /** * 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; }; /** * Determines whether a string contains a substring. * @param {string} str The string to search. * @param {string} subString The substring to search for. * @return {boolean} Whether {@code str} contains {@code subString}. */ goog.string.contains = function(str, subString) { return str.indexOf(subString) != -1; }; /** * Determines whether a string contains a substring, ignoring case. * @param {string} str The string to search. * @param {string} subString The substring to search for. * @return {boolean} Whether {@code str} contains {@code subString}. */ goog.string.caseInsensitiveContains = function(str, subString) { return goog.string.contains(str.toLowerCase(), subString.toLowerCase()); }; /** * Returns the non-overlapping occurrences of ss in s. * If either s or ss evalutes to false, then returns zero. * @param {string} s The string to look in. * @param {string} ss The string to look for. * @return {number} Number of occurrences of ss in s. */ goog.string.countOf = function(s, ss) { return s && ss ? s.split(ss).length - 1 : 0; }; /** * 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 Infinity 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; }; /** * Returns whether the given string is lower camel case (e.g. "isFooBar"). * * Note that this assumes the string is entirely letters. * @see http://en.wikipedia.org/wiki/CamelCase#Variations_and_synonyms * * @param {string} str String to test. * @return {boolean} Whether the string is lower camel case. */ goog.string.isLowerCamelCase = function(str) { return /^[a-z]+([A-Z][a-z]*)*$/.test(str); }; /** * Returns whether the given string is upper camel case (e.g. "FooBarBaz"). * * Note that this assumes the string is entirely letters. * @see http://en.wikipedia.org/wiki/CamelCase#Variations_and_synonyms * * @param {string} str String to test. * @return {boolean} Whether the string is upper camel case. */ goog.string.isUpperCamelCase = function(str) { return /^([A-Z][a-z]*)+$/.test(str); }; /** * 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 String(str).replace(/\-([a-z])/g, function(all, match) { return match.toUpperCase(); }); }; /** * 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 String(str).replace(/([A-Z])/g, '-$1').toLowerCase(); }; /** * Converts a string into TitleCase. First character of the string is always * capitalized in addition to the first letter of every subsequent word. * Words are delimited by one or more whitespaces by default. Custom delimiters * can optionally be specified to replace the default, which doesn't preserve * whitespace delimiters and instead must be explicitly included if needed. * * Default delimiter => " ": * goog.string.toTitleCase('oneTwoThree') => 'OneTwoThree' * goog.string.toTitleCase('one two three') => 'One Two Three' * goog.string.toTitleCase(' one two ') => ' One Two ' * goog.string.toTitleCase('one_two_three') => 'One_two_three' * goog.string.toTitleCase('one-two-three') => 'One-two-three' * * Custom delimiter => "_-.": * goog.string.toTitleCase('oneTwoThree', '_-.') => 'OneTwoThree' * goog.string.toTitleCase('one two three', '_-.') => 'One two three' * goog.string.toTitleCase(' one two ', '_-.') => ' one two ' * goog.string.toTitleCase('one_two_three', '_-.') => 'One_Two_Three' * goog.string.toTitleCase('one-two-three', '_-.') => 'One-Two-Three' * goog.string.toTitleCase('one...two...three', '_-.') => 'One...Two...Three' * goog.string.toTitleCase('one. two. three', '_-.') => 'One. two. three' * goog.string.toTitleCase('one-two.three', '_-.') => 'One-Two.Three' * * @param {string} str String value in camelCase form. * @param {string=} opt_delimiters Custom delimiter character set used to * distinguish words in the string value. Each character represents a * single delimiter. When provided, default whitespace delimiter is * overridden and must be explicitly included if needed. * @return {string} String value in TitleCase form. */ goog.string.toTitleCase = function(str, opt_delimiters) { var delimiters = goog.isString(opt_delimiters) ? goog.string.regExpEscape(opt_delimiters) : '\\s'; // For IE8, we need to prevent using an empty character set. Otherwise, // incorrect matching will occur. delimiters = delimiters ? '|[' + delimiters + ']+' : ''; var regexp = new RegExp('(^' + delimiters + ')([a-z])', 'g'); return str.replace(regexp, function(all, p1, p2) { return p1 + p2.toUpperCase(); }); }; /** * Parse a string in decimal or hexidecimal ('0xFFFF') form. * * To parse a particular radix, please use parseInt(string, radix) directly. See * https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/parseInt * * This is a wrapper for the built-in parseInt function that will only parse * numbers as base 10 or base 16. Some JS implementations assume strings * starting with "0" are intended to be octal. ES3 allowed but discouraged * this behavior. ES5 forbids it. This function emulates the ES5 behavior. * * For more information, see Mozilla JS Reference: http://goo.gl/8RiFj * * @param {string|number|null|undefined} value The value to be parsed. * @return {number} The number, parsed. If the string failed to parse, this * will be NaN. */ goog.string.parseInt = function(value) { // Force finite numbers to strings. if (isFinite(value)) { value = String(value); } if (goog.isString(value)) { // If the string starts with '0x' or '-0x', parse as hex. return /^\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10); } return NaN; }; /** * Splits a string on a separator a limited number of times. * * This implementation is more similar to Python or Java, where the limit * parameter specifies the maximum number of splits rather than truncating * the number of results. * * See http://docs.python.org/2/library/stdtypes.html#str.split * See JavaDoc: http://goo.gl/F2AsY * See Mozilla reference: http://goo.gl/dZdZs * * @param {string} str String to split. * @param {string} separator The separator. * @param {number} limit The limit to the number of splits. The resulting array * will have a maximum length of limit+1. Negative numbers are the same * as zero. * @return {!Array.<string>} The string, split. */ goog.string.splitLimit = function(str, separator, limit) { var parts = str.split(separator); var returnVal = []; // Only continue doing this while we haven't hit the limit and we have // parts left. while (limit > 0 && parts.length) { returnVal.push(parts.shift()); limit--; } // If there are remaining parts, append them to the end. if (parts.length) { returnVal.push(parts.join(separator)); } return returnVal; };