/foo(?!bar)/ 表示匹配foo后面不是bar的foo/foo(?<!bar)/ 没有见过
解决方案 »
- 怎么能显示admin.php页的内容
- Fatal error: Call to undefined function curl_init() in D:\wamp\www\bj\qq.php on
- 求一sql 语句
- 疯了,php就一个连接,死活就是不能带参数,带参数就不显示,kao!!
- 怎样判断 主机 是否 支持 pear ??
- 除了要开启GD2以外,还有什么会影响PHP生成图片
- 关于传值的问题?(或许不是传值)大伙帮忙一下
- 怎样得到一个时间戳的当天、当月、当年的起始时间戳?
- help help!!!!关于gd乱码
- 这个路径怎么写啊?
- 如何判断上传的文件是文本文件?
- 关于linux下apache+mysql+php的 安装问题,帮忙看看哪个步骤出错了(无法解析php)
/(?!foo)bar按意思来说应该是匹配前面不是foo的bar吧,那为什么它会与foobar匹配?
/foo(?<!bar)为后置断前,
Assertions An assertion is a test on the characters following or
preceding the current matching point that does not actually
consume any characters. The simple assertions coded as \b,
\B, \A, \Z, \z, ^ and $ are described above. More complicated
assertions are coded as subpatterns. There are two
kinds: those that look ahead of the current position in the
subject string, and those that look behind it. An assertion subpattern is matched in the normal way, except
that it does not cause the current matching position to be
changed. Lookahead assertions start with (?= for positive
assertions and (?! for negative assertions. For example, \w+(?=;) matches a word followed by a semicolon, but does not include
the semicolon in the match, and foo(?!bar) matches any occurrence of "foo" that is not followed by
"bar". Note that the apparently similar pattern (?!foo)bar does not find an occurrence of "bar" that is preceded by
something other than "foo"; it finds any occurrence of "bar"
whatsoever, because the assertion (?!foo) is always TRUE
when the next three characters are "bar". A lookbehind
assertion is needed to achieve this effect. Lookbehind assertions start with (?<= for positive assertions
and (?<! for negative assertions. For example, (?<!foo)bar does find an occurrence of "bar" that is not preceded by
"foo". The contents of a lookbehind assertion are restricted
such that all the strings it matches must have a fixed
length. However, if there are several alternatives, they do
not all have to have the same fixed length. Thus (?<=bullock|donkey) is permitted, but (?<!dogs?|cats?) causes an error at compile time. Branches that match different
length strings are permitted only at the top level of
a lookbehind assertion. This is an extension compared with
Perl 5.005, which requires all branches to match the same
length of string. An assertion such as (?<=ab(c|de)) is not permitted, because its single top-level branch can
match two different lengths, but it is acceptable if rewritten
to use two top-level branches: (?<=abc|abde) The implementation of lookbehind assertions is, for each
alternative, to temporarily move the current position back
by the fixed width and then try to match. If there are
insufficient characters before the current position, the
match is deemed to fail. Lookbehinds in conjunction with
once-only subpatterns can be particularly useful for matching
at the ends of strings; an example is given at the end
of the section on once-only subpatterns. Several assertions (of any sort) may occur in succession.
For example, (?<=\d{3})(?<!999)foo matches "foo" preceded by three digits that are not "999".
Notice that each of the assertions is applied independently
at the same point in the subject string. First there is a
check that the previous three characters are all digits,
then there is a check that the same three characters are not
"999". This pattern does not match "foo" preceded by six
characters, the first of which are digits and the last three
of which are not "999". For example, it doesn't match
"123abcfoo". A pattern to do that is (?<=\d{3}...)(?<!999)foo This time the first assertion looks at the preceding six
characters, checking that the first three are digits, and
then the second assertion checks that the preceding three
characters are not "999". Assertions can be nested in any combination. For example, (?<=(?<!foo)bar)baz matches an occurrence of "baz" that is preceded by "bar"
which in turn is not preceded by "foo", while (?<=\d{3}(?!999)...)foo is another pattern which matches "foo" preceded by three
digits and any three characters that are not "999". Assertion subpatterns are not capturing subpatterns, and may
not be repeated, because it makes no sense to assert the
same thing several times. If any kind of assertion contains
capturing subpatterns within it, these are counted for the
purposes of numbering the capturing subpatterns in the whole
pattern. However, substring capturing is carried out only
for positive assertions, because it does not make sense for
negative assertions. Assertions count towards the maximum of 200 parenthesized
subpatterns.