String 对象

作为函数调用 String 构造器

 当将 String 作为函数调用，而不是作为构造器，它执行一个类型转换。

String ( [ value ] )

 返回一个由 ToString(value) 计算出的字符串值（不是 String 对象）。如果没有提供 value，返回空字符串 ""。

String 构造器

 当 String 作为一个 new 表达式的一部分被调用，它是个构造器：它初始化新创建的对象。

new String ( [ value ] )

 新构造对象的 [[Prototype]] 内部属性设定为标准内置的字符串原型对象，它是 String.prototype 的初始值 (15.5.3.1)。

 新构造对象的 [[Class]] 内部属性设定为 "String"。

 新构造对象的 [[Extensible]] 内部属性设定为 true。

 新构造对象的 [[PrimitiveValue]] 内部属性设定为 ToString(value)，或如果没提供 value 则设定为空字符串。

String 构造器的属性

 String 构造器的 [[Prototype]] 内部属性的值是标准内置的函数原型对象 (15.3.4).

 除了内部属性和 length 属性（值为 1）之外，String 构造器还有以下属性：

String.prototype

 String.prototype 的初始值是标准内置的字符串原型对象 (15.5.4)。

 这个属性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

String.fromCharCode ( [ char0 [ , char1 [ , … ] ] ] )

 返回一个字符串值，包含的字符数与参数数目相同。每个参数指定返回字符串中的一个字符，也就是说第一个参数第一个字符，以此类推（从左到右）。一个参数转换为一个字符，通过先应用 ToUint16 (9.7) 操作，再将返回的 16 位整数看作字符的代码单元值。如果没提供参数，返回空字符串。

 fromCharCode 函数的 length 属性是 1。

字符串原型对象的属性

 字符串原型对象本身是一个值为空字符串的 String 对象（它的 [[Class]] 是 "String"）。

 字符串原型对象的 [[Prototype]] 内部属性值是标准内置的 Object 原型对象 (15.2.4)。

String.prototype.constructor

 String.prototype.constructor 的初始值是内置 String 构造器。

String.prototype.toString ( )

 返回 this 字符串值。（注，对于一个 String 对象，toString 方法和 valueOf 方法返回相同值。）

 toString 函数是非通用的 ; 如果它的 this 值不是一个字符串或字符串对象，则抛出一个 TypeError 异常。因此它不能作为方法转移到其他类型对象上。

String.prototype.valueOf ( )

 返回 this 字符串值。

 valueOf 函数是非通用的 ; 如果它的 this 值不是一个字符串或字符串对象，则抛出一个 TypeError 异常。因此它不能作为方法转移到其他类型对象上。

String.prototype.charAt (pos)

 将 this 对象转换为一个字符串，返回包含了这个字符串 pos 位置的字符的字符串。如果那个位置没有字符，返回空字符串。返回结果是个字符串值，不是字符串对象。

 如果 pos 是一个数字类型的整数值，则 x.charAt( pos) 与 x.substring( pos, pos+1) 的结果相等。

 当用一个参数 pos 调用 charAt 方法，采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 position 为 ToInteger(pos).
4. 令 size 为 S 的字符数 .
5. 如果 position < 0 或 position ≥ size, 返回空字符串 .
6. 返回一个长度为 1 的字符串 , 它包含 S 中 position 位置的一个字符 , 在这里 S 中的第一个（最左边）字符被当作是在位置 0，下一个字符被当作是在位置 1，等等 .

 charAt 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.charCodeAt (pos)

 将 this 对象转换为一个字符串，返回一个代表这个字符串 pos 位置字符的代码单元值的数字（小于 216 的非负整数）。如果那个位置没有字符，返回 NaN。

 当用一个参数 pos 调用 charCodeAt 方法，采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 position 为 ToInteger(pos).
4. 令 size 为 S 的字符数 .
5. 如果 position < 0 或 position ≥ size, 返回 NaN.
6. 返回一个数字类型值，值是字符串 S 中 position 位置字符的代码单元值。 在这里 S 中的第一个（最左边）字符被当作是在位置 0，下一个字符被当作是在位置 1，等等 .

 charCodeAt 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.concat ( [ string1 [ , string2 [ , … ] ] ] )

 当用一个或更多参数 string1, string2, 等等 , 调用 concat 方法 , 它返回一个包含了 --this 对象（转换为一个字符串）中的字符们和后面跟着的每个 string1, string2, 等等，（每个参数都转换为字符串）里的字符们 -- 的字符串。返回结果是一个字符串值，不是一个字符串对象。采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 args 为一个内部列表，它是传给这个函数的参数列表的拷贝 .
4. 令 R 为 S.
5. 只要 args 不是空，就重复删除 args 的第一个元素，并令 next 为这个元素 .令 R 为包含了 -- 之前的 R 值中的字符们和后面跟着的 ToString(next) 结果的字符们 -- 的字符串值。
6. 返回 R.

 concat 方法的 length 属性是 1.

 concat 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.indexOf (searchString, position)

 将 this 对象转换为一个字符串，如果 searchString 在这个字符串里大于或等于 position 的位置中的一个或多个位置使它呈现为字符串的子串，那么返回这些位置中最小的索引；否则返回 -1。如果 position 是 undefined，就认为它是 0，以搜索整个字符串。

 indexOf 需要两个参数 searchString 和 position，执行以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 searchStr 为 ToString(searchString).
4. 令 pos 为 ToInteger(position). ( 如果 position 是 undefined, 此步骤产生 0).
5. 令 len 为 S 的字符数 .
6. 令 start 为 min(max(pos, 0), len).
7. 令 searchLen 为 SearchStr 的字符数 .
8. 返回 一个不小于 start 的可能的最小值整数 k，使得 k+searchLen 不大于 len，并且对所有小于 searchLen 的非负数整数 j，S 的 k+j 位置字符和 searchStr 的 j 位置字符相同；但如果没有这样的整数 k，则返回 -1。

 indexOf 的 length 属性是 1。

 indexOf 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.lastIndexOf (searchString, position)

 将 this 对象转换为一个字符串，如果 searchString 在这个字符串里小于或等于 position 的位置中的一个或多个位置使它呈现为字符串的子串，那么返回这些位置中最大的索引；否则返回 -1。如果 position 是 undefined，就认为它是字符串值的长度，以搜索整个字符串。

 lastIndexOf 需要两个参数 searchString 和 position，执行以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 searchStr 为 ToString(searchString).
4. 令 numPos 为 Tonumber(position). ( 如果 position 是 undefined, 此步骤产生 NaN).
5. 如果 numPos 是 NaN, 令 pos 为 +∞; 否则 , 令 pos 为 ToInteger(numPos).
6. 令 len 为 S 的字符数 .
7. 令 start 为 min(max(pos, 0), len).
8. 令 searchLen 为 SearchStr 的字符数 .
9. 返回 一个不大于 start 的可能的最大值整数 k，使得 k+searchLen 不大于 len，并且对所有小于 searchLen 的非负数整数 j，S 的 k+j 位置字符和 searchStr 的 j 位置字符相同；但如果没有这样的整数 k，则返回 -1。

 lastIndexOf 的 length 属性是 1。

 lastIndexOf 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.localeCompare (that)

 当以一个参数 that 来调用 localeCompare 方法，它返回一个非 NaN 数字值，这个数字值反应了对 this 值（转换为字符串）和 that 值（转换为字符串）进行语言环境敏感的字符串比较的结果。两个字符串 S 和 That 用实现定义的一种方式进行比较。比较结果是为了按照系统默认语言环境指定的排列顺序来排列字符串，根据按照排列顺序 S 是在 That 前面，相同，还是 S 在 That 后面，结果分别是负数，零，正数。

 在执行比较之前执行以下步骤以预备好字符串：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 That 为 ToString(that).

 如果将 localeCompare 方法看做是将 this 和 that 作为两个参数的函数，那么它是在所有字符串集合上的保持一致的比较函数（在 15.4.4.11 定义）。

 实际返回值是实现定义的，允许实现者们在返回值里编码附加信息。但是函数需要定义一个在所有字符串上的总的顺序，并且，当比较的字符串们被认为是 Unicode 标准定义的标准等价，则返回 0。

 如果宿主环境没有在所有字符串上语言敏感的比较，此函数可执行按位比较。

 localeCompare 方法自身不适合直接作为 Array.prototype.sort 的参数，因为后者需要的是两个参数的函数。

 这个函数的目的是在宿主环境中任何依靠语言敏感的比较方式都可用于 ECMAScript 环境，并根据宿主环境当前语言环境设置的规则进行比较。强烈建议这个函数将 -- 根据 Unicode 标准的标准等价的 -- 字符串当做是相同的（也就是说，要比较的字符串仿佛是都先被转换为正常化形式 C 或正常化形式 D 了）。还建议这个函数不履行 Unicode 相容等价或分解。

 本标准的未来版本可能会使用这个函数的第二个参数；建议实现不将这个参数位用作其他用途。

 localeCompare 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.match (regexp)

 当以 regexp 作为参数调用 match 方法，采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 如果 Type(regexp) 是 Object 并且 regexp 的 [[Class]] 内部属性的值是 "RegExp", 则令 rx 为 regexp;
4. 否则 , 令 rx 为 仿佛是用表达式 new RegExp( regexp) 创建的新正则对象，这里的 RegExp 是标准内置构造器名。
5. 令 global 为 以 "global" 为参数调用 rx 的 [[Get]] 内部方法的结果 .
6. 令 exec 为 标准内置函数 RegExp.prototype.exec ( 见 15.10.6.2)
7. 如果 global 不是 true, 则以 rx 作为 this 值，用包含 S 的参数列表调用 exec 的 [[Call]] 内部方法，返回结果。
8. 否则 , global 是 true以 "lastIndex" 和 0 作为参数调用 rx 的 [[Put]] 内部方法。令 A 为 仿佛是用表达式 new Array() 创建的新数组，这里的 Array 是标准内置构造器名 .令 previousLastIndex 为 0.令 n 为 0.令 lastMatch 为 true.只要 lastMatch 是 true，就重复令 result 为 以 rx 作为 this 值，用包含 S 的参数列表调用 exec 的 [[Call]] 内部方法的结果。如果 result 是 null, 则设定 lastMatch 为 false.否则 , result 不是 null令 thisIndex 为 以 "lastIndex" 为参数调用 rx 的 [[Get]] 内部方法的结果。如果 thisIndex = previousLastIndex 则以 "lastIndex" 和 thisIndex+1 为参数调用 rx 的 [[Put]] 内部方法。设定 previousLastIndex 为 thisIndex+1.否则 , 设定 previousLastIndex 为 thisIndex.令 matchStr 为 以 0 为参数调用 result 的 [[Get]] 内部方法的结果。以 ToString(n), 属性描述符 {[[Value]]: matchStr, [[Writable]]: true, [[Enumerable]]: true, [[configurable]]: true}, 和 false 作为参数调用 A 的 [[DefineOwnProperty]] 内部方法。n 递增 1.如果 n = 0, 则返回 null.返回 A.

 match 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.replace (searchValue, replaceValue)

 首先根据以下步骤设定 string：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 string 为 以 this 值作为为参数调用 ToString 的结果。

 如果 searchValue 是一个正则表达式（[[Class]] 内部属性是 "RegExp" 的对象），按照如下执行：如果 searchValue.global 是 false，则搜索 string，找出匹配正则表达式 searchValue 的第一个子字符串。如果 searchValue.global 是 true，则搜索 string，找出匹配正则表达式 searchValue 的所有子字符串。搜索的做法与 String.prototype.match 相同，包括对 searchValue.lastIndex 的更新。令 m 为 searchValue 的左捕获括号的个数（使用 15.10.2.1 指定的 NcapturingParens）。

 如果 searchValue 不是正则表达式，令 searchString 为 ToString(searchValue)，并搜索 string，找出第一个出现的 searchString 的子字符串。令 m 为 0。

 如果 replaceValue 是函数，则对每个匹配的子字符串，以 m + 3 个参数调用这个函数。第一个参数是匹配的子字符串。如果 searchValue 是正则表达式，接下来 m 个参数是 MatchResult（见 15.10.2.1）里的所有捕获值。第 m + 2 个参数是发生的匹配在 string 里的偏移量，第 m + 3 个参数是 string。结果是将输入的原字符串里的每个匹配子字符串替换为相应函数调用的返回值（必要的情况下转换为字符串）得到的字符串。

 否则，令 newstring 表示 replaceValue 转换为字符串的结果。结果是将输入的原字符串里的每个匹配子字符串替换为 -- 将 newstring 里的字符替换为表 22 指定的替代文本得到的字符串 -- 得到的字符串。替换这些 $ 是由左到右进行的，并且一旦执行了这样的替换，新替换的文本不受进一步替换。例如 ，"$1,$2".replace(/(\$(\d))/g, "$$1-$1$2") 返回 "$1-$11,$1-$22"。newstring 里的一个 $ ，如果不符合以下任何格式，就保持原状。

replace 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.search (regexp)

 当用参数 regexp 调用 search 方法，采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 string 为 以 this 值作为参数调用 ToString 的结果。
3. 如果 Type(regexp) 是 Object 且 regexp 的 [[Class]] 内部属性的值是 "RegExp", 则令 rx 为 regexp;
4. 否则 , 令 rx 为仿佛是用表达式 new RegExp( regexp) 创建的新正则对象，这里的 RegExp 是标准内置构造器名。
5. 从 string 开始位置搜索正则表达式模式 rx 的匹配。如果找到匹配，令 result 为匹配在 string 里的偏移量；如果没有找到匹配，令 result 为 -1。执行搜索时 regexp 的 lastIndex 和 global 属性是被忽略的。regexp 的 lastIndex 属性保持不变。
6. 返回 result.

 search 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.slice (start, end)

 slice 方法需要两个参数 start 和 end，将 this 对象转换为一个字符串，返回这个字符串中从 start 位置的字符到（但不包含）end 位置的字符的一个子字符串（或如果 end 是 undefined，就直接到字符串尾部）。用 sourceLength 表示字符串长度，如果 start 是负数，就把它看做是 sourceLength+start；如果 end 是负数，就把它看做是 sourceLength+end。返回结果是一个字符串值，不是字符串对象。采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 len 为 S 的字符数 .
4. 令 intStart 为 ToInteger(start).
5. 如果 end 是 undefined, 令 intEnd 为 len; 否则 令 intEnd 为 ToInteger(end).
6. 如果 intStart 是 negative, 令 from 为 max(len + intStart,0); 否则 令 from 为 min(intStart,len).
7. 如果 intEnd 是 negative, 令 to 为 max(len +intEnd,0); 否则 令 to 为 min(intEnd, len).
8. 令 span 为 max(to – from,0).
9. 返回 一个包含 --S 中从 form 位置的字符开始的 span 个连续字符 -- 的字符串。

 slice 方法的 length 属性是 2。

 slice 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.split (separator, limit)

 将 this 字符串转换为一个字符串，返回一个数组对象，里面存储了这个字符串的子字符串。子字符串是从左到右搜索 separator 的匹配来确定的；这些匹配结果不成为返回数组的任何子字符串元素，但被用来分割字符串。separator 的值可以是一个任意长度的字符串，也可以是一个正则对象（即，一个 [[Class]] 内部属性为 "RegExp" 的对象；见 15.10）。

 separator 值可以是一个空字符串，一个空正则表达式，或一个可匹配空字符串的正则表达式。这种情况下，separator 不匹配输入字符串开头和末尾的空的子串，也不匹配分隔符的之前匹配结果末尾的空字串。（例如，如果 separator 是空字符串，要将字符串分割为单个字符们；结果数组的长度等于字符串长度，且每个字串都包含一个字符。）如果 separator 是正则表达式，在 this 字符串的给定位置中只考虑首次匹配结果，即使如果在这个位置上回溯可产生一个非空的子串。（例如，"ab".split(/a*?/) 的执行结果是数组 ["a","b"]，而 "ab".split(/a*/) 的执行结果是数组 ["","b"] 。）

 如果 this 对象是（或转换成）空字符串，返回的结果取决于 separator 是否可匹配空字符串。如果可以，结果是不包含任何元素的数组。否则，结果是包含一个空字符串元素的数组。

 如果 separator 是包含捕获括号的正则表达式，则对 separator 的每次匹配，捕获括号的结果 ( 包括 undefined) 都拼接为输出数组。例如，

 执行结果是数组：

 如果 separator 是 undefined，则返回结果是只包含 this 值（转换为字符串）一个字符串元素的数组。如果 limit 不是 undefined，则输出数组被切断为包含不大于 limit 个元素。

 当调用 split 方法，采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 A 为 仿佛使用表达式 new Array() 创建的新对象，这里的 Array 是标准内置构造器名 .
4. 令 lengthA 为 0.
5. 如果 limit 是 undefined, 令 lim = 232–1; 否则 令 lim = ToUint32(limit).
6. 令 s 为 S 的字符数 .
7. 令 p = 0.
8. 如果 separator 是正则对象 ( 它的 [[Class]] 是 "RegExp"), 令 R = separator; 否则，令 R = ToString(separator).
9. 如果 lim = 0, 返回 A.
10. 如果 separator 是 undefined, 则以 "0", 属性描述符 {[[Value]]: S, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作为参数调用 A 的 [[DefineOwnProperty]] 内部方法。返回 A.
11. 如果 s = 0, 则调用 SplitMatch(S, 0, R) 并 令 z 为 它的 MatchResult 结果 .如果 z 不是 failure, 返回 A.以 "0", 属性描述符 {[[Value]]: S, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作为参数调用 A 的 [[DefineOwnProperty]] 内部方法。返回 A.
12. 令 q = p.
13. 只要 q ≠ s，就重复调用 SplitMatch(S, q, R) 并 令 z 为 它的 MatchResult 结果 .如果 z 是 failure, 则 令 q = q+1.否则 , z 不是 failurez 必定是一个 State. 令 e 为 z 的 endIndex 并 令 cap 为 z 的 captures 数组 .如果 e = p, 则 令 q = q+1.否则 , e ≠ p令 T 为一个字符串，它的值等于包含 -- 在 S 中从 p（包括它）位置到 q（不包括）位置的字符 -- 的子字符串的值。以 ToString(lengthA), 属性描述符 {[[Value]]: T, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作为参数调用 A 的 [[DefineOwnProperty]] 内部方法 .lengthA 递增 1.如果 lengthA = lim, 返回 A.令 p = e.令 i = 0.只要 i 不等于 cap 中的元素个数，就重复 .令 i = i+1.以 ToString(lengthA), 属性描述符 {[[Value]]: cap[i], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作为参数调用 A 的 [[DefineOwnProperty]] 内部方法。lengthA 递增 1.如果 lengthA = lim, 返回 A.令 q = p.
14. 令 T 为 为一个字符串，它的值等于包含 -- 在 S 中从 p（包括它）位置到 q（不包括）位置的字符 -- 的子字符串的值。
15. 以 ToString(lengthA), 属性描述符 {[[Value]]: T, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作为参数调用 A 的 [[DefineOwnProperty]] 内部方法。
16. 返回 A.

 SplitMatch 抽象操作需要三个参数，字符串 S，整数 q，字符串或正则对象 R，按照以下顺序执行并返回一个 MatchResult（见 15.10.2.1）：

1. 如果 R 是个正则对象 ( 它的 [[Class]] 是 "RegExp"), 则以 S 和 q 作为参数调用 R 的 [[Match]] 内部方法，并返回 MatchResult 的结果。
2. 否则，Type(R) 必定是 String. 令 r 为 R 的字符数 .
3. 令 s 为 S 的字符数 .
4. 如果 q+r > s 则返回 MatchResult failure.
5. 如果存在一个在 0（包括）到 r（不包括）之间的整数 i，使得 S 的 q+i 位置上的字符和 R 的 i 位置上的字符不同，则返回 failure。
6. 令 cap 为 captures 的空数组 ( 见 15.10.2.1).
7. 返回 State 数据结构 (q+r, cap). ( 见 15.10.2.1)

 split 方法的 length 属性是 2.

 分隔符是正则对象时，split 方法忽略 separator.global 的值。

 split 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.substring (start, end)

 substring 方法需要两个参数 start 和 end，将 this 对象转换为一个字符串，返回包含 -- 在转换结果字符串中从 start 位置字符一直到（但不包括）end 位置的字符（或如果 end 是 undefined，就到字符串末尾）-- 的一个子串。返回结果是字符串值，不是字符串对象。

 如果任一参数是 NaN 或负数，它被零取代；如果任一参数大于字符串长度，它被字符串长度取代。

 如果 start 大于 end，交换它们的值。

 采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 len 为 S 的字符数 .
4. 令 intStart 为 ToInteger(start).
5. 如果 end 是 undefined, 令 intEnd 为 len; 否则 令 intEnd 为 ToInteger(end).
6. 令 finalStart 为 min(max(intStart, 0), len).
7. 令 finalEnd 为 min(max(intEnd, 0), len).
8. 令 from 为 min(finalStart, finalEnd).
9. 令 to 为 max(finalStart, finalEnd).
10. 返回 一个长度是 to - from 的字符串，它包含 S 中从索引值 form 到 to-1（按照索引升序）的所有字符。

 substring 方法的 length 属性是 2。

 substring 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.toLowerCase ( )

 采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 L 为一个字符串，L 的每个字符是 S 中相应字符的 Unicode 小写等量，或者（如果没有 Unicode 小写等量存在）是实际的 S 中相应字符值。
4. 返回 L.

 为了此操作，字符串的 16 位代码单元被看作是 Unicode 基本多文种平面（Basic Multilingual Plane）中的代码点。代理代码点直接从 S 转移到 L，不做任何映射。

 返回结果必须是根据 Unicode 字符数据库里的大小写映射得到的（对此数据库明确规定，不仅包括 UnicodeData.txt 文件，而且还包括 Unicode 2.1.8 和更高版本里附带的 SpecialCasings.txt 文件）。

 某些字符的大小写映射可产生多个字符。这种情况下结果字符串与原字符串的长度未必相等。因为 toUpperCase 和 toLowerCase 都有上下文敏感的行为，所以这俩函数不是对称的。也就是说，s.toUpperCase().toLowerCase() 不一定等于 s.toLowerCase()。

 toLowerCase 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.toLocaleLowerCase ( )

 此函数产生依照 -- 宿主环境的当前语言设置 -- 更正的结果，而不是独立于语言环境的结果，除此之外它的运作方式与 toLowerCase 完全一样。只有在少数情况下有一个区别（如，土耳其语），就是那个语言和正规 Unicode 大小写映射有冲突时的规则。

 此函数的第一个参数可能会用于本标准的未来版本 ; 建议实现不以任何用途使用这个参数位置。

 toLocaleLowerCase 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.toUpperCase ( )

 此函数的将字符映射到在 Unicode 字符数据库中与其等值的大写字符，除此之外此函数的行为采用与 String.prototype.toLowerCase 完全相同的方式。

 toUpperCase 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.toLocaleUpperCase ( )

 此函数产生依照 -- 宿主环境的当前语言设置 -- 更正的结果，而不是独立于语言环境的结果，除此之外它的运作方式与 toUpperCase 完全一样。只有在少数情况下有一个区别（如，土耳其语），就是那个语言和正规 Unicode 大小写映射有冲突时的规则。

 此函数的第一个参数可能会用于本标准的未来版本 ; 建议实现不以任何用途使用这个参数位置。

 toLocaleUpperCase 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String.prototype.trim ( )

 采用以下步骤：

1. 以 this 值作为参数调用 CheckObjectCoercible。
2. 令 S 为以 this 值作为参数调用 ToString 的结果 .
3. 令 T 为一个字符串值，它是 S 的一个拷贝，并删除了开头和结尾中空白的。空白的定义是 WhiteSpace 和 LineTerminato r 的并集。
4. 返回 T.

 trim 函数被有意设计成通用的；它不要求它的 this 值是字符串对象。因此，他可以当做方法转移到其他类型对象。

String 实例的属性

 字符串实例从字符串原型对象继承属性，字符串实例的 [[Class]] 内部属性值是 "String"。字符串实例还有 [[PrimitiveValue]] 内部属性，length 属性，和一组属性名是数组索引的可遍历属性。

 [[PrimitiveValue]] 内部属性是代表这个字符串对象的字符串值。以数组索引命名的属性对应字符串值里的单字符。一个特殊的 [[GetOwnProperty]] 内部方法用来为数组索引命名的属性指定数字，值，和特性。

length

 在代表这个字符串对象的字符串值里的字符数。

 一旦创建了一个字符串对象，这个属性是不可变的。它有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

[[GetOwnProperty]] ( P )

 数组对象使用一个，用在其他原生 ECMAscript 对象的 [[GetOwnProperty]] 内部方法 (8.12.1) 的变化版。这个特殊内部方法用来给命名属性添加访问器，对应到字符串对象的单字符。

 设 S 为一个字符串对象，P 为一个字符串。

 当以属性名 P 调用 S 的 [[GetOwnProperty]] 内部方法，采用以下步骤：

1. 令 desc 为 以 P 为参数调用 S 的默认 [[GetOwnProperty]] 内部方法 (8.12.1) 的结果。
2. 如果 desc 不是 undefined，返回 desc.
3. 如果 ToString(abs(ToInteger(P))) 与 P 的值不同 , 返回 undefined.
4. 令 str 为 S 的 [[PrimitiveValue]] 内部属性字符串值。
5. 令 index 为 ToInteger(P).
6. 令 len 为 str 里的字符数 .
7. 如果 len ≤ index, 返回 undefined.
8. 令 resultStr 为一个长度为 1 的字符串 , 里面包含 str 中 index 位置的一个字符 , 在这里 str 中的第一个（最左边）字符被认为是在位置 0，下一个字符在位置 1，依此类推。
9. 返回一个属性描述符 { [[Value]]: resultStr, [[Enumerable]]: true, [[Writable]]: false, [[Configurable]]: false }