An integer specifying the number of characters in the specified String object.

Because all string indexes are zero-based, the index of the last character for any string x is x.length - 1.

Creates a new String object initialized to the specified string.

Note: Because string literals use less overhead than String objects and are generally easier to use, you should use string literals instead of the String class unless you have a good reason to use a String object rather than a string literal.

Returns the character in the position specified by the index parameter. If index is not a number from 0 to string.length - 1, an empty string is returned.

This method is similar to String.charCodeAt() except that the returned value is a character, not a 16-bit integer character code.

Parameters

See also

Returns the numeric Unicode character code of the character at the specified index. If index is not a number from 0 to string.length - 1, NaN is returned.

This method is similar to String.charAt() except that the returned value is a 16-bit integer character code, not the actual character.

Parameters

See also

Appends the supplied arguments to the end of the String object, converting them to strings if necessary, and returns the resulting string. The original value of the source String object remains unchanged.

Parameters

Returns a string comprising the characters represented by the Unicode character codes in the parameters.

Parameters

Searches the string and returns the position of the first occurrence of val found at or after startIndex within the calling string. This index is zero-based, meaning that the first character in a string is considered to be at index 0--not index 1. If val is not found, the method returns -1.

Parameters

See also

Searches the string from right to left and returns the index of the last occurrence of val found before startIndex. The index is zero-based, meaning that the first character is at index 0, and the last is at string.length - 1. If val is not found, the method returns -1.

Parameters

See also

Compares the sort order of two or more strings and returns the result of the comparison as an integer. While this method is intended to handle the comparison in a locale-specific way, the ActionScript 3.0 implementation does not produce a different result from other string comparisons such as the equality (==) or inequality (!=) operators. If the strings are equivalent, the return value is 0. If the original string value precedes the string value specified by other, the return value is a negative integer, the absolute value of which represents the number of characters that separates the two string values. If the original string value comes after other, the return value is a positive integer, the absolute value of which represents the number of characters that separates the two string values.

Parameters

Matches the specifed pattern against the string.

Parameters

See also

Matches the specifed pattern against the string and returns a new string in which the first match of pattern is replaced with the content specified by repl. The pattern parameter can be a string or a regular expression. The repl parameter can be a string or a function; if it is a function, the string returned by the function is inserted in place of the match. The original string is not modified.

In the following example, only the first instance of "sh" (case-sensitive) is replaced:

 var myPattern:RegExp = /sh/;  
 var str:String = "She sells seashells by the seashore.";
 trace(str.replace(myPattern, "sch"));  
    // She sells seaschells by the seashore.

In the following example, all instances of "sh" (case-sensitive) are replaced because the g (global) flag is set in the regular expression:

 var myPattern:RegExp = /sh/g;  
 var str:String = "She sells seashells by the seashore.";
 trace(str.replace(myPattern, "sch"));  
    // She sells seaschells by the seaschore.

In the following example, all instance of "sh" are replaced because the g (global) flag is set in the regular expression and the matches are not case-sensitive because the i (ignoreCase) flag is set:

 var myPattern:RegExp = /sh/gi;  
 var str:String = "She sells seashells by the seashore.";
 trace(str.replace(myPattern, "sch"));  
    // sche sells seaschells by the seaschore.

Parameters

var str:String = "flip-flop";
 var pattern:RegExp = /(\w+)-(\w+)/g;
 trace(str.replace(pattern, "$2-$1")); // flop-flip

 var str1:String = "abc12 def34";
 var pattern:RegExp = /([a-z]+)([0-9]+)/g;
 var str2:String = str1.replace(pattern, replFN);
 trace(str2);   // 12abc 34def
 
 function replFN():String {
  return arguments[2] + arguments[1];
 }

 {"abc12", "abc", "12", 0, "abc12 def34"}

 {"def34", "def", "34", 6, "abc123 def34"}

See also

Searches for the specifed pattern and returns the index of the first matching substring. If there is no matching substring, the method returns -1.

Parameters

See also

Returns a string that includes the startIndex character and all characters up to, but not including, the endIndex character. The original String object is not modified. If the endIndex parameter is not specified, then the end of the substring is the end of the string. If the character indexed by startIndex is the same as or to the right of the character indexed by endIndex, the method returns an empty string.

Parameters

See also

Splits a String object into an array of substrings by dividing it wherever the specified delimiter parameter occurs.

If the delimiter parameter is a regular expression, only the first match at a given position of the string is considered, even if backtracking could find a nonempty substring match at that position. For example:

  var str:String = "ab";
  var results:Array = str.split(/a*?/); // results == ["","b"]
  
  results = str.split(/a*/); // results == ["","b"].)

If the delimiter parameter is a regular expression containing grouping parentheses, then each time the delimiter is matched, the results (including any undefined results) of the grouping parentheses are spliced into the output array. For example

  var str:String = "Thi5 is a tricky-66 example.";
  var re:RegExp = /(\d+)/;
  var results:Array = str.split(re);
      // results == ["Thi","5"," is a tricky-","66"," example."]

If the limit parameter is specified, then the returned array will have no more than the specified number of elements.

If the delimiter is an empty string, an empty regular expression, or a regular expression that can match an empty string, each single character in the string is output as an element in the array.

If the delimiter parameter is undefined, the entire string is placed into the first element of the returned array.

Parameters

See also

Returns a substring consisting of the characters that start at the specified startIndex and with a length specified by len. The original string is unmodified.

Parameters

Returns a string consisting of the character specified by startIndex and all characters up to endIndex - 1. If endIndex is not specified, String.length is used. If the value of startIndex equals the value of endIndex, the method returns an empty string. If the value of startIndex is greater than the value of endIndex, the parameters are automatically swapped before the function executes. The original string is unmodified.

Parameters

Returns a copy of this string, with all uppercase characters converted to lowercase. The original string is unmodified. While this method is intended to handle the conversion in a locale-specific way, the ActionScript 3.0 implementation does not produce a different result from the toLowerCase() method.

See also

Returns a copy of this string, with all lowercase characters converted to uppercase. The original string is unmodified. While this method is intended to handle the conversion in a locale-specific way, the ActionScript 3.0 implementation does not produce a different result from the toUpperCase() method.

See also

Returns a copy of this string, with all uppercase characters converted to lowercase. The original string is unmodified.

This method converts all characters (not simply A-Z) for which Unicode lowercase equivalents exist:

  var str:String = " JOSÉ BARÇA";
  trace(str.toLowerCase()); // josé barça

See also

Returns a copy of this string, with all lowercase characters converted to uppercase. The original string is unmodified.

This method converts all characters (not simply a-z) for which Unicode uppercase equivalents exist:

  var str:String = "José Barça";
  trace(str.toUpperCase()); // JOSÉ BARÇA

See also

Returns the primitive value of a String instance. This method is designed to convert a String object into a primitive string value. Because Flash Player automatically calls valueOf() when necessary, you rarely need to explicitly call this method.

1. The constructor for StringExample declares several local String instances, which are initialized with various strings and a new StringHelper object.
2. The StringHelper class has the following methods:
   • replace(): calls the split() and join() methods of String to remove a substring of the string passed in with a new one.
   • trim(): calls both trimBack() and trimFront() using the strings passed in and returns the updated string.
   • trimFront():recursively removes all characters that match the char parameter, starting from the front of the string and working toward the end, until the first character in the string does not match char and returns the updated string.
   • trimBack(): recursively removes all characters that match the char parameter, starting from the end of the string and working backward, until the last character in the string does not match char and returns the updated string.
   • stringToCharacter(): returns the first character of the string passed to it.
3. Three strings are then produced using the declared string variables with a call to the replace() method used to produce the second string and trim() to produce the third string.

package {
    import flash.display.Sprite;

    public class StringExample extends Sprite {
        public function StringExample() {
            var companyStr:String = new String("     Company X");
            var productStr:String = "Product Z Basic     ";
            var emptyStr:String = " ";
            var strHelper:StringHelper = new StringHelper();

            var companyProductStr:String = companyStr + emptyStr + productStr;
            trace("'" + companyProductStr + "'");    // '     Company X Product Z Basic     '

            companyProductStr = strHelper.replace(companyProductStr, "Basic", "Professional");
            trace("'" + companyProductStr + "'");    // '     Company X Product Z Professional     '

            companyProductStr = strHelper.trim(companyProductStr, emptyStr);
            trace("'" + companyProductStr + "'");    // 'Company X Product Z Professional'
        }
    }
}

class StringHelper {
    public function StringHelper() {
    }

    public function replace(str:String, oldSubStr:String, newSubStr:String):String {
        return str.split(oldSubStr).join(newSubStr);
    }

    public function trim(str:String, char:String):String {
        return trimBack(trimFront(str, char), char);
    }

    public function trimFront(str:String, char:String):String {
        char = stringToCharacter(char);
        if (str.charAt(0) == char) {
            str = trimFront(str.substring(1), char);
        }
        return str;
    }

    public function trimBack(str:String, char:String):String {
        char = stringToCharacter(char);
        if (str.charAt(str.length - 1) == char) {
            str = trimBack(str.substring(0, str.length - 1), char);
        }
        return str;
    }

    public function stringToCharacter(str:String):String {
        if (str.length == 1) {
            return str;
        }
        return str.slice(0, 1);
    }
}