Namespace goog.string
code »Enumerations
|
Global Functions
code »goog.string.buildString ( var_args ) ⇒ string
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:
buildString('a', 'b', 'c', 'd') -> 'abcd'
buildString(null, undefined) -> ''
string
Parameters |
---|
|
Returns |
var_args . |
code »goog.string.canonicalizeNewlines ( str ) ⇒ string
Replaces Windows and Mac new lines with unix style: \r or \r\n with \n.
string
Parameters |
---|
|
Returns |
str A copy of {@code} with canonicalized newlines. |
code »goog.string.caseInsensitiveCompare ( str1, str2 ) ⇒ number
A string comparator that ignores case.
-1 = str1 less than str2
0 = str1 equals str2
1 = str1 greater than str2
number
code »goog.string.caseInsensitiveContains ( str, subString ) ⇒ boolean
Determines whether a string contains a substring, ignoring case.
boolean
code »goog.string.caseInsensitiveEndsWith ( str, suffix ) ⇒ boolean
Case-insensitive suffix-checker.
boolean
code »goog.string.caseInsensitiveEquals ( str1, str2 ) ⇒ boolean
Case-insensitive equality checker.
boolean
code »goog.string.caseInsensitiveStartsWith ( str, prefix ) ⇒ boolean
Case-insensitive prefix-checker.
boolean
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.
Parameters |
---|
|
Returns |
|
code »goog.string.collapseWhitespace ( str ) ⇒ string
Converts multiple whitespace chars (spaces, non-breaking-spaces, new lines
and tabs) to a single space, and strips leading and trailing whitespace.
string
Parameters |
---|
|
Returns |
str with collapsed whitespace. |
code »goog.string.compareElements_ ( left, right ) ⇒ number
Compares elements of a version number.
number
code »goog.string.contains ( str, subString ) ⇒ boolean
Determines whether a string contains a substring.
boolean
code »goog.string.countOf ( s, ss ) ⇒ number
Returns the non-overlapping occurrences of ss in s.
If either s or ss evalutes to false, then returns zero.
number
Generates and returns a string which is unique in the current document.
This is useful, for example, to create unique IDs for DOM elements.
Returns |
---|
|
code »goog.string.endsWith ( str, suffix ) ⇒ boolean
Fast suffix-checker.
boolean
code »goog.string.escapeChar ( c ) ⇒ string
Takes a character and returns the escaped string for that character. For
example escapeChar(String.fromCharCode(15)) -> "\\x0E".
string
Parameters |
---|
|
Returns |
c . |
code »goog.string.escapeString ( str ) ⇒ string
Takes a string and returns the escaped string for that character.
string
Parameters |
---|
|
Returns |
str . |
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.
Returns |
---|
|
code »goog.string.hashCode ( str ) ⇒ number
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).
number
Parameters |
---|
|
Returns |
str , between 0 (inclusive) and 2^32
(exclusive). The empty string returns 0. |
code »goog.string.htmlEscape ( str, opt_isLikelyToContainHtmlChars ) ⇒ string
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.
string
Parameters |
---|
|
Returns |
str . |
code »goog.string.isAlpha ( str ) ⇒ boolean
Checks if a string contains all letters.
boolean
Parameters |
---|
|
Returns |
str consists entirely of letters. |
code »goog.string.isAlphaNumeric ( str ) ⇒ boolean
Checks if a string contains only numbers or letters.
boolean
Parameters |
---|
|
Returns |
str is alphanumeric. |
Checks if a string is all breaking whitespace.
Parameters |
---|
|
Returns |
|
code »goog.string.isEmpty ( str ) ⇒ boolean
Checks if a string is empty or contains only whitespaces.
boolean
Parameters |
---|
|
Returns |
str is empty or whitespace only. |
code »goog.string.isEmptySafe ( str ) ⇒ boolean
Checks if a string is null, undefined, empty or contains only whitespaces.
boolean
Parameters |
---|
|
Returns |
str is null, undefined, empty, or
whitespace only. |
code »goog.string.isLowerCamelCase ( str ) ⇒ boolean
Returns whether the given string is lower camel case (e.g. "isFooBar").
Note that this assumes the string is entirely letters.
boolean
Parameters |
---|
|
Returns |
|
code »goog.string.isNumeric ( str ) ⇒ boolean
Checks if a string contains only numbers.
boolean
Parameters |
---|
|
Returns |
str is numeric. |
code »goog.string.isSpace ( ch ) ⇒ boolean
Checks if a character is a space character.
boolean
Parameters |
---|
|
Returns |
|
code »goog.string.isUnicodeChar ( ch ) ⇒ boolean
Checks if a character is a valid unicode character.
boolean
Parameters |
---|
|
Returns |
|
code »goog.string.isUpperCamelCase ( str ) ⇒ boolean
Returns whether the given string is upper camel case (e.g. "FooBarBaz").
Note that this assumes the string is entirely letters.
boolean
Parameters |
---|
|
Returns |
|
code »goog.string.makeSafe ( obj ) ⇒ string
Returns a string representation of the given object, with
null and undefined being returned as the empty string.
string
Parameters |
---|
|
Returns |
obj . |
code »goog.string.newLineToBr ( str, opt_xml ) ⇒ string
Converts \n to
s or
s.
string
s or
s.
code »goog.string.normalizeSpaces ( str ) ⇒ string
Normalizes spaces in a string, replacing all consecutive spaces and tabs
with a single space. Replaces non-breaking space with a space.
string
Parameters |
---|
|
Returns |
str with all consecutive spaces and tabs
replaced with a single space. |
code »goog.string.normalizeWhitespace ( str ) ⇒ string
Normalizes whitespace in a string, replacing all whitespace chars with
a space.
string
Parameters |
---|
|
Returns |
str with all whitespace normalized. |
code »goog.string.numerateCompare ( str1, str2 ) ⇒ number
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.
number
code »goog.string.padNumber ( num, length, opt_precision ) ⇒ string
Pads number to given length and optionally rounds it to a given precision.
For example:
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'
string
code »goog.string.parseInt ( value ) ⇒ number
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
number
code »goog.string.preserveSpaces ( str ) ⇒ string
Preserve spaces that would be otherwise collapsed in HTML by replacing them
with non-breaking space Unicode characters.
string
Parameters |
---|
|
Returns |
str with preserved whitespace. |
code »goog.string.quote ( s ) ⇒ string
Encloses a string in double quotes and escapes characters so that the
string is a valid JS string.
string
Parameters |
---|
|
Returns |
s surrounded by double quotes. |
code »goog.string.regExpEscape ( s ) ⇒ string
Escapes characters in the string that are not safe to use in a RegExp.
string
Parameters |
---|
|
Returns |
s . |
code »goog.string.remove ( s, ss ) ⇒ string
Removes the first occurrence of a substring from a string.
string
code »goog.string.removeAll ( s, ss ) ⇒ string
Removes all occurrences of a substring from a string.
string
code »goog.string.removeAt ( s, index, stringLength ) ⇒ string
Removes a substring of a specified length at a specific
index in a string.
string
code »goog.string.repeat ( string, length ) ⇒ string
Repeats a string n times.
string
code »goog.string.splitLimit ( str, separator, limit ) ⇒ !Array.<string>
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
!Array.<string>
code »goog.string.startsWith ( str, prefix ) ⇒ boolean
Fast prefix-checker.
boolean
code »goog.string.stripNewlines ( str ) ⇒ string
Takes a string and replaces newlines with a space. Multiple lines are
replaced with a single space.
string
Parameters |
---|
|
Returns |
str stripped of newlines. |
code »goog.string.stripQuotes ( str, quoteChars ) ⇒ string
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:
goog.string.stripQuotes('"abc"', '"`') --> 'abc'
goog.string.stripQuotes('`abc`', '"`') --> 'abc'
string
code »goog.string.subs ( str, var_args ) ⇒ string
Does simple python-style string substitution.
subs("foo%s hot%s", "bar", "dog") becomes "foobar hotdog".
string
Parameters |
---|
|
Returns |
str in which each occurrence of
%s has been replaced an argument from var_args . |
code »goog.string.toCamelCase ( str ) ⇒ string
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.
string
Parameters |
---|
|
Returns |
|
code »goog.string.toMap ( s ) ⇒ !Object
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.
!Object
Parameters |
---|
|
Returns |
|
code »goog.string.toNumber ( str ) ⇒ number
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)
number
Parameters |
---|
|
Returns |
|
code »goog.string.toSelectorCase ( str ) ⇒ string
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.
string
Parameters |
---|
|
Returns |
|
code »goog.string.toTitleCase ( str, opt_delimiters ) ⇒ string
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'
string
Parameters |
---|
Returns |
|
code »goog.string.trim ( str ) ⇒ string
Trims white spaces to the left and right of a string.
string
Parameters |
---|
|
Returns |
str . |
code »goog.string.trimLeft ( str ) ⇒ string
Trims whitespaces at the left end of a string.
string
Parameters |
---|
|
Returns |
str . |
code »goog.string.trimRight ( str ) ⇒ string
Trims whitespaces at the right end of a string.
string
Parameters |
---|
|
Returns |
str . |
code »goog.string.truncate ( str, chars, opt_protectEscapedCharacters ) ⇒ string
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...'.
string
code »goog.string.truncateMiddle ( str, chars, opt_protectEscapedCharacters, opt_trailingChars ) ⇒ string
Truncate a string in the middle, adding "..." if necessary,
and favoring the beginning of the string.
string
Parameters |
---|
|
Returns |
str . |
code »goog.string.unescapeEntities ( str ) ⇒ string
Unescapes an HTML string.
string
Parameters |
---|
|
Returns |
str . |
code »goog.string.unescapeEntitiesUsingDom_ ( str, opt_document ) ⇒ string
Unescapes an HTML string using a DOM to resolve non-XML, non-numeric
entities. This function is XSS-safe and whitespace-preserving.
string
code »goog.string.unescapeEntitiesWithDocument ( str, document ) ⇒ string
Unescapes a HTML string using the provided document.
string
Unescapes XML entities.
Parameters |
---|
|
Returns |
str . |
code »goog.string.urlDecode ( str ) ⇒ string
URL-decodes the string. We need to specially handle '+'s because
the javascript library doesn't convert them to spaces.
string
Parameters |
---|
|
Returns |
str . |
code »goog.string.urlEncode ( str ) ⇒ string
URL-encodes a string
string
Parameters |
---|
|
Returns |
str that is safe for urls.
Note that '#', ':', and other characters used to delimit portions
of URLs *will* be encoded. |
code »goog.string.whitespaceEscape ( str, opt_xml ) ⇒ string
Do escaping of whitespace to preserve spatial formatting. We use character
entity #160 to make it safer for xml.
string