javascript String

属性

1.constructor 指定创建一个对象的函数。

constructor 属性是每个具有原型的对象的原型成员。这包括除了 arguments、Enumerator、Error、Global、Math、RegExp、Regular Expression 和 VBArray 对象以外的所有内部 JScript 对象。constructor 属性包含了对某种函数的引用，此种函数构造了特定对象的实例。
基于类的对象没有 constructor 属性。

2.length 返回字符串的长度。

length 属性包含一个整数，该整数指示 String 对象中的字符数。String 对象中的最后一个字符的索引为 length - 1。

3.prototype 为对象的类返回原型的引用。

用prototype属性为对象的类提供一组基本功能。对象的新的实例“继承”了赋予该对象的原型的行为。
所有内部 JScript 对象都有一个只读的 prototype 属性。可以像该例中那样，为原型添加功能，但不可以向对象赋予另外一个原型。但是，可以向用户定义的对象赋予新的原型。
本语言参考中，每个内部对象的方法和属性列表都指示了哪些是对象原型的一部分，哪些不是。
注意：当以快速模式（JScript .NET 的默认模式）运行时，不能修改内置对象的 prototype 属性。若要从命令行编译使用 prototype 属性的程序，必须使用 /fast- 关闭快速选项。由于线程处理问题，在 ASP.NET 中关闭快速选项是不安全的。

方法

1.function anchor(anchorString : String ) : String

返回对象中指定文本周围带有 HTML 定位点（具有 NAME 属性）的字符串。
参数：anchorString是要放在 HTML 定位点 NAME 属性中的文本。
备注：调用 anchor 方法在 String 对象外创建一个命名定位点。
未进行任何检查来查看此标记是否已应用于该字符串。

2.function big() : String

返回 String 对象中文本周围带有 HTML <BIG> 标记的字符串。
备注：未进行任何检查来查看此标记是否已应用于该字符串。

3.function blink() : String

返回 String 对象中文本周围带有 HTML <BLINK> 标记的字符串。
备注：未进行任何检查来查看此标记是否已应用于该字符串。在 Microsoft Internet Explorer 中不支持 <BLINK> 标记

4.function bold() : String

返回 String 对象中文本周围带有 HTML <B> 标记的字符串。
备注:未进行任何检查来查看此标记是否已应用于该字符串。

5.function charAt(index : Number) : String

返回 String 对象的指定索引处的字符
参数：index 必选。所需字符的从零开始的索引。有效值为 0 到字符串长度减 1 的数字。
备注：charAt 方法返回一个字符值，该字符值等于指定索引位置的字符。一个字符串中的第一个字符位于索引位置 0，第二个字符位于索引位置 1，依此类推。超出有效范围的 index 返回空字符串。

6.function charCodeAt(index : Number) : String

返回一个整数，该整数表示 String 对象中指定位置处的字符的 Unicode 编码。
参数：index 必选。所需字符的从零开始的索引。有效值为 0 到字符串长度减 1 的数字。
备注：一个字符串中的第一个字符位于索引位置 0，第二个字符位于索引位置 1，依此类推。如果指定 index 没有字符，将返回 NaN。

7.function concat([string1 : String [, ... [, stringN : String]]]]) : String

返回一个字符串值，该值包含当前字符串与提供的任何字符串的连接。
参数：string1, ..., stringN 可选。要连接到当前字符串末尾的 String 对象或文本。
备注：concat 方法的结果等同于：result = curstring + string1 + ... + stringN。curstring 是指对象中存储的用于提供 concat 方法的字符串。源字符串中或结果字符串中的值的变化都不会影响另一个字符串中的值。如果有不是字符串的参数，则它们在连接到 curstring 之前将首先被转换为字符串。

8.function fixed() : String

返回 String 对象中文本周围带有 HTML <TT> 标记的字符串。
备注：未进行任何检查来查看此标记是否已应用于该字符串。

9.function fontcolor(colorVal : String) : String

返回 String 对象中文本周围带有 HTML <FONT> 标记（具有 COLOR 属性）的字符串。
参数：colorVal 必选。包含颜色值的字符串值。可以是颜色的十六进制值，也可以是颜色的预定义名。
备注：有效的预定义颜色名取决于 JScript 主机（浏览器、服务器等）。它们也可能随主机版本的不同而不同。详细信息请查阅主机文档。未进行任何检查来查看此标记是否已应用于该字符串。

10.function fontsize(intSize : Number) : String

返回 String 对象中文本周围带有 HTML <FONT> 标记（具有 SIZE 属性）的字符串。
参数：intSize 必选。用来指定文本大小的整数值。
备注：有效的整数值取决于 Microsoft JScript 主机。详细信息请参见主机文档。未进行任何检查来查看此标记是否已应用于该字符串。

11.function fromCharCode([code1 : Number [, ... [, codeN : Number]]]]) : String

从一些 Unicode 字符值中返回一个字符串。
参数：code1, ..., codeN 可选。要转换为字符串的 Unicode 字符值序列。如果没有给出参数，结果为空字符串。
备注：fromCharCode 方法是从全局 String 对象中调用的。

12.function indexOf(subString : String [, startIndex : Number]) : Number

返回 String 对象内第一次出现子字符串的字符位置。
参数：subString 必选。在 String 对象中搜索的子字符串。
startIndex 可选。该整数值指定在 String 对象内开始搜索的索引。若省略此参数，则搜索从字符串的起始处开始。
备注：indexOf 方法返回一个整数值，该值指示 String 对象内子字符串的起始位置。如果未找到子字符串，则返回 -1。如果 startindex 为负，则将 startindex 视为零。如果它比最大字符位置索引还大，则将它视为可能的最大索引。搜索将从左向右执行。否则，此方法与 lastIndexOf 相同。

13.function italics() : String

返回字符串对象中文本周围带有 HTML <I> 标记的字符串。
备注：未进行任何检查来查看此标记是否已应用于该字符串。

14.function lastIndexOf(substring : String [, startindex : Number ]) : Number

返回 String 对象中某个子字符串的最后一个匹配项的索引。
参数：substring 必选。在 String 对象内将被搜索的子字符串。
startindex 可选。该整数值指定在 String 对象内开始搜索的索引。若省略该参数，则搜索将从字符串的结尾开始。
备注：lastIndexOf 方法返回一个整数值，指示 String 对象内子字符串的开始位置。如果未找到子字符串，则返回 -1。如果 startindex 为负，则将 startindex 视为零。如果它比最大字符位置索引还大，则将它视为可能的最大索引。从右向左执行搜索。否则，该方法和 indexOf 相同。

15.function link(linkstring : String) : String

返回 String 对象中文本周围带有 HTML 定位点和 HREF 属性的字符串。
备注：调用 link 方法来创建 String 对象外部的超级链接。未进行任何检查来查看此标记是否已应用于该字符串。

16.function localeCompare(stringExp : String) : Number

返回一个值，指示两个字符串在当前区域设置中是否相等。
参数：stringExp 必选。要与当前字符串对象进行比较的字符串。
备注：localeCompare 对当前字符串对象和 stringExp 进行区分区域设置的字符串比较，并返回 -1、0 或 +1，这取决于系统中默认的区域设置的排序顺序。如果当前字符串对象排在 stringExp 之前，则 localeCompare 返回 -1；如果当前字符串排在 stringExp 之后，则返回 +1。如果返回值为零，则说明这两个字符串是相等的。

17.function match(rgExp : RegExp) : Array

使用正则表达式模式对字符串执行搜索，并返回一个包含该搜索结果的数组。
参数：rgExp 必选。包含正则表达式模式和适用标志的 Regular Expression 对象的实例。也可以是包含正则表达式模式和标志的变量名或字符串。
备注：如果 match 方法没有找到匹配，将返回 null。如果找到匹配，则 match 方法返回一个数组，并将更新全局 RegExp 对象的属性以反映匹配结果。
match 方法返回的数组有三个属性：input、index 和 lastIndex。Input 属性包含整个被搜索的字符串。Index 属性包含了在整个被搜索字符串中匹配的子字符串的位置。LastIndex 属性包含了前一次匹配中最后一个字符的下一个位置。
如果没有设置全局标志 (g)，数组的零元素包含整个匹配，而第 1 到第 n 个元素包含了匹配中曾出现过的任一个子匹配。此行为与没有设置全局标志的 exec 方法的行为相同。如果设置了全局标志，则元素 0 到 n 中包含所有出现的匹配。

18.function replace(rgExp : RegExp, replaceText : String) : String

返回一个字符串的副本，该字符串的文本已被使用正则表达式或搜索字符串替换。
参数：rgExp 必选。Regular Expression 对象的实例包含正则表达式模式和适用标志。也可以是 String 对象或文本。如果 rgExp 不是 Regular Expression 对象的实例，它将被转换为字符串，并对结果进行精确的搜索；字符串将不会被试图转化为正则表达式。
replaceText 必选。一个 String 对象或字符串文本，包含用于替换当前字符串对象中 rgExp 的每个成功匹配的文本。在 Jscript 5.5 或更高版本中，replaceText 参数也可是返回替换文本的函数。
备注：在完成指定的替换之后，replace 方法的结果是当前字符串对象的副本。下面任意的匹配变量都可用于识别最新的匹配及匹配字符串。在需要动态确定替换字符串的文本替换中可以使用匹配变量。

字符	含义
$$	$（JScript 5.5 或更高版本）
$&	指定当前字符串对象中与整个模式相匹配的部分。（JScript 5.5 或更高版本）
$`	指定当前字符串对象中位于 $& 所描述的匹配前面的部分。（JScript 5.5 或更高版本）
$'	指定当前字符串对象中位于 $& 所描述的匹配后面的部分。（JScript 5.5 或更高版本）
$n	第 n 个捕获到的子匹配，这里 n 为从 1 到 9 的十进制一位数。（JScript 5.5 或更高版本）
$nn	第 nn 个捕获到的子匹配，这里 nn 为从 01 到 99 的十进制二位数。（JScript 5.5 或更高版本）

如果 replaceText 是一个函数，对于每个匹配的子字符串，调用该函数时带有下面的 m + 3 个参数，这里 m 是在 rgExp 中用于捕获的左括弧的个数。第一个参数是匹配的子字符串。接下来的 m 个参数是搜索中捕获到的全部结果。参数 m + 2 是当前字符串对象中发生匹配位置的偏移量，而参数 m + 3 是当前字符串对象。结果为将每一匹配的子字符串替换为函数调用的相应返回值后的字符串值。Replace 方法更新全局 RegExp 对象的属性。

19.function search(rgExp : RegExp) : Number

返回正则表达式搜索中第一个子字符串匹配项的位置。
参数：rgExp 必选。Regular Expression 对象的实例包含正则表达式模式和适用标志。
备注：search 方法表示是否找到了匹配项。如果找到一个匹配项，则 search 方法将返回一个整数值，该值指示发生匹配处距字符串开头的偏移量。如果没有找到匹配项，则返回 -1。

20.function slice(start : Number [, end : Number]) : String

返回字符串的片段。
参数：start 必选。指向字符串指定部分的开头的索引。 end 可选。指向字符串指定部分的结尾的索引。
备注：slice 方法返回一个包含字符串指定部分的 String 对象。
slice 方法一直复制到 end 所指示的元素，但是不包括该元素。如果 start 为负，则将其视为 length + start，此处 length 为字符串的长度。如果 end 为负，则将其视为 length + end，此处 length 为字符串的长度。如果省略 end，则将一直提取到字符串的结尾。如果 end 出现在 start 之前，则不会将任何字符复制到新字符串中。

21.function small() : String

返回 String 对象中文本周围带有 HTML <SMALL> 标记的字符串。
备注：未进行任何检查来查看此标记是否已应用于该字符串。

22.function split([ separator : { String | RegExp } [, limit : Number]]) : Array

返回一个字符串拆分为若干子字符串时所产生的字符串数组。
参数：separator 可选。字符串或正则表达式对象的实例，它标识用于分隔字符串的一个或多个字符。如果忽略该参数，将返回包含整个字符串的单元素数组。
limit 可选。一个用于限制数组中返回的元素数的值。
备注：split 方法的结果是在字符串中出现 separator 的每个位置分隔字符串后产生的字符串数组。separator 将不作为任何数组元素的一部分返回。

23.function strike() : String

返回 String 对象中文本周围带有 HTML <STRIKE> 标记的字符串。
备注： 未进行任何检查来查看此标记是否已应用于该字符串。

24.function sub() : String

返回 String 对象中文本周围带有 HTML <SUB> 标记的字符串。
备注：未进行任何检查来查看此标记是否已应用于该字符串。

25.function substr(start : Number [, length : Number]) : String

返回一个从指定位置开始，并具有指定长度的子字符串。
参数：start 必选。所需的子字符串的起始位置。字符串中第一个字符的索引为 0。
length 可选。返回的子字符串中包含的字符数。
备注：如果 length 为 0 或负数，将返回一个空字符串。如果没有指定该参数，则子字符串将延续到字符串的结尾。

26.function substring(start : Number, end : Number) : String

返回位于 String 对象中的指定位置的子字符串。
参数：start 必选。从 0 开始的索引整数，指示子字符串的起始位置。
end 必选。从 0 开始的索引整数，指示子字符串的结束位置。
备注：substring 方法将返回一个字符串，该字符串包含从 start 直到 end（不包含 end）的子字符串。substring 方法使用 start 和 end 两者中的较小值作为子字符串的起始点。例如，strvar.substring(0, 3) 和 strvar.substring(3, 0) 将返回相同的子字符串。如果 start 或 end 为 NaN 或负数，那么它将被替换为 0。子字符串的长度等于 start 和 end 之差的绝对值。例如，在 strvar.substring(0, 3) 和 strvar.substring(3, 0) 中，返回的子字符串的长度为 3。

27.function sup() : String

返回 String 对象中文本周围带有 HTML <SUP> 标记的字符串。
备注：未进行任何检查来查看此标记是否已应用于该字符串。

28.function tolocaleLowerCase() : String

返回一个字符串，其中所有的字母都被转换为小写，同时考虑到宿主环境的当前区域设置。
备注：toLocaleLowerCase 方法转换字符串中的字符，同时考虑到宿主环境的当前区域设置。在大多数情况下，其结果与利用 toLowerCase 方法所得到的结果相同。如果语言规则与常规的 Unicode 大小写映射冲突，则结果将会不同。

29.function tolocaleUpperCase() : String

返回一个字符串，其中所有字母都被转换为大写，同时考虑宿主环境的当前区域设置。
备注：toLocaleUpperCase 方法转换字符串中的字符，同时考虑到宿主环境的当前区域设置。在大多数情况下，其结果与使用 toUpperCase 方法所得到的结果相同。如果语言规则与常规的 Unicode 大小写映射冲突，则结果将会不同。

30.function toLowerCase() : String

返回一个字符串，该字符串中的所有字母都被转换为小写字母。
备注：toLowerCase 方法对非字母字符无效。

31.function toString( [radix : Number] ) : String

返回表示对象的字符串。
参数：radix 可选。为将数字值转换为字符串指定一个基数。此值仅用于数字
备注：toString 方法是一个所有内置的 JScript 对象的成员。它的行为取决于对象的类型：

对象	行为
数组	将 Array 的元素转换为字符串。结果字符串被连接起来，用逗号分隔。
布尔型	如果布尔值是 true，则返回“真”。否则，返回“假”。
日期	返回日期的文本表示。
错误	返回一个包含相关错误信息的字符串。
函数	返回如下格式的字符串，其中 functionname 是一个函数的名称，此函数的 toString 方法被调用： "function functionname() { [native code] }"
数字	返回数字的文字表示。
字符串	返回 String 对象的值。
默认	返回“[object objectname]”，其中 objectname 是对象类型的名称。

32.function toUpperCase() : String

返回一个字符串，该字符串中的所有字母都被转换为大写字母。
备注：toUpperCase 方法对非字母字符无效。

33.function valueOf() : Object

返回指定对象的原始值。
备注：每个内部 JScript 对象的 valueOf 方法被以不同方式定义。

对象	返回值
数组	数组元素被转换为字符串，这些字符串被连接在一起，用逗号分隔。这与 Array.toString 和 Array.join 方法作用相同。
布尔型	布尔值。
日期	以毫秒数存储的时间值，从 UTC 1970 年 1 月 1 日午夜开始计算。
函数	函数本身。
数字	数字值。
对象	对象本身。这是默认设置。
字符串	字符串值。

Math 和 Error 对象都没有 valueOf 方法。

http://www.w3school.com.cn/js/jsref_obj_string.asp

        //javascript1.5 firefox已实现
        quote:function () {
            var c, i, l = this.length, o = '"';
            for (i = 0; i < l; i += 1) {
                c = this.charAt(i);
                if (c >= ' ') {
                    if (c === '\\' || c === '"') {
                        o += '\\';
                    }
                    o += c;
                } else {
                    switch (c) {
                        case '\b':
                            o += '\\b';
                            break;
                        case '\f':
                            o += '\\f';
                            break;
                        case '\n':
                            o += '\\n';
                            break;
                        case '\r':
                            o += '\\r';
                            break;
                        case '\t':
                            o += '\\t';
                            break;
                        default:
                            c = c.charCodeAt();
                            o += '\\u00' + Math.floor(c / 16).toString(16) +
                            (c % 16).toString(16);
                    }
                }
            }
            return o + '"';
        },

var meta = {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '"' : '\\"',
    '\\': '\\\\'
};
String.prototype. quote = function () {
        return   '"' + this.replace(/[\\\"\x00-\x1f]/g, function (a) {
            var c = meta[a];
            return typeof c === 'string' ? c :
            '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
        }) + '"'
    }

/*
 * $Id: uneval.js,v 0.3 2009/02/26 02:29:58 dankogai Exp dankogai $
 */

if (typeof(this['uneval']) !== 'function') {
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    var protos = [];
    var char2esc = {'\t':'t','\n':'n','\v':'v','\f':'f','\r':'\r',    
                    '\'':'\'','\"':'\"','\\':'\\'};
    var escapeChar = function(c){
        if (c in char2esc) return '\\' + char2esc[c];
        var ord = c.charCodeAt(0);
        return ord < 0x20   ? '\\x0' + ord.toString(16)
        :  ord < 0x7F   ? '\\'   + c
        :  ord < 0x100  ? '\\x'  + ord.toString(16)
        :  ord < 0x1000 ? '\\u0' + ord.toString(16)
        : '\\u'  + ord.toString(16)
    };
    var uneval_asis = function(o){ return o.toString() };
    /* predefine objects where typeof(o) != 'object' */
    var name2uneval = {
        'boolean':uneval_asis,
        'number': uneval_asis,
        'string': function(o){
            return '\''
            + o.toString()
               .replace(/[\x00-\x1F\'\"\\\u007F-\uFFFF]/g, escapeChar)
            + '\''
        },
        'undefined': function(o){ return 'undefined' },
        'function':uneval_asis
    };

    var uneval_default = function(o, np){
        var src = []; // a-ha!
        for (var p in o){
            if (!hasOwnProperty.call(o, p)) continue;
            src[src.length] = uneval(p)  + ':' + uneval(o[p], 1);
        };
        // parens needed to make eval() happy
        return np ? '{' + src.toString() + '}' : '({' + src.toString() + '})';
    };

    uneval_set = function(proto, name, func){
        protos[protos.length] = [ proto, name ];
        name2uneval[name] = func || uneval_default;
    };

    uneval_set(Array, 'array', function(o){
            var src = [];
            for (var i = 0, l = o.length; i < l; i++)
                src[i] = uneval(o[i]);
            return '[' + src.toString() + ']';
        });
    uneval_set(RegExp, 'regexp', uneval_asis);
    uneval_set(Date, 'date', function(o){
            return '(new Date(' + o.valueOf() + '))';
        });
    
    var typeName = function(o){
        // if (o === null) return 'null';
        var t = typeof o;
        if (t != 'object') return t;
        // we have to lenear-search. sigh.
        for (var i = 0, l = protos.length; i < l; i++){
            if (o instanceof  protos[i][0]) return protos[i][1];
        }
        return 'object';
    };
    
    uneval = function(o, np){
        // if (o.toSource) return o.toSource();
        if (o === null) return 'null';
        var func = name2uneval[typeName(o)] || uneval_default;
        return func(o, np);
    }
}

if (typeof(this['clone']) !== 'function') {
    clone = function(o){
        try{
            return eval(uneval(o));
        }catch(e){
            throw(e);
        }
    };
}

 function stringLiteralize( source ) {
        return '"'
            + source
                .replace( /\x5C/g, '\\\\' )
                .replace( /"/g, '\\"' )
                .replace( /\x0A/g, '\\n' )
                .replace( /\x09/g, '\\t' )
                .replace( /\x0D/g, '\\r' )
                // .replace( /\x08/g, '\\b' )
                // .replace( /\x0C/g, '\\f' )
            + '"';
    }