JS 字符串操作本质 +正则表达式
字符串操作的真相:
var a = "s";
a.toLocaleUpperCase();
alert(a); //s
调用 转换大写函数, 结果 a的值并没有发生变化.
var a = "s";
var b = a;
b = b.toLocaleUpperCase();
alert("a="+a); //s
alert("b=" + b); //S
这个时候 b的值,却发生了变化.
总结: javascript对于字符串的复制和传递操作,仅是简单的采用 引用的方法,操作对象为堆区字符串的地址,
但是,一旦要编辑字符串本身的值,则javascript就会 把堆区的字符串读取到栈区进行独立操作. 操作完毕,如果要把
结果赋值给原变量(b = b.toLocaleUpperCase() ),javascript就会把字符串写会堆区,但不覆盖原值所在的区域,而是新开辟一个区域进去存储.
并把新空间的地址传递给栈区,等待javascript垃圾回收,而原来变量的值并没有变化.
字符串是如何进行比较的:
var a = "s";
var b = "s";
alert(a === b); //true
虽然 a和b存储的字符串引用地址不同,但是他们相同,这说明比较操作时,是使用值得方法进行比较的;
先把 两个变量的字符串读取到栈区,然后进行逐字节比较,然后返回结果.
字符串的加密和解密
escape() //使用转义序列替换某些字符串进行编码
unescape() //解码
encodeURI //通过转义某些字符对URI进行编码
decodeURI //解码
正则表达式在js中:
5. 全部符号解释
字符
描述
\
将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。
^
匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
$
匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
*
匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+
匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?
匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}
n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}
n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}
m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
?
当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
.
匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
(pattern)
匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '\(' 或 '\)'。
(?:pattern)
匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)
正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)
负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x|y
匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]
字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz]
负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
[a-z]
字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z]
负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
\b
匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B
匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\cx
匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
\d
匹配一个数字字符。等价于 [0-9]。
\D
匹配一个非数字字符。等价于 [^0-9]。
\f
匹配一个换页符。等价于 \x0c 和 \cL。
\n
匹配一个换行符。等价于 \x0a 和 \cJ。
\r
匹配一个回车符。等价于 \x0d 和 \cM。
\s
匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S
匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t
匹配一个制表符。等价于 \x09 和 \cI。
\v
匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w
匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W
匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
\xn
匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。正则表达式中可以使用 ASCII 编码。.
\num
匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。
\n
标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm
标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml
如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un
匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。
例子:
var r = /go{0,1}gle/g; //ggle gogle
var r=/[0-9a-zA-Z] // \w替换[0-9a-zA-Z]
贪婪匹配
( ? {m,n} {n}这些重复类)具有弱 贪婪性
var s = "<html><head>";
var r = /<.{4,9}>/;
alert(s.match(r)); //<html>
var r = /<.{4,10}>/;
alert(s.match(r)); //<html>,<head>
总是匹配 重复次数最多的.
( * + {n,} )这些具有强贪婪性:
var s = "<html><head></head><a>";
var r = /(<.*>)(<.*>)/;
alert(s.match(r)[1] + "\n" + s.match(r)[2]);
只给右值留一个匹配项.
惰性匹配:
它将查看 字符串中得第一个字符是否匹配,如果条件不够,就读入下一个字符.
var s = "<html><head></head><a>";
var r = /<.*?>/; // 惰性匹配 只需 在重复类后面加? 即可
alert(s.match(r));
下面看一下 重复类的惰性匹配 情况:
{n,m}? 尽量匹配n次,但是为了满足匹配条件,也可能最多 重复m次
?? 尽量匹配,最多匹配一次, 等价于{0,1}?
+? 尽量匹配一次,为了满足条件,可以匹配任意次 等价于{1,}?
*? 尽量不匹配,为了满足条件,可以匹配任意次 等价于 {0,}?
高级匹配模式:
分组:
例1
var s = "<html><head></head><a>";
var r = /(<.*?>)/g; //分组写法 小括号表示一个独立的逻辑域,其匹配内容独立存储.
var a = s.match(r);
for (var i in a) {
alert(a[i]);
}
例2:
var s = "asda";
var r = /a(sd)?/g;
for (var i in s.match(r)) {
alert(s.match(r)[i]); // asd 和 a
}
例3:
var s = "ab=21,ac=23";
var r = /(\w+)=(\d*)/;
var re = s.match(r);
例4:后部可以引用前面的子表达式
var s = "<h1>asd<h1><a>333<a>";
var r = /(<\/?\w+>).*\1/g; // \1表示第一个括号内的表达式
var re = s.match(r);
注意: 对正则表达式 前面 子表达式的引用,所指的不是那个子表达式的模式,而是与那个模式 相匹配的文本.
引用:
在正在表达式执行匹配运算时,表达式计算会自动把每个分组匹配的文本存储在一个特殊的地方,
这些存储在分组中得特殊值,都被称之为 反相引用.
例1:
var s = "asdefg";
var r = /(\w)(\w)/;
r.test(s);
使用 RegExp$+数字 访问反向引用的值
例2:
在定义分组的表达式中包含反向引用.可以通过转义序列(/1/2)来实现.
var s = "asdefg";
var r = /(\w)(\w)\1\1\1\1\1\1\1\1\1\1\1\1\1/;
r.test(s); //false
非引用型分组: 提高匹配速度,节省系统资源
正则表达式分组 会占用一定的系统资源,因为要存储 反向引用.很多时候使用分组是为了
设置 操作单元,为不是为了使用引用,这时候 就要用到 非引用型分组了.
var s = "asdefg";
var n = "123";
var r = /(?:\w*?)|(?:\d*?)/; //左括号 加上 ?: 就是 非引用型 分组
选择:
var s = "asdefg";
var n = "123";
var r = /\w+|\d+/;
边界:
var s = "<html><head></head></html>";
var r = /^(?:<\/?\w+>)/; //<html>
var r = /(?:<\/?\w+>)$/; //</html>
var s = "asd asd asd a a";
var r = /\b(?:.+?)\b/g; // \b匹配退格,而不是边界
alert(s.match(r));
标志:
i : 执行大小写不敏感的匹配
g: 执行全局匹配,即 找到所有匹配,而不是在找到第一匹配就停止
m: 执行多行匹配,
例子1:
var s = "asd\nasd\nasd\nab";
var r = /^\w{1}/g; //a 默认是 单行匹配
alert(s.match(r));
var r = /\w{1}$/g;
alert(s.match(r)); //b
例子2: 多行匹配
var s = "asd\nasd\nasd\nab";
var r = /^\w{1}/gm; //a,a,a,a
alert(s.match(r));
var r = /\w{1}$/gm;
alert(s.match(r)); //d,d,d,b
