javascript - 正则表达式不匹配部分序列，但匹配完整序列

coder 2024-05-09 原文

我有一些这样的转义 HTML:

&lt;img border=&#039;0&#039; /&gt;

我正在尝试匹配和替换完整的转义序列，例如 ' 但不是部分转义序列，例如 39，因为 39 是实际上不在未转义的字符串中。本质上，每个转义序列都应被视为单个标记。

这是一个 JS 正则表达式。有没有办法排除 & 和 ; 之间的匹配，同时仍然接受包含这两个字符的序列？

期望的结果:

搜索 <img border='0'/> for lt: 不匹配。
搜索 <img border='0'/> 对于 39:不匹配。
搜索 <img border='0'/> 对于 ':匹配。
搜索 <img border='0'/> 对于 border=':匹配。

当前代码:

> var str = '&lt;img border=&#039;0&#039; /&gt;'
> str.replace(/(border)/gi, '|$1|')
'&lt;img |border|=&#039;0&#039; /&gt;'  // ok
> str.replace(/(39)/gi, '|$1|')
'&lt;img border=&#0|39|;0&#0|39|; /&gt;'  // not ok

注意:我无法取消转义然后重新转义以匹配。它必须被转义。

最佳答案

OP 希望 JavaScript 正则表达式匹配并替换转义 HTML 中的字符串，同时处理转义序列(例如 <、' 或 ) 作为单个字符，并且在替换过程中不会对 HTML 字符串进行转义。

这意味着替换

"lt" 与 "<> 中的 "[lt]" 将导致 "<[lt;>(避免在实体内匹配)
"<" 和 "<> 在 "<lt" 中将导致 "[< ;] lt"(匹配实体)
"&l" with "[&l]" in "< <" 将导致 "< [&l ]t"(不匹配部分实体)
"t;" 和 "<> 中的 "[t;]" 将导致 "< ;="">(不匹配部分实体)
"<> 与 "<> 在 "<lt" 中将导致 "[< l]t"(匹配包括实体)
"lt; &l" 与 "[lt; &l]" in "< <" 将导致 "<>(不匹配部分实体)
"t; <" with "[t; <]" in "lt; <" 会导致 "l[t; <]"(匹配包括实体)
"t; <" with "[t; <]" in "lt; <" 会导致 "lt; <"(不匹配部分实体)

使用以下用于捕获转义序列的正则表达式(例如 <、' 或 )，

/&[a-z]+;|&#x[a-f\d]+;|&#\d+;/gi

我们可以使用以下函数作为处理上述大多数情况(#1、#2、#4、#5 和#7)的起点:

function searchAndReplace(searchFor, replacement, str) {
  return str.replace(
    new RegExp(
      prepare(searchFor) + 
      "|(&[a-z]+;|&#x[a-f\\d]+;|&#\\d+;)", // consume entities
      "gi"
    ),
    function(m, entity) {
      return entity || replacement;
    }
  );
}

function prepare(str) {
  return str.replace(/[^\w\s]/g, "\\$&"); //escape regex metachars [1]
}

// [1] from http://eloquentjavascript.net/09_regexp.html#h_Rhu25fogrG

其余情况(#3、#6、#8)涉及搜索字符串末尾的潜在部分转义序列。

一个解决方案是在 searchFor 字符串的末尾检查潜在的部分转义序列，并附加一个相应的否定前瞻 (?!) 以防止匹配有效的转义序列。完整的解决方案(通过一组大约 40 个测试用例)如下所示，并且应该比 .exec() 方法更快且更简单:

function searchAndReplace(searchFor, replacement, str) {
  return str.replace(
    new RegExp(
      prepare(searchFor) + 
      "|(&[a-z]+;|&#x[a-f0-9]+;|&#\\d+;)", 
      "gi"
    ),
    function(m, entity) {
      return entity || replacement;
    }
  );
}

function prepare(str) {
  var add = "";
  if (/&$/.test(str)) {
    add = "(?!#x[a-z\\d]+;|#\\d+;|[a-z]+;)";
  } else if (/&[a-z]+$/i.test(str)) {
    add = "(?![a-z]*;)";
  } else if (/&#$/.test(str)) {
    add = "(?!x[a-f\\d]+;|\\d+;)";
  } else if (/&#x$/.test(str)) {
    add = "(?![a-f\\d]+;)";
  } else if (/&#x[a-f\d]+$/i.test(str)) {
    add = "(?![a-f\\d]*;)";
  }
  return str.replace(/[^\w\s]/g, "\\$&") + add;
}

// test function

function test(searchFor, replacement, str, expected) {
  var result = searchAndReplace(searchFor, replacement, str);
  console.log(
    searchFor +
      ": " +
      (result === expected ? "Passed" : "Failed: " + [expected, result])
  );
}

// test cases

test("lt", "[lt]", "&lt;img border=&#039;0&#039; /&gt;", "&lt;img border=&#039;0&#039; /&gt;");
test("39", "[39]", "&lt;img border=&#039;0&#039; /&gt;", "&lt;img border=&#039;0&#039; /&gt;");
test("&#039;", "[&#039;]", "&lt;img border=&#039;0&#039; /&gt;", "&lt;img border=[&#039;]0[&#039;] /&gt;");
test("border=&#039;", "[border=&#039;]", "&lt;img border=&#039;0&#039; /&gt;", "&lt;img [border=&#039;]0&#039; /&gt;");
test("39&", "[39&]", "39&lt;img border=39&#039;&gt&gt&&#039 t; 0&#039;&39; /&gt;", "39&lt;img border=39&#039;&gt&gt&&#039 t; 0&#039;&39; /&gt;")
test("0&#", "[0&#]", "39&lt;img border=39&#039;&gt&gt&&#039 t; 0&#039;&39; /&gt;", "39&lt;img border=39&#039;&gt&gt&&#039 t; 0&#039;&39; /&gt;")
test("lt", "[]", "&lt&lt;t;t&l", "&[]&lt;t;t&l");
test("&lt;", "[]", "&lt&lt;t;t&l", "&lt[]t;t&l");
test("&l", "[]", "&lt&lt;t;t&l", "[]t&lt;t;t[]");
test("t;", "[]", "&lt&lt;t;t&l", "&lt&lt;[]t&l");
test("t&", "[]", "&lt&lt;t;t&l", "&lt&lt;t;[]l");
test("&lt;t", "[]", "&lt&lt;t;t&l", "&lt[];t&l");
test("t&lt;", "[]", "&lt&lt;t;t&l", "&l[]t;t&l");
test("t;t", "[]", "&lt&lt;t;t&l", "&lt&lt;[]&l");
test("t&l", "[]", "&lt&lt;t;t&l", "&lt&lt;t;[]");
test("39", "[]", "&#039&#039;9;9&#", "&#0[]&#039;9;9&#");
test("&#039;", "[]", "&#039&#039;9;9&#", "&#039[]9;9&#");
test("&", "[]", "&#039&#039;9;9&#", "[]#039&#039;9;9[]#");
test("&#", "[]", "&#039&#039;9;9&#", "[]039&#039;9;9[]");
test("9;", "[]", "&#039&#039;9;9&#", "&#039&#039;[]9&#");
test("9&", "[]", "&#039&#039;9;9&#", "&#039&#039;9;[]#");
test("&#039;9", "[]", "&#039&#039;9;9&#", "&#039[];9&#");
test("9&#039;", "[]", "&#039&#039;9;9&#", "&#03[]9;9&#");
test("9;9", "[]", "&#039&#039;9;9&#", "&#039&#039;[]&#");
test("9&#", "[]", "&#039&#039;9;9&#", "&#039&#039;9;[]");
test("x7", "[]", "&#x7f&#x7f;f;f&#x", "&#[]f&#x7f;f;f&#x");
test("&#x7f;", "[]", "&#x7f&#x7f;f;f&#x", "&#x7f[]f;f&#x");
test("&", "[]", "&#x7f&#x7f;f;f&#x", "[]#x7f&#x7f;f;f[]#x");
test("&#", "[]", "&#x7f&#x7f;f;f&#x", "[]x7f&#x7f;f;f[]x");
test("&#x", "[]", "&#x7f&#x7f;f;f&#x", "[]7f&#x7f;f;f[]");
test("&#x7", "[]", "&#x7f&#x7f;f;f&#x", "[]f&#x7f;f;f&#x");
test("f;", "[]", "&#x7f&#x7f;f;f&#x", "&#x7f&#x7f;[]f&#x");
test("f&", "[]", "&#x7f&#x7f;f;f&#x", "&#x7f&#x7f;f;[]#x");
test("&#x7f;f", "[]", "&#x7f&#x7f;f;f&#x", "&#x7f[];f&#x");
test("f&#x7f;", "[]", "&#x7f&#x7f;f;f&#x", "&#x7[]f;f&#x");
test("f;f", "[]", "&#x7f&#x7f;f;f&#x", "&#x7f&#x7f;[]&#x");
test("f&#", "[]", "&#x7f&#x7f;f;f&#x", "&#x7f&#x7f;f;[]x");
test("f&#x", "[]", "&#x7f&#x7f;f;f&#x", "&#x7f&#x7f;f;[]");
test("t; &lt; lt &l", "[]", "&lt; &lt; lt &lt;lt; &lt; lt &lt", "&lt; &lt; lt &lt;l[]t");

关于javascript - 正则表达式不匹配部分序列，但匹配完整序列，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43416876/

javascript 匹配 amp 34 code regex

有关javascript - 正则表达式不匹配部分序列，但匹配完整序列的更多相关文章

ruby 正则表达式 - 如何替换字符串中匹配项的第 n 个实例 - 2
在我的应用程序中，我需要能够找到所有数字子字符串，然后扫描每个子字符串，找到第一个匹配范围(例如5到15之间)的子字符串，并将该实例替换为另一个字符串“X”。我的测试字符串s="1foo100bar10gee1"我的初始模式是1个或多个数字的任何字符串，例如，re=Regexp.new(/\d+/)matches=s.scan(re)给出["1","100","10","1"]如果我想用“X”替换第N个匹配项，并且只替换第N个匹配项，我该怎么做？例如，如果我想替换第三个匹配项“10”(匹配项[2])，我不能只说s[matches[2]]="X"因为它做了两次替换“1fooX0barXg
ruby - 匹配未转义的平衡定界符对 - 2
如何匹配未被反斜杠转义的平衡定界符对(其本身未被反斜杠转义)(无需考虑嵌套)？例如对于反引号，我试过了，但是转义的反引号没有像转义那样工作。regex=/(?!$1:"how\\"#expected"how\\`are"上面的正则表达式不考虑由反斜杠转义并位于反引号前面的反斜杠，但我愿意考虑。StackOverflow如何做到这一点？这样做的目的并不复杂。我有文档文本，其中包括内联代码的反引号，就像StackOverflow一样，我想在HTML文件中显示它，内联代码用一些spanMaterial装饰。不会有嵌套，但转义反引号或转义反斜杠可能出现在任何地方。
ruby - 匹配大写字母并用后续字母填充，直到一定的字符串长度 - 2
我有一个驼峰式字符串，例如:JustAString。我想按照以下规则形成长度为4的字符串:抓取所有大写字母；如果超过4个大写字母，只保留前4个；如果少于4个大写字母，则将最后大写字母后的字母大写并添加字母，直到长度变为4。以下是可能发生的3种情况:ThisIsMyString将产生TIMS(大写字母)；ThisIsOneVeryLongString将产生TIOV(前4个大写字母)；MyString将生成MSTR(大写字母+tr大写)。我设法用这个片段解决了前两种情况:str.scan(/[A-Z]/).first(4).join但是，我不太确定如何最好地修改上面的代码片段以处理最后一种
ruby - 是否有用于序列化和反序列化各种格式的对象层次结构的模式？ - 2
给定一个复杂的对象层次结构，幸运的是它不包含循环引用，我如何实现支持各种格式的序列化？我不是来讨论实际实现的。相反，我正在寻找可能会派上用场的设计模式提示。更准确地说:我正在使用Ruby，我想解析XML和JSON数据以构建复杂的对象层次结构。此外，应该可以将该层次结构序列化为JSON、XML和可能的HTML。我可以为此使用Builder模式吗？在任何提到的情况下，我都有某种结构化数据-无论是在内存中还是文本中-我想用它来构建其他东西。我认为将序列化逻辑与实际业务逻辑分开会很好，这样我以后就可以轻松支持多种XML格式。最佳答案我最
ruby-on-rails - Rails 3，嵌套资源，没有路由匹配 [PUT] - 2
我真的为这个而疯狂。我一直在搜索答案并尝试我找到的所有内容，包括相关问题和stackoverflow上的答案，但仍然无法正常工作。我正在使用嵌套资源，但无法使表单正常工作。我总是遇到错误，例如没有路线匹配[PUT]"/galleries/1/photos"表格在这里:/galleries/1/photos/1/edit路线.rbresources:galleriesdoresources:photosendresources:galleriesresources:photos照片Controller.rbdefnew@gallery=Gallery.find(params[:galle
ruby - rbenv 安装 ruby 校验和不匹配 osx - 2
我已经在mountainlion上成功安装了rbenv和rubybuild。运行rbenvinstall1.9.3-p392结束于:校验和不匹配:ruby-1.9.3-p392.tar.gz(文件已损坏)预期f689a7b61379f83cbbed3c7077d83859，得到1cfc2ff433dbe80f8ff1a9dba2fd5636它正在下载的文件看起来没问题，如果我使用curl手动下载文件，我会得到同样不正确的校验和。有没有人遇到过这个？他们是如何解决的？最佳答案 tl:博士；使用浏览器从http://ftp.rub
ruby - 正则表达式将非英文字母匹配为非单词字符 - 2
@raw_array[i]=~/[\W]/非常简单的正则表达式。当我用一些非拉丁字母(具体来说是俄语)尝试时，条件是错误的。我能用它做什么？最佳答案 @raw_array[i]=~/[\p{L}]/使用西里尔字符进行测试。引用:http://www.regular-expressions.info/unicode.html#prop 关于ruby-正则表达式将非英文字母匹配为非单词字符，我们在StackOverflow上找到一个类似的问题： https://
微信小程序通过字典表匹配对应数据 - 2
前言一般来说，前端根据后台返回code码展示对应内容只需要在前台判断code值展示对应的内容即可，但要是匹配的code码比较多或者多个页面用到时，为了便于后期维护，后台就会使用字典表让前端匹配，下面我将在微信小程序中通过wxs的方法实现这个操作。为什么要使用wxs？{{method(a,b)}}可以看到，上述代码是一个调用方法传值的操作，在vue中很常见，多用于数据之间的转换，但由于微信小程序诸多限制的原因，你并不能优雅的这样操作，可能有人会说，为什么不用if判断实现呢？但是if判断的局限性在于如果存在数据量过大时，大量重复性操作和if判断会让你的代码显得异常冗余。wxswxs相当于是一个独立
ruby - 正则表达式在哪个位置失败？ - 2
我需要一个非常简单的字符串验证器来显示第一个符号与所需格式不对应的位置。我想使用正则表达式，但在这种情况下，我必须找到与表达式相对应的字符串停止的位置，但我找不到可以做到这一点的方法。(这一定是一种相当简单的方法……也许没有？)例如，如果我有正则表达式:/^Q+E+R+$/带字符串:"QQQQEEE2ER"期望的结果应该是7 最佳答案一个想法:你可以做的是标记你的模式并用可选的嵌套捕获组编写它:^(Q+(E+(R+($)?)?)?)?然后你只需要计算你获得的捕获组的数量就可以知道正则表达式引擎在模式中停止的位置，你可以确定匹配结束
ruby - 有没有办法从 ruby case 语句中访问表达式？ - 2
我想从then子句中访问case语句表达式，即food="cheese"casefoodwhen"dip"then"carrotsticks"when"cheese"then"#{expr}crackers"else"mayo"end在这种情况下，expr是食物的当前值(value)。在这种情况下，我知道，我可以简单地访问变量food，但是在某些情况下，该值可能无法再访问(array.shift等)。除了将expr移出到局部变量然后访问它之外，是否有直接访问caseexpr值的方法？罗亚附注我知道这个具体示例很简单，只是一个示例场景。最佳答案

javascript - 正则表达式不匹配部分序列，但匹配完整序列

有关javascript - 正则表达式不匹配部分序列，但匹配完整序列的更多相关文章

随机推荐