zh.json

{
    "'{0}' found at index {1}": "在下标 {1} 找到 '{0}'",
    "(except for line terminators)": "(除了换行)",
    "{1} Alternative": "{1} 选择分支",
    "{1} always fails to match": "{1} 总是无法匹配",
    "{1} always finds a zero-length match": "{1} 总是找到一个长度为0的匹配",
    "{1} and {2} are also available with the use of '{3}'": "{1} 和 {2} 也同样可用于 '{3}'",
    "{1} and {2} match start/end of line": "{1} 和 {2} 匹配行首/行尾",
    "{1} can be used to match the same text the third preceding capture group matched and captured.": "{1} 可匹配与第三捕获组已匹配并捕获内容相同的字符串。",
    "{1} Capturing Group": "{1} 捕获组",
    "{1} char": "{1} 字符",
    "{1} chars": "{1} 字符",
    "{1} is a line separator which can stand for {2}, {3}, {4}, or {5}.": "{1} 是一个换行分隔符，可以代表 {2}, {3}, {4}, 或者 {5}。",
    "{1} is a paragraph separator (PS) character.": "{1} 是一个分段符。",
    "{1} is NEL, next line character.": "{1} 是一个新行符(NEL，next line character)。",
    "{1} line break": "{1} 换行符",
    "{1} line breaks": "{1} 换行符",
    "{1} match": "{1} 次匹配",
    "{1} matches": "{1} 次匹配",
    "{1} matches only end of pattern": "{1} 仅匹配模式结尾",
    "{1} modifier:": "{1} 模式：",
    "{1} or {2}": "{1} 或 {2}",
    "{1} step": "{1} 步",
    "{1} steps": "{1} 步",
    "{1} subpattern": "{1} 子匹配式",
    "{1} test failed": "{1} 测试失败",
    "{1} tests failed": "{1} 多个测试失败",
    "{1} upvotes, {2} downvotes (score {3}%)": "{1} 票赞成，{2} 票反对（支持率 {3}%）",
    "{1} user(s) (including you) have a score of {2}, better than {3}% of submissions": "有 {1} 位用户（包括你）的得分为 {2}，胜过 {3}% 的提交",
    "{1} user(s) have a score of {2}, better than {3}% of submissions": "{1} 位用户的得分为 {2} ，胜过 {3}% 的提交",
    "{1} would be the second previous capture group, for example. {2} would be the third capture group.": "例如，{1} 将是之前的第二个捕获组。{2} 将是第三个捕获组。",
    "{1}. A {2} followed by a letter with no special meaning is faulted": "{1}. {2} 之后跟着一个没有特殊意义的字母是错误的",
    "{1}. A dot won't match {2}": "{1}. 一个点（.）不会匹配 {2}",
    "{1}. All capturing groups {2} are instead treated as if they were non-capturing groups {3}.": "{1} 。所有捕获分组 {2} 都会被视为非捕获分组 {3} 。",
    "{1}. All line terminators are recognized in the behavior of {3}, {4}, and {5}.": "{1}。所有行终止符均在 {3}、{4} 和 {5} 的行为中被识别。",
    "{1}. All matches (don't return after first match)": "{1} 。查找所有匹配 (而不是仅返回第一个匹配)",
    "{1}. Apply case insensitive matching to unicode characters in accordance with the unicode standard": "{1}。 根据 Unicode 标准对 Unicode 字符应用不区分大小写匹配",
    "{1}. Capturing groups {2} are no longer treated as if they were non-capturing groups {3}.": "{1}。捕获组 {2} 不再被视为非捕获组 {3}。",
    "{1}. Case insensitive match (ignores case of {2})": "{1}。大小写不敏感（忽略 {2} 的大小写）",
    "{1}. Case insensitive matching is only applied to the US-ASCII character set": "{1}。不区分大小写匹配仅适用于 US-ASCII 字符集",
    "{1}. Case sensitive match": "{1}。区分大小写匹配",
    "{1}. Causes {2} and {3} to match begin/end of string": "{1}。使 {2} 和 {3} 匹配字符串的首/尾",
    "{1}. Causes {2} and {3} to match the begin/end of each line (not only begin/end of string)": "{1}。使 {2} 和 {3} 匹配每行的首/尾（不仅是整个字符串的首/尾）",
    "{1}. Dot matches newline characters": "{1} 。点号匹配换行符",
    "{1}. Enable all unicode and additional character class set features. This is an extension of the existing {2}-flag": "{1}。启用所有 unicode 和其他字符类集功能。这是现有 {2} 标志的扩展",
    "{1}. Enable all unicode features and interpret all unicode escape sequences as such": "{1}. 启用所有 Unicode 特性，并据此解析所有 Unicode 转义符",
    "{1}. Enable matching using an approach that avoids backtracking and guarantees linear-time processing in the length of the input.": "{1}。使用避免回溯并保证输入长度的线性时间处理的方法来启用匹配。",
    "{1}. Enable the built in character classes to also match unicode characters": "{1}. 让内建字符类型也匹配Unicode字符",
    "{1}. Force the a dollar sign, {2}, to always match end of the string, instead of end of the line. This option is ignored if the {3}-flag is set": "{1}。强制美元符号 {2} 始终匹配字符串的末尾，而不是行的末尾。如果设置了 {3} 标志，则忽略此选项",
    "{1}. Force the escape sequences {2}, {3}, {4}, {5}, {6}, {7}, {8} and {9} to perform ASCII-only matching instead of full Unicode matching": "{1}。强制转义序列 {2}、{3}、{4}、{5}、{6}、{7}、{8} 和 {9} 执行仅 ASCII 匹配，而不是完整的 Unicode 匹配",
    "{1}. Force the pattern to only match consecutive matches from where the previous match ended.": "{1}. 强制模式只匹配从上一个匹配结束的地方开始的连续匹配。",
    "{1}. Make {2}, {3}, {4}, {5}, {6}, {7}, {8} and {9} perform matching with Unicode semantic (redundant in Python 3)": "{1}。使 {2}、{3}、{4}、{5}、{6}、{7}、{8} 和 {9} 执行与 Unicode 语义的匹配（在 Python 3 中是多余的）",
    "{1}. Only the {2} line terminator is recognized in the behavior of {3}, {4}, and {5}.": "{1}。 {3}、{4} 和 {5} 的行为中仅识别 {2} 行终止符。",
    "{1}. Pattern strings are treated as {2}. Also causes escape sequences to match unicode characters": "{1}. 模式字符串被视为{2}。还会使转义序列与Unicode字符相匹配",
    "{1}. Spaces and text after a {2} in the pattern are ignored": "{1}. 表达式中的空白字符和 {2} 及其后的内容都会被忽略",
    "{1}. Spaces and text after a {2} in the pattern are ignored (even whitespace inside character classes)": "{1}. 忽略 {2} 后面的空白和字符(包括字符中的空格)",
    "{1}. The .NET regex engine now now performs matches from right to left, instead of left ro right.": "{1} 。.NET 正则引擎现在从右到左执行匹配，而不是从左到右。",
    "{1}. The JavaScript regex engine now returns the indices at which the regex matched in the subject string.": "{1}.JavaScript正则引擎如今将在字符串被正则表达式匹配的地方返回索引。",
    "{1}. The match becomes greedy by default": "{1}. 默认情况下会以贪婪匹配",
    "{1}. The match becomes lazy by default. Now a {2} following a quantifier makes it greedy": "{1}. 匹配在默认情况下是惰性的。现在，量词后的{2}会使它贪婪",
    "{1}. The pattern is forced to become anchored at the start of the search, or at the position of the last successful match, equivalent to a {2}": "{1}。该模式被迫锚定在搜索开始处或最后一次成功匹配的位置，相当于 {2}",
    "{1}. Whitespaces and {2} in the pattern are treated literally": "{1}。模式中的空格和 {2} 按字面意思处理",
    "`(?R1)` checks if a call to capture group 1 was made, which will return false the first time it is encountered because the regex engine is simply parsing capture group one.": "`(?R1)`将检查分组1是否成功捕获。一开始正则引擎正在分析捕获组1，故返回false()，匹配竖线后子表达式。",
    "3 or more of a": "三个a以上",
    "A case insensitive match is performed, meaning capital letters will be matched by non-capital letters and vice versa.": "大小写字母的表达式将相互匹配。",
    "A character except: a, b or c": "非a或b或c的字符",
    "A character in the range: a-z": "在a到z范围内的小写英语字母字符",
    "A character in the range: a-z or A-Z": "在a到z或A到Z范围内的大小写英语字母字符",
    "A character not in the range: a-z": "在a到z范围外的字符",
    "A common misconception is that repeating a capture group would create separate IDs for each time it matches. If that functionality is needed, one has to rely on the global (/g) flag instead. For example: {1}": "有种普遍的误解，认为重复一个捕获组会在其每次匹配时产生不同的ID。若需达到该效果，应使用全局修饰符 (/g)。 例如：{1}",
    "a line": "一行",
    "A lookbehind assertion has to be fixed width": "后视断言必须为固定长度",
    "A non-capturing group allows you to apply quantifiers to part of your regex but does not capture/assign an ID.": "非捕获分组可以让你对部分表达式进行分组的同时，而不会捕获内容和分配编号。",
    "A posix character class may only appear inside a character class": "一个posix字符类只能出现在一个字符类中",
    "A quantifier inside a lookbehind makes it non-fixed width": "后视中的量词使其长度不固定",
    "A quote without content has ambiguous behavior and should be avoided": "不包含内容的引用表意不明，应避免使用",
    "A repeated capturing group will only capture the last iteration. Put a capturing group around the repeated group to capture all iterations or use a non-capturing group instead if you're not interested in the data": "重复捕获组将仅捕获最后一次迭代。在重复组周围放置一个捕获组以捕获所有迭代，或者如果您对获取匹配内容不感兴趣，则使用非捕获组",
    "A single character of: a, b or c": "单个a或b或c字符",
    "A single character of: a, b, c or d": "单个字符A、b、c或d",
    "A special thanks goes out to the following individuals for their hard work and contributions to the quiz:": "特别感谢以下人员对测验的辛勤劳动和贡献：",
    "A subpattern name must be unique": "子表达式的赋名必须唯一",
    "A word boundary": "单词边界",
    "Absolute end of string": "文本最末尾",
    "Account": "账号",
    "Account Page": "账号页",
    "acts like {1}, except that if the pattern is unanchored, the bumpalong advance is not to the next character, but to the position in the subject where {2} was encountered": "行为类似于 {1}，但如果模式未锚定，则凹凸前进不是到下一个字符，而是到主题中遇到 {2} 的位置",
    "Add bold text": "加粗",
    "Add bulleted list": "添加无序列表",
    "Add header": "添加头部",
    "Add italic text": "添加斜体文本",
    "Add numbered list": "添加数字列表",
    "Add Regex to the Community Pattern Library": "将正则表达式添加到社区库",
    "Add tag": "添加标签",
    "Add test": "添加测试",
    "Add to Community Library": "添加到社区库",
    "Add to favorites": "添加到收藏",
    "Adjust the threshold at which the left sidebar will collapse and hide. If the viewport is smaller than the set width, it is hidden, otherwise visible.": "调整左侧的侧边栏折叠、隐藏的宽度值。如果窗口小于设定的宽度，侧边栏会被隐藏，反之将正常展示。",
    "Adjust the threshold at which the right sidebar will collapse and hide. If the viewport is smaller than the set width, it is hidden, otherwise visible.": "调整右侧的侧边栏折叠、隐藏的宽度值。如果窗口小于设定的宽度，侧边栏会被隐藏，反之将正常展示。",
    "After Match": "下文匹配",
    "After you have finished a task you can continue improving upon your solution, making it shorter, and climb higher into the leader boards.": "完成一项任务后，你可以继续改进解决方案、缩短其长度，从而提升天梯排行。",
    "All associated data with your account will be permanently deleted, such as your saved expressions, your library entries, and your quiz progression.": "与您的账户相关的所有数据，例如保存的正则表达式、正则库和测验进度，将被永久删除。",
    "All available": "全部可用",
    "All capturing groups {1} are instead treated as if they were non-capturing groups {2}.": "所有捕获组 {1} 将会被视为非捕获组 {2} 。",
    "All tests passed": "所有测试均已通过",
    "All the errors detected are listed below, from left to right, as they appear in the pattern.": "全部检测到的错误如下所示，从左到右，按照他们出现在表达式里的顺序展示。",
    "All Tokens": "全部符号",
    "All versions": "所有版本",
    "Allow duplicate subpattern names": "允许子模式重复命名，如：(?<name>N1)(?<name>N2)",
    "Allows case insensitive matching of unicode characters, not only US-ASCII.": "不区分大小写匹配应用于 Unicode 字符，而不仅仅是 US-ASCII 。",
    "Allows regex to match unicode characters via dotall and unicode escape sequences, as well as ES6 unicode code point escapes such as {1} which is made up of {2}.": "允许正则表达式通过 dotall 和 unicode 转义序列以及 ES6 unicode 代码点转义（例如由 {2} 组成的 {1}）来匹配 unicode 字符。",
    "Also known as global mode, it instruct the engine not to stop after the first match has been found, but rather to continue until no more matches can be found.": "这种模式也称为全局模式，它指示引擎在找到第一个匹配结果后不停止，继续运行，直到找不到更多匹配结果为止。",
    "Alternate - match either a or b": "选择 - 匹配 a 或 b",
    "Alternative": "选择分支",
    "Alternative notation for {1}": "{1}的替代符号",
    "Always collapse left sidebar": "总是收起左边栏",
    "Always collapse right sidebar": "总是收起右边栏",
    "An alternate way to match alphabet letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "匹配字母的另一种方法。等同于{1}。双括号不是错的，POSIX 要求。",
    "An alternate way to match any letter or digit. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "匹配字母或者数字的另一种方法。等同于{1}。双括号不是错的，POSIX 要求这么干。",
    "An error occurred while fetching the resource": "获取资源时出错",
    "An error occurred while loading the page, please refresh and try again": "加载页面出错，请刷新重试",
    "An error occurred while trying to load the resource, please refresh and try again": "加载资源出错，请刷新重试",
    "An explanation of your regex will be automatically generated as you type.": "你输入的正则表达式的解释会自动生成在这里。",
    "An unescaped delimiter must be escaped; in most languages with a backslash ({1})": "未转义的分隔符必须被转义；在大多数语言中，使用反斜杠 ({1}) 进行转义",
    "Anchor": "锚定模式",
    "Anchor to start of pattern, or at the end of the most recent match": "锚定到模式的开始处，或最近匹配的结束处",
    "Anchors": "锚点",
    "anonymous": "匿名",
    "Another option is enabling the x flag to allow `# comments` but it will also cause the regex engine to ignore space characters. To match space characters you have to escape them: {1}.": "另一个选项是启用 x 标志以允许“# comments”，但它也会导致正则表达式引擎忽略空格字符。要匹配空格字符，您必须对它们进行转义：{1}。",
    "Any changes to the community entry, both the expression, as well as title/description/etc, can be made at the following url: {1}": "对社区条目（包括表达式以及标题/说明等）的任何更改都可以在以下网址进行：{1}",
    "Any character following a {1} that is not a valid meta sequence will be faulted and raise an error. {2}, for example, will cause an error, and it will not match.": "{1} 后面的任何不是有效元序列的字符都会出错并引发错误。例如，{2} 会导致错误，并且不会匹配。",
    "Any characters between {1} and {2}, including metacharacters, will be treated as literals.": "{1} 和 {2} 之间的任何字符（包括元字符）都将被视为文字。",
    "Any digit": "阿拉伯数字字符",
    "Any non-digit": "非阿拉伯数字字符",
    "Any non-whitespace character": "非空白字符",
    "Any non-word character": "非字母、数字或下划线的字符",
    "Any single character": "任意单个字符",
    "Any text appearing in this group is ignored in the regex.": "正则表达式中将忽略此组中出现的任何文本。",
    "Any Unicode sequences, linebreaks included": "包含换行符在内的 Unicode 字符",
    "Any whitespace character": "任意空白字符",
    "Any word can be used as a tag": "可用于标签的单词",
    "Any word character": "字母、数字或下划线的字符",
    "Appearance": "外观",
    "approximately {1} ms": "约 {1} 毫秒",
    "Are you sure you want to delete this community entry?": "您确定要删除此社区条目吗？",
    "Are you sure you want to delete this regex? This action is non-reversible and will delete all versions of this regex.": "确定要删除这个正则表达式吗？这个操作是不可逆的，并且会删除这个正则表达式的所有版本。",
    "Are you sure you want to delete your account?": "您确定要删除您的帐户吗？",
    "as few times as possible, expanding as needed": "尽可能少匹配，如果有必要，回溯匹配更多内容",
    "as many times as possible, giving back as needed": "尽可能多匹配，如果有必要，回溯匹配更少内容",
    "as many times as possible, without giving back": "尽可能多匹配，不回溯",
    "ASCII codes 0-127": "ASCII编码0-127号字符",
    "ASCII control characters": "ASCII 控制字符",
    "assert position at a word boundary: {1}": "断言位置在字边界：{1}",
    "assert position where {1} does not match": "断言 {1} 不匹配的位置",
    "assert that {1} {2}": "断言 {1} {2}",
    "Assert that the Regex below does not match": "断言内部的表达式不能匹配",
    "Assert that the Regex below matches": "断言内部的表达式可以匹配",
    "asserts position at start of {1}": "断言位于 {1} 的起始位置",
    "asserts position at start of the string": "断言位于字符串的起始位置",
    "asserts position at the end of a line": "断言位于文本行的结束位置",
    "asserts position at the end of the previous match or the start of the string for the first match": "断言位于上一个匹配项的结束位置（对第一次匹配而言，断言位于字符串的开始位置）",
    "asserts position at the end of the string": "断言位于字符串的结束位置",
    "asserts position at the end of the string, or before the line terminator right at the end of the string (if any)": "断言位于字符串的结束位置，或者位于字符串末尾的换行符之前",
    "Asserts that the given subpattern can be matched here, without consuming characters": "断言给定的子模式可以在此处匹配，而不消耗字符",
    "Atomic Group": "原子组",
    "Atomic group (non-capturing)": "固化分组(不捕获)",
    "Author": "作者",
    "Automatic": "自动",
    "Automatic will infer the preferred theme from the host system": "自动将从系统推断出首选主题",
    "Available keyboard shortcuts": "可用快捷键",
    "Avoid using this legacy syntax for any new patterns": "避免将这种遗留语法用于任何新模式",
    "Backreference": "反向引用",
    "Backreferences may not be placed inside character classes. If you meant to create an octal escape, prefix the escape with a 0.": "反向引用不能放在字符类内。如果您要创建八进制转义，请在转义前加上 0。",
    "Backspace": "Backspace",
    "Backspace character": "退格符",
    "Backticks can not be used in a raw string, use {1} instead": "原始字符串中不能使用反引号，请改用 {1}",
    "Bad subpattern name. Ensure it is alpha numeric and does not begin with a digit": "子模式名称错误。请确保它是字母数字且不以数字开头",
    "Balancing Named Capturing Group": "命名捕获型平衡组",
    "Balancing Named Capturing Group {1}": "命名捕获型平衡组 {1}",
    "Balancing Non-capturing Group": "非捕获型平衡组",
    "Because of this, you are now running a local-only (offline) version. You will still be able to use all the base function of the applications like before, but some features that require a connection with the server might not work.": "因此，您现在运行的是本地（离线）版本。您仍然可以像以前一样使用应用程序的所有基本功能，但一些需要与服务器连接的功能可能无法使用。",
    "Because you are not signed in this entry has not been linked to an account. It is recommended you sign in so that your entries are never lost and you can manage them from the account page whenever you like.": "由于您尚未登录，此条目尚未链接到帐户。建议您登录，这样您的条目就不会丢失，并且您可以随时从帐户页面管理它们。",
    "Become a Github Sponsor": "成为 Github 赞助商",
    "Become a sponsor today!": "今天就成为赞助商吧！",
    "Become an Enterprise Sponsor": "成为企业赞助商",
    "Before even attempting a match, the regex engine makes some checks, such as the length of the string. If it is not long enough to fit the pattern, it will automatically return a no match. This optimization can be disabled by using this modifier.": "在开始匹配前，正则引擎会检查一些参数，如文本长度，若不足，则直接返回“无匹配结果”。本标签将禁止该功能。",
    "Before Match": "上文匹配",
    "Between 3 and 6 of a": "3到6个a",
    "Bogus escape: this escape is not recognized in the python flavor": "虚假转义：这个转义在Python风味中不被认可",
    "Branch Reset Group": "组分支",
    "By default, {1} matches any unicode newline character or sequence thereof. Its behavior can be controlled by newline convention verbs like {2} or {3}.": "默认情况下，{1} 匹配任何 unicode 换行符或其序列。其行为可以通过换行符约定动词（如 {2} 或 {3}）控制。",
    "By signing in you also get the ability to enhance your skills and participate in the {1} along with thousands of other regex connoisseurs!": "通过登录，您还可以提升自己的技能，并与数千名其他正则表达式鉴赏家一起参与{1}！",
    "By signing in, all your expressions will be automatically saved to your account, where you have ability to organize and manage them.": "通过登录，您的所有表情将自动保存到您的帐户中，您可以在其中组织和管理它们。",
    "Cancel": "取消",
    "Capture everything enclosed": "匹配并捕获括号中的内容",
    "capture group {1}": "捕获组 {1}",
    "Capture Group {1} is {2} ... and so on": "捕获组{1}是{2}…以此类推",
    "Capture Group {1} is {2} and its start/end positions can be obtained via {3} and {4}": "捕获组{1}是{2}，其开始/结束位置可通过{3}和{4}获得",
    "Carriage return": "回车符",
    "case insensitive": "不区分大小写",
    "Case insensitive": "不区分大小写",
    "Case insensitive match": "不区分大小写",
    "Case insensitive matching affects unicode characters as well": "对 Unicode 字符也进行不区分大小写匹配",
    "Case Modifier": "案例修饰符",
    "case sensitive": "区分大小写",
    "Catastrophic Backtracking": "回溯次数过多",
    "Catastrophic backtracking has been detected and the execution of your expression has been halted. To find out more and what this is, please read the following article:": "检测到灾难性回溯，表达式的执行已停止。要了解更多信息以及这是什么，请阅读以下文章：",
    "Category": "类别",
    "causes a skip to the next innermost alternative if the rest of the pattern does not match": "如果模式的其余部分不匹配，则跳至下一个最内层的替代方案",
    "Causes the regex engine to give up on the current match if it tries to backtrack past {1}'s position. This is useful when looking to cut down on backtracking at specific points in the regex. Equivalent to {2}.": "如果正则表达式引擎尝试回溯到 {1} 的位置，则会导致其放弃当前匹配。这在希望减少正则表达式中特定点的回溯时非常有用。等同于 {2}。",
    "Causes the regex to exit if it tries to backtrack past {1}'s position. This is useful when looking to cut down on backtracking at specific points in the regex. Equivalent to {2}.": "如果正则表达式尝试回溯超过 {1} 的位置，则会导致正则表达式退出。这在希望减少正则表达式中特定点的回溯时很有用。相当于 {2}。",
    "causes the whole match to fail outright if the rest of the pattern does not match": "如果模式的其余部分不匹配，则导致整个匹配彻底失败",
    "causes token to be ignored": "导致元字符被忽略",
    "Change delimiter": "修改分隔符",
    "Character Class": "字符类",
    "Character class intersection": "字符类交集",
    "Character class missing closing bracket": "字符类缺少结尾括号",
    "Character class relative complement": "字符类相对补语",
    "Character class subtraction": "字符类补集",
    "Character Classes": "字符类别",
    "Character range is out of order": "字符范围乱序",
    "Character range with surrogate pairs without unicode enabled results in ambiguous behavior": "未启用 unicode 的代理对的字符范围会导致歧义行为",
    "Checks whether the {1} subroutine matches": "检查 {1} 子程序是否匹配",
    "Checks whether the whole pattern matches": "检查整个模式是否匹配",
    "Class Intersection": "类交叉点",
    "Class modifiers are computed from left to right, and the descriptions below (leading with three dots) must be interpreted with this in mind.": "类修饰符是从左到右计算的，下面的描述（以三个点开头）必须在考虑到这一点的情况下进行解释。",
    "Class Subtraction": "类减法",
    "Class Symmetric Difference": "类对称差分",
    "Clear": "清除",
    "Close": "关闭",
    "Close details": "关闭详情",
    "Code Generator": "代码生成",
    "Collapse all tests": "收起所有测试",
    "Collapse Subtree": "折叠子树",
    "Collapse test": "坍塌试验",
    "Comment": "注释",
    "Comment group": "注释分组",
    "Common Tokens": "常用",
    "Community Entry": "社区入口",
    "Community Library Entry": "社区图书馆入口",
    "Community Moderator": "社区版主",
    "Community Patterns": "社区模式",
    "Complete match contents": "完整匹配内容",
    "Conditional": "条件匹配",
    "Conditional replacement": "有条件更换",
    "Conditional statement": "条件语句",
    "Conditionally matches one of two options depending on whether the {1} capturing group matched": "根据 {1} 捕获组是否匹配，有条件地匹配两个选项之一",
    "Conditionally matches one of two options depending on whether the lookaround matches": "根据环视是否匹配，有条件地匹配两个选项之一",
    "contains": "包含",
    "Contents after match": "匹配项之后的内容",
    "Contents before match": "匹配项之前的内容",
    "Contents in capture group `foo`": "捕获组`foo`内容",
    "Contents in capture group 1": "捕获组1内容",
    "Control": "控制",
    "Control Character": "控制字符",
    "Control character Y": "Y对应Ctrl字符",
    "Control characters": "控制符",
    "Control verb": "控制动作标记",
    "Converts all subsequent tokens to their {1} equivalence until {2} is encountered": "将所有后续标记转换为其 {1} 等价标记，直到遇到 {2}",
    "Converts metacharacters to literal characters, and also allows literal matching of the regex delimiter in use, like `/`.": "将元字符转换为文字字符，并且还允许对正在使用的正则表达式分隔符进行文字匹配，例如“/”。",
    "Converts the subsequent token to their {1} equivalence": "将后续标记转换为其 {1} 等价标记",
    "Copied!": "已复制！",
    "Copy to clipboard": "复制",
    "Current score: {1}": "当前评分：{1}",
    "Dark": "深色",
    "Data": "数据",
    "Debug Test": "调试此测试",
    "Decimal digits": "十进制数字",
    "Decrease speed": "播放速度 -",
    "Decrease step range": "缩小步骤范围",
    "Default code generator language": "代码生成的默认语言",
    "Default flavor": "默认语言风格",
    "Definition": "Definition",
    "Delete": "删除",
    "Delete account": "删除帐户",
    "Delete Account and Data": "删除帐户和数据",
    "Delete community entry": "删除社区条目",
    "Delete Community Entry?": "删除社区条目？",
    "Delete permalink": "删除永久链接",
    "Delete Regex": "删除正则表达式",
    "Delete regular expression": "删除正则表达式",
    "Delete this version": "删除此版本",
    "Delimiters": "分隔符",
    "Description": "说明",
    "Description of regular expression": "正则表达式的描述",
    "Detailed match information will be displayed here automatically.": "匹配详情会自动显示在这里。",
    "Disable all keyboard shortcuts": "禁用所有快捷键",
    "Disable backtracking when matching": "匹配时禁用回溯",
    "Disable read-only mode": "禁用只读模式",
    "Disallow duplicate subpattern names": "子模式名称不允许重复",
    "Disallow meaningless escapes": "禁止模式中的反斜线后面跟上一个没有特殊意义的字母",
    "Disallows backtracking past {1}'s position, and gives up matching the current alternation if there's a failure. If instead {1} is used outside of an alternation, it will act like {3}. Equivalent to {2}.": "不允许回溯到 {1} 的位置，如果失败则放弃匹配当前交替。如果在交替之外使用 {1}，则其作用类似于 {3}。等同于 {2}。",
    "Do note that these tasks do not necessarily promote best practices in real life scenarios, but rather aim to teach you the fundamentals of writing powerful regular expressions.": "请注意，这些任务不一定会促进现实场景中的最佳实践，而是旨在教会你编写强大的正则表达式的基础知识。",
    "does {1} match": "{1}匹配",
    "does match": "匹配",
    "Does not allow the capture group ID to be incremented for all enclosed capture groups.": "不允许为所有封闭的捕获组增加捕获组ID。",
    "Don't return after first match": "匹配全部可匹配结果",
    "Donate": "捐赠",
    "Donate through Paypal": "通过 Paypal 捐款",
    "Donate through Stripe": "通过 Stripe 捐款",
    "Dot matches newline": "单行模式，此模式下.能匹配任意字符，包括换行符",
    "Downvote": "否决",
    "Due to a bug in PCRE creating ranges with an escaped literal is unsafe. To avoid this, simply use the literal representation instead": "由于PCRE中的一个bug，使用转义文本创建范围是不安全的。为了避免这种情况，只需使用字面意思来代替",
    "Due to a bug in Rust this script is unavailable. Try specifying the category to work around this issue.": "由于 Rust 中的错误，此脚本不可用。请尝试指定类别来解决此问题。",
    "Duplicate group names": "重复组名模式",
    "Duplicate/reset subpattern group number": "复制/重置子模式组号",
    "Each successful match will remove the content of the referenced group {1}, allowing for balanced matches to be performed.": "每次成功匹配都会删除引用组 {1} 的内容，从而实现平衡匹配。",
    "Edit account entry": "编辑账户条目",
    "Edit Community Entry": "编辑社区条目",
    "Edit personal title": "编辑个人标题",
    "Edit title and tags": "编辑标题和标签",
    "Editor": "编辑器",
    "Editor and Flavors": "编辑和风味",
    "Else match the following regex": "否则匹配以下正则表达式",
    "empty character class — matches {1}": "空集 —— 必然无匹配",
    "Empty match modifier": "空匹配修饰符",
    "empty string": "空字符串",
    "Enable all unicode and character set features": "启用所有 Unicode 和字符集功能",
    "Enable or disable the syntax highlighting of your regular expression in the editor": "启用/禁用正则表达式的语法高亮",
    "Enable read-only mode": "启用只读模式",
    "Enable unicode support": "开启Unicode支持",
    "Enables unicode support for predefined classes": "启用对预定义类的unicode支持",
    "End of string": "文本末尾",
    "End of word": "单词尾",
    "End quote literals without a corresponding open quote literal {1} match null, and only serve to create visual noise. If you meant to match the literal {2}, remove the backslash.": "没有对应的开引号文字 {1} 的结束引号文字匹配为空，并且只会造成视觉干扰。如果您想要匹配文字 {2}，请删除反斜杠。",
    "End-of-word boundary": "字尾边界",
    "ends with": "结尾为",
    "Engine Error": "引擎错误",
    "Enjoy!": "享受！",
    "Ensures that the given pattern will match, ending at the current position in the expression. The pattern can be of variable width. Does not consume any characters.": "确保给定的模式匹配，结束于表达式中的当前位置。模式的宽度可以变化。不消耗任何字符。",
    "Ensures that the given pattern will match, ending at the current position in the expression. The pattern must have a fixed width. Does not consume any characters.": "断言给定的子表达式在当前位置从右往左可以匹配，表达式必须为固定长度。不消耗字符。",
    "Ensures that the given pattern would not match and end at the current position in the expression. The pattern can be of variable width. Does not consume characters.": "确保给定的模式不会匹配并在表达式中的当前位置结束。模式的宽度可以变化。不消耗字符。",
    "Ensures that the given pattern would not match and end at the current position in the expression. The pattern must have a fixed width. Does not consume characters.": "断言给定的子表达式在当前位置从右往左不能匹配，表达式必须为固定长度。不消耗字符。",
    "Enter your regex and hit submit to see the result.": "输入您的正则表达式，并点击提交以查看结果。",
    "equals": "等于",
    "equivalent to {1}": "相当于{1}",
    "Equivalent to {1}": "相当于{1}",
    "Equivalent to {1}.": "相当于{1}。",
    "Equivalent to boolean OR": "相当于布尔值或",
    "Error": "Error",
    "Error reported by engine: {1}": "引擎错误：{1}",
    "Escape sequences like {1} will also match unicode characters.": "像{1}这样的转义序列也将匹配单码字符。",
    "Exactly 3 of a": "三个a",
    "Expand all tests": "展开所有测试",
    "Expand Subtree": "展开子树",
    "Expand test": "扩展测试",
    "Expected group {1} to contain `{2}` but did not": "预期组{1}包含`{2}`，但未包含",
    "Expected group {1} to end with `{2}` but was instead `{3}`": "预期组 {1} 以 `{2}` 结尾，但实际为 `{3}`",
    "Expected group {1} to equal `{2}` but was instead `{3}`": "预期组 {1} 等于 `{2}`，但实际为 `{3}`",
    "Expected group {1} to start with `{2}` but was instead `{3}`": "预期组 {1} 以“{2}”开头，但却以“{3}”开头",
    "Expected regex to match, but did not.": "预期正则表达式匹配，但无匹配。",
    "Expected regex to not match, but did.": "预期正则表达式不匹配，但存在匹配。",
    "Experimental feature; may be removed in the future.": "实验性功能；将来可能会被删除。",
    "Explanation": "解释",
    "Export Matches": "导出匹配结果",
    "Export Method": "导出方法",
    "eXtra": "eXtra",
    "Favorite Regex": "添加到收藏夹",
    "Feel free to refresh the page and try again later, the offline version will remain available to you.": "请随时刷新页面并稍后重试，离线版本仍可供您使用。",
    "Filter by Flavor": "按风格过滤",
    "Find out what's new!": "了解最新动态！",
    "Flags/Modifiers": "修饰符",
    "Flavor": "语言风格",
    "Flavor Help": "风格帮助",
    "Flavors": "口味",
    "Follow me on twitter!": "在twitter上关注我!",
    "For a full regex reference for {1}, please visit:": "完整{1}正则表达式参考，请访问：",
    "For example, repeating 1-3 digits and a period 3 times can be done like this: {1}": "例如，重复3次的1-3个数字和1个句号，可以这样做：{1}",
    "Force a matching failure at a specific point in the regex. Equivalent to {1}, and a synonym of {2}.": "强制在搜索结果中的某个特定点进行匹配失败。相当于{1}，也是{2}的意思。",
    "Fork Regex": "叉正则表达式",
    "Full Match": "完整匹配",
    "full match": "完整匹配",
    "Full match": "完整匹配",
    "Full Search Result": "全部搜索结果",
    "Function": "Function",
    "General": "通用",
    "General Tokens": "一般",
    "Generated Code": "生成代码",
    "Generating code samples, please wait...": "正在生成代码示例，请等待...",
    "Get help on {1}": "Get help on {1}",
    "Given a regular expression that has capture groups, you may refer to them (by number or name) and perform a conditional replacement.": "给定一个具有捕获组的正则表达式，您可以引用它们（按编号或名称）并执行条件替换。",
    "given the following test string": "给定以下测试字符串",
    "given the string {1} assert that {2} {3} {4}": "给定字符串 {1} 断言 {2} {3} {4}",
    "Global": "全局模式",
    "Global pattern flags": "全局模式标志",
    "Go to beginning": "跳转到开头",
    "Go to community entry": "前往社区入口",
    "Go to end": "跳转到末尾",
    "Go to the beginning": "跳转到开头",
    "Go to the end": "跳转到末尾",
    "Golang/RE2, Python, and Javascript consider {1} to be just vertical tab (ascii {2}).": "Golang/RE2、Python 、Javascript ，把 {1} 视为一个垂直制表符（ascii {2}）。",
    "Golang/RE2, Python, and Javascript equivalent is {1}.": "Golang/RE2、Python 和 Javascript 等效于 {1}。",
    "greedy": "贪婪模式",
    "Greedy quantifier": "贪婪模式",
    "Group": "组",
    "Group {1}": "分组 {1}",
    "Group {1} found at {2}": "在{2}找到组{1}",
    "Group {1} no longer exists in the pattern or did not participate in the match": "模式中组{1}不再存在或未参加匹配",
    "Group {1} was not expected to participate in the match but did anyway": "组{1}预期不会进行匹配，但却匹配了",
    "Group Constructs": "子组结构",
    "group did not participate in match": "分组没有参与匹配",
    "Groups are no longer implicitly capturing": "分组不再是隐式捕获的",
    "Groups have been nested too deeply, consider simplifying your pattern": "组嵌套太深，请考虑简化模式",
    "Groups with the same index must either have the same name or both be non-named groups": "有相同索引的组必须有相同的名称或两者都是非命名组",
    "Half end-of-word boundary": "半字尾边界",
    "Half start-of-word boundary": "半字首边界",
    "Headers": "头",
    "here": "这里",
    "Here comes a {1} tab character.": "这里出现了一个 {1} 制表符。",
    "Hex": "十六进制",
    "Hex character YY": "YY对应Hex字符",
    "Hex character YYYY": "YYYY对应Hex字符",
    "Hex character YYYYYYYY": "十六进制字符 YYYYYYYY",
    "Hex only": "仅限十六进制",
    "Hexadecimal digits": "十六进制数字",
    "Hexadecimal replacement values": "HEX替换值",
    "Highest Score": "最高分",
    "Highlight Syntax": "语法高亮",
    "Horizontal whitespace character": "横向空白字符",
    "If capturing group 1 returned a match, the pattern before the alternate {1} is matched. Otherwise, the pattern after the alternate {1} is matched.": "如果捕获组 1 返回匹配，则匹配替代项 {1} 之前的模式。否则，匹配替代项 {1} 之后的模式。",
    "If condition is met, match the following regex": "如果满足条件，则匹配以下正则表达式",
    "If left to Automatic, the code generator will mirror the currently selected flavor in the editor": "如果设置为自动，代码生成器将在编辑器中镜像当前选定的风格",
    "If recursion of the whole pattern is successful, match the pattern before the {1} otherwise match the pattern after the {1}.": "如果整个模式递归成功，则匹配 {1} 之前的模式，否则匹配 {1} 之后的模式。",
    "If the error persists, and you believe this to be an error with regex101, please open an issue here: {1}": "如果错误仍然存在，并且您认为这是 regex101 的错误，请在此处打开问题：{1}",
    "If the lookahead succeeds, matches the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. The lookaround can be negative also. Global flag breaks conditionals.": "如果前视匹配成功，则匹配竖线前面的表达式，否则匹配竖线后面的表达式。环视可以是否定型的。全局标记会中断条件匹配。",
    "If the lookbehind succeeds, match the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. The lookaround can be negative. Global flag, 'g', breaks conditionals.": "如果后视匹配成功，则匹配竖线前面的表达式，否则匹配竖线后面的表达式。环视可以是否定型的。全局标记会中断条件匹配。",
    "If the referenced subpattern did match, the first text will be inserted, otherwise the second.": "如果引用的子模式匹配，则插入第一个文本，否则插入第二个文本。",
    "If this token is inside a capturing group, only that capturing group is ended successfully at that particular location, while the parent pattern continues to execute.": "当它出现在捕获组内，则组内捕获至该处为止，其余表达式继续匹配。",
    "If you are working on very large and complex expressions, turning this option off will yield improved performance. Note: Only works in supported languages {1}.": "如果您正在处理非常大且复杂的表达式，关闭此选项将提高性能。注意：仅适用于受支持的语言 {1}。",
    "If you encounter any issues, quirky behavior or bugs, please open up an issue on github with all the relevant details": "如果你遇到任何问题、奇怪行为或bug，请在 github 上提交 issue，并提供相关详细信息",
    "If you want to permanently remove the saved data, you can easily do so from here. The delete link will be automatically tied to your account, so you never have to worry about losing it.": "如果您想永久删除已保存的数据，您可以在此处轻松完成。删除链接将自动绑定到您的帐户，因此您永远不必担心丢失它。",
    "If you're running an ad blocker, consider whitelisting regex101 to support the website.": "如果你正在使用广告拦截器，请考虑将 regex101 列入白名单以支持本站。",
    "Ignore all whitespace / verbose": "忽略所有空格/冗长",
    "Ignore whitespace": "忽略空白字符，可以多行书写，并使用#进行注释说明",
    "Ignore whitespace / verbose": "忽略空白 / 注释模式",
    "In PCRE a recursion test {1}, group name {2}, or a relative position {3} can be used as the conditional. Global flag breaks conditionals as the engine does a second pass over an already matched/consumed string.": "在 PCRE 中，递归测试 {1}、组名 {2} 或相对位置 {3} 可用作条件。全局标志会中断条件，因为引擎会对已匹配/使用的字符串进行第二次遍历。",
    "In the example below, the first alternate matched \"a\", and the second one matched \"bc\", however once it bumped into \"X\" none of the alternatives resulted in a match. Therefore the engine cannot return the next \"a\" as a match because \"X\" is not the last location where a match occurred.": "范例中，相邻的a和bc分别被匹配，但因有X相隔，下一个a及其后内容不被匹配。",
    "In this case `(?(R&sub1)...|...)` checks if a call to `sub1` has been made. The first time the recursive conditional is parsed, the engine is in the process of matching what `sub1` requires, not yet finished. Conditional will return false and match `ky` instead.": "在这种情况下，`(?(R&sub1)...|...)` 检查是否已调用 `sub1`。第一次解析递归条件时，引擎正在匹配 `sub1` 所需的内容，尚未完成。条件将返回 false 并匹配 `ky`。",
    "Include full match in exported data": "在导出的数据中包含完整匹配",
    "Include non-participating groups in match result": "匹配结果中包含没有参与匹配的分组",
    "include the latest version of the regex crate in your Cargo.toml": "在你的Cargo.toml中包含最新版本的regex crate",
    "including a single character not present in the list below": "包含下表中不存在的单个字符",
    "including a single character present in the list below": "包括以下列表中的单个字符",
    "Incomplete group structure": "组的结构不完整",
    "Increase speed": "播放速度 +",
    "Increase step range": "扩大步骤范围",
    "Info": "Info",
    "Inline comment, discarded by the engine when matching the regex": "内联注释，匹配正则表达式时被引擎丢弃",
    "Inline modifiers": "内联修饰符",
    "Inline modifiers cannot be placed in the root of a conditional due to a bug in the .NET regex engine": "由于 .NET 正则表达式引擎中的错误，内联修饰符不能放在条件的根部",
    "Input String": "Input String",
    "Insert a backspace": "插入一个退格符",
    "Insert a backspace character.": "插入一个退格字符。",
    "Insert a bell": "插入一个响铃符",
    "Insert a bell character.": "插入一个响铃字符。",
    "Insert a carriage return": "插入一个回车符",
    "Insert a carriage return character.": "插入一个回车字符。",
    "Insert a form-feed": "插入一个换页符",
    "Insert a form-feed character.": "插入一个换页符号。",
    "Insert a literal quote": "插入文字引语",
    "Insert a literal quote in the regex.": "在正则表达式中插入文字引号。",
    "Insert a newline": "插入一个换行符",
    "Insert a newline character.": "插入一个换行符号。",
    "Insert a null": "插入一个空字符",
    "Insert a null character.": "插入一个空字符。",
    "Insert a personal title": "插入个人标题",
    "Insert a tab": "插入一个制表符",
    "Insert a tab character.": "插入一个制表字符。",
    "Insert a vertical tab": "插入一个垂直制表符",
    "Insert a vertical tab character.": "插入一个垂直制表字符。",
    "Insert code snippet": "插入代码片段",
    "insert comparison string": "插入比较字符串",
    "Insert entire input string": "插入整个输入字符串",
    "Insert last captured group": "插入最后一个捕获组",
    "Insert link": "插入链接",
    "Insert quote": "插入引号",
    "insert test description": "添加测试说明",
    "insert test string": "输入测试文本",
    "Insert the escaped literal": "插入转义文字",
    "Insert the escaped literal. Mainly useful if you're trying to insert a character that cannot be typed literally.": "插入转义文字。主要在尝试插入无法按字面输入的字符时有用。",
    "insert your regular expression here": "在此输入你的正则表达式",
    "insert your replacement value here": "在此输入你的替换文本",
    "insert your test string here": "在此处插入测试字符串",
    "inserts a backspace character {1}": "插入一个退格符 {1}",
    "inserts a carriage return {1}": "插入一个回车符 {1}",
    "Inserts a dollar sign": "插入美元符号",
    "inserts a form-feed character {1}": "插入一个换页符 {1}",
    "inserts a line-feed (newline) character {1}": "插入一个换行符（newline） {1}",
    "inserts a tab character {1}": "插入一个制表符 {1}",
    "inserts a vertical tab character {1}": "插入一个垂直制表符 {1}",
    "inserts esc {1}": "插入 esc {1}",
    "inserts the bell character {1}": "插入一个响铃字符 {1}",
    "inserts the character {1} with index {2}{3}": "插入索引为 {2}{3} 的字符 {1}",
    "inserts the entire input string": "插入整个输入字符串",
    "inserts the last group that was most recently captured by the regex": "插入最近一次被表达式捕获的分组",
    "inserts the matched substring": "插入整个匹配结果",
    "inserts the name from the last encountered backtracking control verb on the matching path that has a name": "插入匹配路径上最后遇到的具有名称的回溯控制动词的名称",
    "inserts the portion of the string that follows the matched substring": "插入匹配项之后的文本",
    "inserts the portion of the string that precedes the matched substring": "插入匹配项之前的文本",
    "inserts the same text as most recently matched by the {1} capturing group": "插入编号分组 {1} 最后一次捕获到的文本",
    "inserts the same text as most recently matched by the capturing group named {1}": "插入命名分组 {1} 最后一次捕获到的文本",
    "inserts the same text as most recently matched by the entire pattern": "插入整个正则表达式匹配到的文本",
    "Internal engine error: {1}": "内部引擎错误：{1}",
    "Introduction": "简介",
    "Invalid control character": "非法控制字符",
    "Invalid low/high surrogate": "无效的低/高替代值",
    "Invalid placement of hyphen; there may only be one inside the group": "连字符位置无效；组内只能有一个",
    "Invalid unicode escape": "unicode转义无效",
    "is null": "是null",
    "Isolates part of the full match to be later referred to by ID within the regex or the matches array. IDs start at 1.": "隔离完整匹配的一部分，以便稍后通过正则表达式或匹配数组中的 ID 引用。ID 从 1 开始。",
    "JIT Modifier": "JIT 修改器",
    "Join the Discord community!": "加入 Discord 社区！",
    "Jump {1} steps backwards": "快退 {1} 步",
    "Jump {1} steps forward": "快进 {1} 步",
    "Keep in mind that Python 3 is going to treat your whole script as unicode by default, therefore using this flag would be redundant. See the {1} flag to limit matches to ASCII characters only. Python 2 requires this flag to turn on unicode support.": "请记住，Python 3 默认将整个脚本视为 unicode，因此使用此标志是多余的。请参阅 {1} 标志以将匹配限制为仅 ASCII 字符。Python 2 需要此标志来启用 unicode 支持。",
    "Keyboard Shortcuts": "快捷键",
    "Language": "语言",
    "Last Group": "最后一组",
    "Last modified {1}": "最后修改时间：{1}",
    "lazy": "懒惰模式",
    "Lazy quantifier": "懒惰模式",
    "Left sidebar Breakpoint {1} ({2})": "左侧边栏断点 {1} ({2})",
    "Letters": "字母",
    "Letters and digits": "字母与数字",
    "Light": "浅色",
    "Limits matched line terminators to only {1}": "将匹配的行终止符限制为仅 {1}",
    "Limits the number of recursions the engine is allowed to make to `d` times. This user set limit cannot be increased past the compile time value or the default, however it can be restricted.": "将引擎允许进行的递归次数限制为“d”次。此用户设置的限制不能超过编译时值或默认值，但可以限制。",
    "Limits the number of times the regex engine is allowed to call `match()` to `x` times. This user set limit cannot be increased past the compile time value or the default, however it can be restricted.": "将正则表达式引擎允许调用“match()”的次数限制为“x”次。此用户设置的限制不能超过编译时值或默认值，但可以限制。",
    "Line break modifier": "换行模式标记",
    "Line Separator": "行分隔符",
    "Line terminator(s) are: {1} {2}": "行终止符为：{1} {2}",
    "Lines are delimited by: {1} {2}": "行的分隔符为： {1} {2}",
    "Link to regular expression": "正则表达式链接",
    "List": "格式化",
    "Live Help": "在线帮助",
    "Load example in editor": "在编辑器中加载示例",
    "Loading content...": "正在加载内容…",
    "Loading, please wait...": "正在加载，请等待...",
    "Loading...": "加载中...",
    "Localized inline modifiers": "局部内联修饰符",
    "Lonely End Quote": "孤独的尽头引言",
    "Lookahead conditional": "前视条件语句",
    "Lookaround": "环视",
    "Lookbehind conditional": "后视条件语句",
    "lowercase": "小写",
    "Lowercase letters": "小写字母",
    "Lowercase Transformation": "小写转换",
    "Lowest Score": "最低分数",
    "Make escape sequences perform ASCII-only matching": "转义系列仅执行ASCII匹配",
    "Make permalink private": "永久链接设为私密",
    "Make permalink public": "永久链接设为公开",
    "Make quantifiers lazy": "使量词默认为非贪婪模式",
    "Make regex perform ASCII-only matching instead of full Unicode matching. Applies to [a-z] ranges and escape sequences.": "令正则引擎只匹配ASCII字符（而不是所有Unicode字符），影响[a-z]等范围元字符和转义组合。",
    "Makes any character literal": "按文本形式处理字符",
    "Makes it so that any unicode newline character or sequence thereof counts as a line break.": "使得任何unicode换行符或其序列都算作换行符。",
    "Makes it so that either a carriage return character or a line feed character, or the two in sequence are considered a line break.": "使得回车符或换行符或连续的两个字符被视为换行符。",
    "Makes it so that empty strings will not be allowed to be matched by the pattern at the start of the subject string.": "使得空字符串不允许与主题字符串开头的模式匹配。",
    "Makes it so that empty strings will not be allowed to be matched by the pattern.": "使得空字符串不允许被模式匹配。",
    "Makes it so that only a carriage return character followed by a line feed character is considered a line break. Common in Windows documents.": "使得只有回车符后跟换行符才被视为换行符。在 Windows 文档中很常见。",
    "Makes it so that only a carriage return character is considered a line break.": "使得只有回车符才被视为换行符。",
    "Makes it so that only a line feed character is considered a line break. Common in UNIX documents.": "使得只有换行符才被视为换行符。在 UNIX 文档中很常见。",
    "Makes it so that the PCRE engine will no longer use just in time compilation.": "使得 PCRE 引擎不再使用即时编译。",
    "Malplaced character class intersection operator": "错位字符类交集运算符",
    "Malplaced character class subtraction operator": "错位字符类减法运算符",
    "Malplaced symmetric character class difference operator": "错位对称特征类差分算子",
    "Manage Regex": "管理正则表达式",
    "marker verb whose main purpose is to track how a match was arrived at": "标记动词，其主要目的是追踪匹配是如何达成的",
    "Match": "匹配",
    "Match {1}": "匹配 {1}",
    "Match {1} failed in {2} step(s)": "第 {1} 次匹配，在第 {2} 步失败",
    "Match {1} found in {2} step(s)": "第 {1} 次匹配，在第 {2} 步完成",
    "Match {1} halted after {2} step(s)": "第 {1} 次匹配，在第 {2} 步停止",
    "Match {1} was found at {2}": "在{2}找到匹配{1}",
    "match {1}, group {2}": "匹配项 {1}，组 {2}",
    "Match a single character not present in the list below": "匹配不在下列列表中的一个单字符",
    "match a single character not present in the set": "匹配集合中不存在的单个字符",
    "Match a single character present in the list below": "匹配下列列表中的一个单字符",
    "match a single character present in the set": "匹配集合中存在的单个字符",
    "match any non-word character in any script (equivalent to {1})": "匹配任何脚本中的任何非单词字符（相当于 {1}）",
    "match any word character in any script (equivalent to {1})": "匹配任何脚本中的任何单词字符（相当于 {1}）",
    "Match anything but a newline": "匹配除换行符之外的任何内容",
    "Match everything enclosed": "匹配括号中的内容（不捕获）",
    "Match expression defined in capture group `name`": "捕获组“name”中定义的匹配表达式",
    "Match expression defined in capture group 1": "匹配捕获组 1 中定义的表达式",
    "Match expression defined in the capture group \"{name}\"": "匹配捕获组“{name}”中定义的表达式",
    "Match expression defined in the capture group called \"letter\". This is an alternative notation for \"{1}\"": "匹配捕获组中定义的名为“字母”的表达式。这是“{1}”的替代表示法",
    "Match expression defined in the capture group called `letter`.": "匹配在捕获组中定义的名为“字母”的表达式。",
    "Match expression defined in the capture group named \"letter\"": "匹配在名为“字母”的捕获组中定义的表达式",
    "Match expression defined in the capture group with the given name. It does not require that the capture group be defined beforehand.": "匹配具有给定名称的捕获组中定义的表达式。它不需要事先定义捕获组。",
    "Match expression defined in the first capture group following the current position in the expression. {1} is the second capture group, {2} is the capture group immediately preceding the current position.": "匹配表达式中当前位置后面的第一个捕获组中定义的表达式。{1} 是第二个捕获组，{2} 是紧接当前位置之前的捕获组。",
    "Match expression defined in the first relative capture group": "匹配第一个相对捕获组中定义的表达式",
    "Match expression defined in the named capture group `letter`": "匹配命名捕获组“letter”中定义的表达式",
    "Match expression defined in the nth capture group": "匹配第 n 个捕获组中定义的表达式",
    "Match expression defined in the nth capture group ahead of the current position of {1}. For example {2} is the second previous capture group.": "匹配 {1} 当前位置之前的第 n 个捕获组中定义的表达式。例如，{2} 是前第二个捕获组。",
    "Match expression defined in the nth capture group ahead of the current position of {1}. For example, {2} is the second upcoming capture group.": "匹配在 {1} 当前位置之前的第 n 个捕获组中定义的表达式。例如，{2} 是第二个即将到来的捕获组。",
    "Match expression defined in the nth capture group.": "匹配第 n 个捕获组中定义的表达式。",
    "Match expression defined in the nth capture group. `n` can be positional as well. For example, {1} stands for previous capture group, while {2} would be the third capture group. Equivalent to {3}.": "匹配第 n 个捕获组中定义的表达式。`n` 也可以是位置相关的。例如，{1} 代表前一个捕获组，而 {2} 代表第三个捕获组。相当于 {3}。",
    "Match expression defined in the nth capture group. `n` can be positional as well. For example, {1} stands for the previous capture group, while {2} would be the third next capture group. Equivalent to {3}": "匹配第 n 个捕获组中定义的表达式。`n` 也可以是位置。例如，{1} 代表前一个捕获组，而 {2} 代表下一个第三个捕获组。相当于 {3}",
    "Match expression defined in the nth relative upcoming capture group.": "匹配第 n 个相对即将到来的捕获组中定义的表达式。",
    "Match expression defined in the nth relative upcoming subpattern": "匹配第 n 个相对即将到来的子模式中定义的表达式",
    "Match Information": "匹配信息",
    "match multi character string literals": "匹配多字符串文字",
    "Match nth subpattern": "匹配第n个子表达式/分组的捕获结果",
    "Match one data unit": "匹配一个数据单元",
    "Match previously-named capture group `letter`": "匹配先前命名的捕获组“字母”",
    "Match Step {1}": "匹配步骤 {1}",
    "Match Steps": "匹配步骤",
    "Match subpattern `name`": "匹配'name'子表达式的捕获结果",
    "Match subpattern number #": "匹配编号子表达式",
    "Match text the nth relative previous subpattern matched": "匹配文本中第 n 个相对前一个匹配的子模式",
    "match the remainder of the pattern with the following effective flags: {1}": "后面的表达式将应用下列修饰符进行匹配：{1}",
    "Match was found at {1}": "在{1}找到匹配",
    "Match with full unicode": "模式字符串被当成UTF-8",
    "matches a backspace character {1}": "匹配退格符{1}",
    "matches a carriage return {1}": "匹配回车键，返回{1}",
    "Matches a carriage return, unicode character U+2185.": "匹配回车符，Unicode 字符 U+2185。",
    "matches a character intended to be combined with another character (e.g. accents, umlauts, enclosing boxes, etc.)": "匹配将与另一个字符结合的字符（如重音符、圆角符、包围框等）",
    "matches a character intended to be combined with another character that takes up extra space (vowel signs in many Eastern languages)": "匹配一个旨在与另一个占用额外空间的字符（许多东方语言中的元音符号）结合的字符",
    "matches a character intended to be combined with another character without taking up extra space (e.g. accents, umlauts, etc.)": "匹配旨在与另一个字符组合而不占用额外空间的字符（例如重音符号、变音符号等）",
    "matches a character that encloses the character is is combined with (circle, square, keycap, etc.)": "匹配一个与之结合的字符（圆圈、正框、键帽等）",
    "matches a character with {1} value {2} through {3}": "从 {2} 至 {3} 中匹配一个字符 {1}",
    "matches a combining character (mark) as a full character on its own": "匹配一个组合字符（标记）作为一个单独的完整字符",
    "matches a control character {1}": "匹配一个控制字符 {1}",
    "matches a digit (equivalent to {1})": "匹配一个数字（等价于 {1}）",
    "matches a digit {1} (also written as {2})": "匹配一个数字 {1}（也写成 {2}）",
    "matches a digit zero through nine in any script except ideographic scripts": "匹配除了表意文字系统之外的任何文字系统中的数字 0-9",
    "matches a digit zero through nine in any script except ideographic scripts (equivalent to {1})": "匹配除了表意文字系统之外的任意文字系统中的数字 0-9（等价于 {1}）",
    "matches a form-feed character {1}": "匹配换页符 {1}",
    "matches a hexadecimal digit {1}": "匹配一个十六进制数值 {1}",
    "matches a letter or ideograph that does not have lowercase and uppercase variants": "匹配没有大小写变体表意文字或字母",
    "matches a letter that appears at the start of a word when only the first letter of the word is capitalized": "当单词的首字母大写时，匹配出现在单词开头的字母",
    "matches a letter that exists in lowercase and uppercase variants (combination of {1}, {2} and {3})": "匹配小写和大写变体中的字母（{1}、{2} 和 {3} 的组合）",
    "matches a line separator character {1}": "匹配行分隔符 {1}",
    "matches a line-feed (newline) character {1}": "匹配换行符 {1}",
    "matches a lowercase letter {1}": "匹配一个小写字母 {1}",
    "matches a lowercase letter that has an uppercase variant": "匹配具有大写变体的小写字母",
    "Matches a newline character": "匹配换行符",
    "Matches a null character, most often visually represented in unicode using U+2400.": "匹配一个空字符，该字符通常使用与之对应的图形字符 U+2400 来表示。",
    "matches a number that looks like a letter, such as a Roman numeral": "匹配看起来像字母的数字，例如罗马数字",
    "matches a paragraph separator character {1}": "匹配段落分隔符 {1}",
    "matches a punctuation character {1}": "匹配一个标点符号",
    "matches a punctuation character such as an underscore that connects words": "匹配连接单词的标点符号，例如下划线",
    "matches a single character in the list": "匹配列表中的单个字符",
    "matches a single character in the range between {1} {2} and {3} {4} ({5})": "匹配以下范围内的一个字符：从 {1} {2} 到 {3} {4} （{5}）",
    "matches a special character that is used like a letter": "匹配像字母一样使用的特殊字符",
    "matches a superscript or subscript digit, or a number that is not a digit (excluding numbers from ideographic scripts)": "匹配上标或下标数字，或非数字的数字（不包括表意文字的数字）",
    "matches a tab character {1}": "匹配制表符 {1}",
    "Matches a tab character. Historically, tab stops happen every 8 characters.": "匹配一个制表符。惯例上每个制表空位等于8个半角字符。",
    "Matches a unicode character outside of the given property.": "匹配某 Unicode 属性之外的任意一个字符。",
    "Matches a unicode character that doesn't have any of the given properties.": "匹配不含该属性的Unicode字符。",
    "Matches a unicode character with the given group of properties or categories:": "匹配某 Unicode 属性中的任意一个字符，参考：",
    "Matches a unicode character with the given property:": "匹配某 Unicode 属性中的任意一个字符，参考：",
    "matches a uppercase letter {1}": "匹配一个大写字母 {1}",
    "matches a vertical tab character": "匹配一个垂直制表符",
    "matches a visible character {1}": "匹配一个可见字符 {1}",
    "matches a visible character or the space character {1}": "匹配一个可见字符或空格符",
    "matches a whitespace character that is invisible, but does take up space": "匹配不可见的空白字符，但会占用空间",
    "matches a whitespace character, excluding line breaks {1}": "匹配空格字符，不包括换行符 {1}",
    "matches a whitespace character, including a line break {1} (also written as {2})": "匹配一个空白字符，包含换行 {1}（也写成 {2}）",
    "Matches an `a` character or nothing.": "匹配零或一个\"a\"字符。",
    "matches an alphabetic character {1}": "匹配字母字符 {1}",
    "matches an alphanumeric character {1}": "匹配字母数字字符 {1}",
    "matches an alphanumeric character or {1} {2} (also written as {3})": "匹配字母数字字符或 {1} {2} （也写为 {3}）",
    "matches an ASCII {1} or Latin-1 {2} control character": "匹配 ASCII {1} 或 Latin-1 {2} 控制字符",
    "matches an empty string (any position)": "匹配一个空字符串（任何位置）",
    "matches an uppercase letter that has a lowercase variant": "匹配具有小写变体的大写字母",
    "matches any character {1}": "匹配任意字符 {1}",
    "Matches any character except for an a, b or c": "匹配除 a、b 或 c 之外的任意字符",
    "Matches any character in the valid ASCII range. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "匹配有效 ASCII 范围内的任意字符。相当于 {1}。双方括号不是拼写错误，POSIX 表示法要求这样做。",
    "Matches any character other than newline (or including line terminators with the {1} flag)": "匹配除换行符之外的任何字符（或包括带有 {1} 标志的行终止符）",
    "Matches any character that is not a newline, the opposite of {1}. Not affected by the single line {2} flag.": "匹配任何非换行符的字符，与 {1} 相反。不受单行 {2} 标志的影响。",
    "Matches any character that is not horizontal whitespace {1}.": "匹配除了水平空白字符之外的任意字符 {1} 。",
    "matches any character that's not a digit (equivalent to {1})": "匹配一个不是数字的任意字符（等价于 {1}）",
    "matches any character that's not a horizontal whitespace character": "匹配除了水平空白字符之外的任意字符",
    "matches any character that's not a vertical whitespace character": "匹配除了垂直空白字符之外的任意字符",
    "matches any character, including newline": "匹配任何字符，包括换行符",
    "matches any character, including unicode {1}": "匹配任何字符，包括 unicode {1}",
    "Matches any characters between a and z, including a and z.": "匹配a与z之间的字符，包括a和z。",
    "Matches any characters between a-z or A-Z. You can combine as much as you please.": "匹配a到z及A到Z以内字符，可继续增加定义其它字符范围。",
    "Matches any characters defined in the class, except for any of the characters defined in the nested character class.": "匹配类中定义的任何字符，但嵌套字符类中定义的任何字符除外。",
    "Matches any characters except those in the range a-z.": "匹配不在a到z范围内的任意字符。",
    "matches any characters in the {1} {2}": "匹配 {1} {2} 中的任何字符",
    "matches any characters that {1} does not": "匹配任何 {1} 不存在的字符",
    "matches any code point reserved for private use": "匹配任何为私人用途保留的代码点",
    "matches any code point to which no character has been assigned": "匹配任何尚未分配字符的代码点",
    "matches any currency sign": "匹配任何一个货币符号",
    "Matches any decimal digit. Equivalent to {1}.": "匹配一个任意十进制数字，等价于 {1} 。",
    "matches any horizontal whitespace character (equivalent to {1})": "匹配任意水平空白字符（等价于 {1}）",
    "matches any kind of closing bracket": "匹配任何类型的右括号",
    "matches any kind of closing quote": "匹配任何类型的结束引号",
    "matches any kind of hyphen or dash": "匹配任何类型的连字符或破折号",
    "matches any kind of invisible character (equivalent to {1})": "匹配任何类型的不可见字符（相当于 {1}）",
    "matches any kind of letter from any language": "匹配任何语言的任何字母",
    "matches any kind of numeric character in any script": "匹配任何脚本中的任何类型的数字字符",
    "matches any kind of opening bracket": "匹配任何类型的左括号",
    "matches any kind of opening quote": "匹配任何类型的开场引语",
    "matches any kind of punctuation character": "匹配任何类型的标点符号",
    "matches any kind of punctuation character that is not a dash, bracket, quote or connector": "匹配任何非破折号、括号、引号或连接符的标点符号",
    "matches any kind of visible character (equivalent to {1})": "匹配任何可见字符（相当于 {1}）",
    "matches any kind of whitespace or invisible separator": "匹配任何类型的空格或不可见的分隔符",
    "Matches any letter, digit or underscore. Equivalent to {1}.": "匹配任意字母、数字或下划线，等价于 {1} 。",
    "matches any math symbols, currency signs, dingbats, box-drawing characters, etc": "匹配任何数学符号、货币符号、装饰符号、方框绘制字符等",
    "matches any mathematical symbol": "匹配任何数学符号",
    "matches any non-newline character": "匹配除了换行符之外 的任何字符",
    "matches any non-numeric character in any script (equivalent to {1})": "匹配任何脚本中的任何非数字字符（相当于 {1}）",
    "matches any non-whitespace character (equivalent to {1})": "匹配任意非空白字符（等价于 {1}）",
    "matches any non-word character (equivalent to {1})": "匹配任何非单词字符（相当于 {1}）",
    "matches any number of Unicode characters that form an extended Unicode sequence": "匹配构成扩展 Unicode 序列的任意数量的 Unicode 字符",
    "Matches any space, tab or newline character.": "匹配空格、制表符和换行符等空白字符。",
    "matches any Unicode newline sequence": "匹配任何 Unicode 换行符序列",
    "Matches any Unicode newline sequence. Equivalent to (?>\\r\\n|\\n|\\x0b|\\f|\\r|\\x85).": "匹配任何 Unicode 换行符序列。相当于 (?>\\r\\n|\\n|\\x0b|\\f|\\r|\\x85)。",
    "Matches any valid Unicode sequence, including line breaks. Equivalent to {1}.": "匹配任何有效的 Unicode 序列，包括换行符。相当于 {1}。",
    "matches any vertical whitespace character": "匹配任意垂直空白字符",
    "matches any whitespace character (equivalent to {1})": "匹配任意空白字符（等价于 {1}）",
    "matches any word character (equivalent to {1})": "匹配任意单词字符（相当于 {1}）",
    "Matches anything not matched by {1}.": "匹配 {1} 未匹配的任何内容。",
    "Matches anything other than a decimal/digit.": "匹配不是十进制数字的任意字符。",
    "Matches anything other than a letter, digit or underscore. Equivalent to {1}": "匹配不是字母、数字或下划线的任意字符，等价于 {1}",
    "Matches anything other than a space, tab or newline.": "匹配除空格、制表符和换行符以外的字符。",
    "Matches as few characters as possible.": "仅匹配最少量的必要相符内容。",
    "Matches as many characters as possible; backtracking can't reduce the number of characters matched. Because it is greedy, it will match all the way to the last digit, leaving nothing else for the {1} to match. Without backtracking, this regex fails to produce a match.": "尽可能多地匹配相符内容，并禁止随后的匹配项进行回溯匹配。范例中，d++匹配占用了所有数字，没为.留下任何可匹配字符，故整条匹配式匹配失败。",
    "Matches as many characters as possible.": "尽可能多地匹配相符内容。",
    "Matches ASCII characters typically associated with Control+A through Control+Z: {1} through {2}.": "匹配通常与 Control+A 到 Control+Z 相关的 ASCII 字符：{1} 到 {2}。",
    "Matches at least 3 consecutive `a` characters.": "匹配三个以上连续的\"a\"字符。",
    "Matches between 3 and 6 (inclusive) consecutive `a` characters.": "匹配三到六个连续的\"a\"字符。",
    "Matches characters that are not whitespace, letters or numbers. The double square brackets is not a typo, POSIX notation demands it.": "匹配非空格、字母或数字的字符。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "Matches characters that are often used to control text presentation, including newlines, null characters, tabs and the escape character. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "匹配通常用于控制文本显示的字符，包括换行符、空字符、制表符和转义符。相当于 {1}。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "Matches decimal digits. Equivalent to {1} or {2}. The double square brackets is not a typo, POSIX notation demands it.": "匹配十进制数字。相当于 {1} 或 {2}。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "Matches either an a, b or c character": "匹配 a、b 或 c 字符",
    "Matches either what is before the {1} or what is after it - in this case `a` or `b`.": "匹配 {1} 之前的内容或之后的内容 - 在本例中为“a”或“b”。",
    "Matches end of word (POSIX syntax), equivalent to {1}": "匹配单词的结尾（POSIX 语法），相当于 {1}",
    "matches esc {1}": "匹配 esc {1}",
    "Matches exactly 3 consecutive `a` characters.": "匹配三个连续的\"a\"字符。",
    "Matches exactly one data unit of input. Can match individual bytes in UTF-8 mode, leading to undefined behaviour if a search starts inside a character.": "匹配输入单元。在UTF-8模式下可能匹配单个字节，在字符内开始检索时导致“未定义行为”。",
    "Matches expression defined in the capture group with the given name.": "与捕获组中定义的具有给定名称的表达式匹配。",
    "Matches hexadecimal digits, case insensitive. Equivalent to {1}.": "匹配十六进制数字，大小写不敏感，等价于 {1} 。",
    "matches invisible control characters and unused code points": "匹配不可见的控制字符和未使用的代码点",
    "matches invisible formatting indicator": "匹配不可见的格式指示符",
    "Matches letters, numbers and underscores. Equivalent to {1} or {2}. The double square brackets is not a typo, POSIX notation demands it.": "匹配字母、数字和下划线。相当于 {1} 或 {2}。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "Matches lowercase letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "匹配小写字母。相当于 {1}。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "matches one data unit, even in UTF mode (best avoided)": "匹配一个数据单元，即使在 UTF 模式下也是如此（最好避免）",
    "matches one half of a surrogate pair in {1} encoding": "与 {1} 编码中的代理对的一半匹配",
    "Matches one or more consecutive `a` characters.": "匹配一个以上连续的\"a\"字符。",
    "Matches printable characters, part of the basic latin set, such as letters and spaces, without including control characters. The double square brackets is not a typo, POSIX notation demands it.": "匹配可打印字符（基本拉丁字符集的一部分，如字母和空格，不包括控制字符）。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "Matches printable, non-whitespace, non-control characters only. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "仅匹配可打印、非空白、非控制字符。相当于 {1}。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "Matches spaces and tabs (but not newlines). Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "匹配空格和制表符（但不匹配换行符）。相当于 {1}。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "Matches spaces, tabs, non-breaking/mathematical/ideographic spaces, and so on. Works with Unicode.": "匹配空格、制表符、不间断空格/数学空格/表意空格等。适用于 Unicode。",
    "Matches start of word (POSIX syntax), equivalent to {1}": "匹配单词的开头（POSIX 语法），相当于 {1}",
    "Matches text the nth group matched and captured. `n` represents the capture group number and can positionally refer to past capture groups as well.": "匹配第 n 个匹配并捕获的组的文本。'n' 表示捕获组编号，也可以位置引用过去的捕获组。",
    "Matches the 8-bit character with the given octal value.": "匹配给出Oct值对应的八位字符。",
    "Matches the backspace control character. {1} stands for `word boundary` when outside of a character class {2}.": "匹配退格控制字符。当位于字符类 {2} 之外时，{1} 代表“单词边界”。",
    "matches the bell character {1}": "与铃声字符 {1} 匹配",
    "matches the character {1} with index {2}{3} literally ({4})": "与索引为 {2}{3} 的字符 {1} 字面匹配 ({4})",
    "Matches the character with the given hex value.": "与给定的十六进制值匹配的字符。",
    "matches the characters {1} literally ({2})": "匹配字面文本 {1} ({2})",
    "matches the control sequence {1} {2}": "匹配控制序列 {1} {2}",
    "Matches the end of a string only. Unlike {1}, this is not affected by multiline mode, and, in contrast to {2}, will not match before a trailing newline at the end of a string.": "仅匹配字符串的结尾。与 {1} 不同，此命令不受多行模式的影响，与 {2} 不同，此命令不会匹配字符串结尾的换行符之前的内容。",
    "Matches the end of a string or the position before the line terminator right at the end of the string (if any). Unlike {1}, this is not affected by multiline mode.": "匹配字符串的结尾或字符串结尾处行终止符之前的位置（如果有）。与 {1} 不同，这不受多行模式的影响。",
    "Matches the end of a string without consuming any characters. If multiline mode is used, this will also match immediately before a newline character.": "匹配文本末尾的位置（不占用字符）。多行模式下亦匹配换行符前的位置，即行尾。",
    "Matches the end of any word; defined as any characters that are followed by either {1} or {2}.": "匹配任何单词的结尾；定义为后面跟着 {1} 或 {2} 的任何字符。",
    "Matches the end of any word; defined as any characters that are preceeded by {1} and superseeded by either {2} or {3}.": "匹配任何单词的结尾；定义为以 {1} 开头并被 {2} 或 {3} 取代的任何字符。",
    "matches the entire pattern": "匹配整个模式",
    "Matches the expression defined in capture group 1.": "与捕获组 1 中定义的表达式匹配。",
    "matches the expression defined in the {1} capture group": "与 {1} 捕获组中定义的表达式匹配",
    "matches the expression defined in the capture group \"{1}\"": "与捕获组“{1}”中定义的表达式匹配",
    "Matches the intersection between the two character classes. Useful if you want to white or blacklist certain characters from a broader class.": "匹配两个字符类的交集。如果你想将某个更广泛类别中的某些字符列入白名单或黑名单，这很有用。",
    "matches the intersection of the tokens to the left and right of this token": "匹配此标记左侧和右侧标记的交集",
    "Matches the longest possible substring in the group and doesn't allow later backtracking to reevaluate the group. It is not a capturing group.": "占用相应匹配内容，禁止随后的匹配项进行回溯匹配。非捕获组。",
    "matches the negation of {1}": "匹配不是{1}",
    "matches the previous token between {1} and {2} times, {3} {4}": "匹配前面的元素 {1} 到 {2} 次， {3} {4}",
    "matches the previous token exactly {1} {2} {3}": "匹配前面的元素 {1} {2} {3}",
    "Matches the relative complement of the two character classes. That is, any token that is in either, but not both.": "匹配两个字符类的相对补集。也就是说，任何标记都属于其中一个，但不同时属于两者。",
    "Matches the same text a capture group called `name` matched and captured. Alternate notations are {1} and {2}. Valid for .NET.": "匹配名为“name”的捕获组匹配并捕获的相同文本。替代符号为 {1} 和 {2}。适用于 .NET。",
    "matches the same text as most recently matched by the {1} capturing group": "匹配编号分组 {1} 最后一次捕获到的文本",
    "matches the same text as most recently matched by the capturing group named {1}": "匹配命名分组 {1} 最后一次捕获到的文本",
    "matches the same text as most recently matched by the entire pattern": "匹配与整个模式最近匹配的相同文本",
    "Matches the same text capture group called `letter` matched and captured.": "匹配并捕获名为“字母”的相同文本捕获组。",
    "Matches the same text matched and captured by a previously named capture group.": "匹配与先前命名的捕获组匹配并捕获的相同文本。",
    "Matches the same text matched by a previously named capture group.": "匹配与先前命名的捕获组匹配的相同文本。",
    "Matches the same text the nth group prior to {1} matched and captured.": "匹配在 {1} 之前匹配并捕获的第 n 个组的相同文本。",
    "Matches the start of a string only. Unlike {1}, this is not affected by multiline mode.": "仅匹配字符串的开头。与 {1} 不同，这不受多行模式的影响。",
    "Matches the start of a string without consuming any characters. If {1} multiline mode is used, this will also match immediately after a newline character.": "匹配字符串的开头而不消耗任何字符。如果使用 {1} 多行模式，这也将在换行符后立即匹配。",
    "Matches the start of any word; defined as any characters that are preceeded by either {1} or {2} and superseeded by {2}.": "匹配任何单词的开头；定义为以 {1} 或 {2} 开头并被 {2} 取代的任何字符。",
    "Matches the start of any word; defined as any characters that are preceeded by either {1} or {2}.": "匹配任何单词的开头；定义为以 {1} 或 {2} 开头的任何字符。",
    "matches the symmetric difference between the tokens to the left and right of this": "匹配此标记左侧和右侧的对称差异",
    "Matches the text captured by the nth group. n can contain more than one digit, if necessary.": "匹配第 n 组捕获的文本。如果需要，n 可以包含多个数字。",
    "matches the tokens to the left of this, minus any of the tokens present on the right": "匹配其左侧的标记，减去右侧存在的任何标记",
    "Matches the unicode character with the given hex value. When using the `/u` flag, 16-bit character (surrogate/supplementary characters included) syntax becomes `\\u{...}`.": "将 unicode 字符与给定的十六进制值匹配。使用 `/u` 标志时，16 位字符（包括代理/补充字符）语法变为 `\\u{...}`。",
    "Matches the very end of a string only. Unlike {1}, this is not affected by multiline mode.": "仅匹配字符串的最末尾。与 {1} 不同，这不受多行模式的影响。",
    "Matches unicode vertical whitespace, considered a character class by the PCRE engine: {1}.": "匹配 Unicode 垂直空格，PCRE 引擎将其视为字符类：{1}。",
    "Matches uppercase letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "匹配大写字母。相当于 {1}。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "matches various symbols that are not math symbols, currency signs, or combining characters": "匹配各种非数学符号、货币符号或组合字符的符号",
    "Matches whitespace characters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "匹配空格字符。相当于 {1}。双方括号不是拼写错误，POSIX 符号要求这样做。",
    "Matches zero or more consecutive `a` characters.": "匹配零个以上连续的\"a\"字符。",
    "Matches, without consuming any characters, at the position between two characters matched by {1} or {2}.": "匹配 {1} 或 {2} 匹配的两个字符之间的位置，不消耗任何字符。",
    "Matches, without consuming any characters, immediately between a character matched by {1} and a character not matched by {1} (in either order). It cannot be used to separate non words from words.": "匹配 {1} 匹配的字符和 {1} 不匹配的字符（不分先后顺序），不消耗任何字符。不能用于将非单词与单词分开。",
    "Max Execution Time": "最大执行时间",
    "May only be used to define functions. No matching is done in this group.": "仅可用于定义函数。此组中不进行匹配。",
    "meaningless quantifier": "没意义的量词",
    "Meta Escape": "Meta Escape",
    "Meta Sequences": "元字符序列",
    "Modifier": "修改器",
    "Most downvotes": "最多反对票",
    "Most Recent": "最新发布",
    "Most upvotes": "最多赞同",
    "Move down": "下移",
    "Move up": "上移",
    "Multi character string literals": "多字符串文字",
    "Multiline": "多行模式",
    "My Expressions": "我的表达式",
    "My Favorites": "我的收藏夹",
    "My Library Entries": "我的正则库",
    "My Regular Expressions": "我的正则表达式",
    "Name or other identifier of the author": "作者姓名或其他身份信息",
    "Named backreference may not be used before group definition": "在组定义之前不能使用命名反向引用",
    "Named Capture Group {1}": "命名捕获分组 {1}",
    "Named capture groups can be called via {1}": "命名捕获组可以通过 {1} 调用",
    "Named Capturing Group": "命名捕获组",
    "Need help selecting flavor?": "选择风格需要帮助吗？",
    "Negation of \\h": "\\h的反集",
    "Negation of \\p": "\\p的反集",
    "Negation of \\pX": "\\pX的反集",
    "Negation of \\v": "\\v的反集",
    "Negative Lookahead": "否定型前视",
    "Negative Lookbehind": "否定型后视",
    "Nested character classes act as boolean OR, equivalent to simply using {1}": "嵌套字符类充当布尔或，相当于简单地使用 {1}",
    "New!": "新的！",
    "Newline": "换行符",
    "Next page": "Next page",
    "Next question": "Next question",
    "No data": "No data",
    "No data captured during the debug process.": "调试过程中未捕获任何数据。",
    "no description available": "没有可用的描述",
    "No hex code was specified": "未指定十六进制代码",
    "No Internet Connection": "没有互联网连接",
    "No Match": "无匹配",
    "No match groups were extracted.": "未提取匹配组。",
    "No result": "没有结果",
    "No tags available": "没有可用的标签",
    "No tests matched your filter, click {1} to show all.": "没有符合你的过滤器的测试，点击{1}来显示所有。",
    "Non-atomic Positive Lookahead": "非原子正向前瞻",
    "Non-atomic Positive Lookbehind": "非原子正向后视",
    "Non-capturing group": "非捕获分组",
    "Non-capturing group that discards backtracking positions once matched.": "非捕获组，一旦匹配就会丢弃回溯位置。",
    "Non-capturing Group. Matches the tokens contained with the following effective flags: {1}": "非捕获组。匹配包含以下有效标志的标记：{1}",
    "Non-capturing groups": "非捕获组",
    "Non-word boundary": "非单词边界",
    "None": "None",
    "not": "不",
    "Note that {1} is wrapped in a superfluous capture group to help visually identify its match in the example string.": "请注意，{1} 被包裹在多余的捕获组中，以帮助在示例字符串中直观地识别其匹配项。",
    "Note that clicking any of the links above will refresh the page. Your data will be saved to local storage and restored once you return to the website.": "请注意，点击上述任何链接都会刷新页面。您的数据将保存到本地存储中，并在您返回网站后恢复。",
    "Note that this feature is not yet supported on all browsers; use at your own discretion!": "请注意，此功能尚未在所有浏览器上得到支持；请自行决定使用！",
    "Note: for Python 2.7 compatibility, use ur{1}{2} to prefix the regex and u\"\" to prefix the test string and substitution.": "注意：为了与 Python 2.7 兼容，使用 ur{1}{2} 作为正则表达式的前缀，使用 u\"\" 作为测试字符串和替换的前缀。",
    "nothing": "没有什么",
    "Nothing to preview": "没有预览",
    "Null character": "空字符",
    "Octal": "八进制",
    "Octal character ddd": "八进制字符 ddd",
    "Octal Character Table": "八进制字符表",
    "Octal only": "仅限八进制",
    "Offline Version": "Offline Version",
    "Ok": "好",
    "Once `(?1)` is called, `(?(R1)true|false)` will return true since capture group 1 was called, and will match `ction`": "一旦调用 `(?1)`，`(?(R1)true|false)` 将返回 true，因为捕获组 1 被调用，并且将匹配 `ction`",
    "Once we recursively call `(?&sub1)` the conditional will return true as `(?<sub1>)` finished matching, thus `ction` will match.": "一旦我们递归调用 `(?&sub1)`，条件将返回 true，因为 `(?<sub1>)` 完成匹配，因此 `ction` 将匹配。",
    "Once you have solved each task, you will be presented with statistics over how well others have done in that task, and the next task will be made available to you.": "一旦你完成了一项任务，你将获得其他人在该任务中完成情况的统计数据，下一项任务将提供给你。",
    "one": "1",
    "One or more of a": "一个及以上a",
    "Only signed in users are allowed to contribute to the community library": "仅允许登录用户向社区图书馆做出贡献",
    "Only the bare minimum information is retrieved and saved in order to identify your account.": "只需检索和保存最低限度的信息用以识别账户。",
    "Open code generator": "打开代码生成器",
    "Open regex debugger": "打开正则表达式调试器",
    "Open regex in editor": "在编辑器里打开正则表达式",
    "optional": "选修的",
    "or": "or",
    "Order By": "排序",
    "Parsing HTML with regex is seldom a good idea, despite there being a task in the quiz to do just that.": "使用正则表达式解析 HTML 往往不是一个很好的做法——虽然测验中有这样的任务。",
    "Pattern Backtrack Indicator": "形态回溯指标",
    "Pattern Error": "正则表达式错误",
    "Pattern may not end with a trailing backslash": "模式不能以尾部反斜杠结尾",
    "Pattern modifier": "模式修饰符",
    "Pattern strings will be treated as UTF-16, which means that unicode characters will also be included in {1} ranges, and in escape sequences like {2}.": "模式字符串将被视为 UTF-16，这意味着 unicode 字符也将包含在 {1} 范围内，以及 {2} 等转义序列中。",
    "Pause": "暂停",
    "PCRE equivalent is {1}.": "PCRE 等效于 {1}。",
    "Perform matching from right to left": "从右往左执行匹配",
    "Pick version to delete": "选择要删除的版本",
    "Pick which line separator to use in the editor. This only affects the parsing of the text when inserted into the editor, any changes within the editor will always use {1}.": "选择在编辑器中使用哪个行分隔符。这只会影响插入编辑器时文本的解析，编辑器内的任何更改都将始终使用 {1}。",
    "Plain Text": "纯文本",
    "Play": "播放",
    "Please {1} by clicking the link or the button in the left sidebar.": "请通过左边栏的按钮或点击链接进行 {1} 。",
    "Please enable JavaScript to use this web application.": "请将您的浏览器启用 JavaScript。",
    "Please fix the errors in your pattern before you attempt to submit it to the community library": "在尝试将图案提交给社区图书馆之前，请先修复图案中的错误",
    "Please fix the errors in your pattern before you try to debug it": "在尝试调试之前，请先修复模式中的错误",
    "Please insert a regular expression before you submit it to the community library": "请在提交到社区图书馆之前插入正则表达式",
    "Please insert a regular expression in order to debug it": "请插入正则表达式以便进行调试",
    "Please insert a regular expression in order to generate code snippets": "请插入正则表达式以生成代码片段",
    "Please insert or update the data in the editor before attempting to save a new entry": "请在编辑器中插入或更新数据，然后再尝试保存新条目",
    "Please keep in mind that these code samples are automatically generated and are not guaranteed to work. If you find any syntax errors, feel free to submit a bug report.": "请记住这里的代码是自动生成的，并不保证一定可以。如果你发现语法错误，你可以随意提交一个bug报告。",
    "Please modify the data in this entry before attempting to update it": "尝试更新之前，请修改此条目中的数据",
    "Please note that the translations are not exhaustive, and many english phrases are likely to still be used": "请注意，翻译并不详尽，许多英语短语可能仍会被使用",
    "Please remember this entry will be public in the community library. This is not your personal regex library! To save, access and manage your personal entries, please go to the {1} instead.": "请记住，此条目将在社区库中公开。这不是您的个人正则表达式库！要保存、访问和管理您的个人条目，请转到 {1}。",
    "Please wait while the page is loading...": "请等待页面加载...",
    "Please wait while your expression is being debugged...": "当你的表达式被调试时，请等待…",
    "Please wait while your request is being processed...": "您的请求正在处理中，请等待...",
    "Positive Lookahead": "肯定型前视",
    "Positive Lookbehind": "肯定型后视",
    "Posix Class": "Posix 类",
    "POSIX Word Boundaries must be the only item inside a character class": "POSIX 字边界必须是字符类中的唯一项",
    "possessive": "占用模式",
    "Possessive quantifier": "侵占模式",
    "Pre-define patterns before using them": "预定义表达式",
    "Press {1} to copy": "点击 {1} 进行复制",
    "Preview": "预览",
    "Previous page": "上一页",
    "Print the match result": "打印匹配结果",
    "Print the result of the substitution": "打印替换结果",
    "Processing...": "匹配中...",
    "Purchase Enterprise License": "购买企业许可证",
    "Quantifier": "量词",
    "Quantifier range is too large": "量词范围过大",
    "Quantifiers": "重复",
    "Quick Reference": "快速参考",
    "Quiz Submission Score": "测验提交分数",
    "Quote": "引用",
    "Quote; treat as literals": "引用，视为纯文本进行匹配",
    "Range": "范围",
    "Read more": "阅读更多",
    "Recommended": "受到推崇的",
    "Recurse entire pattern": "递归表达式",
    "Recursive Conditional statement": "递归条件语句",
    "Recursively match the entire expression. Equivalent to {1} or {2}.": "递归匹配整个表达式。相当于{1}或{2}。",
    "regex": "正则表达式",
    "Regex Debugger": "正则调试",
    "Regex Editor": "正则编辑器",
    "Regex engine modifier": "正则引擎模式标记",
    "Regex Flags": "正则修饰符",
    "Regex Flavor Guide": "正则表达式风格指南",
    "Regex Quiz": "正则测验",
    "regex quiz": "正则测验",
    "RegEx Score (lower is better)": "RegEx 分数（越低越好）",
    "Regex Version: {1}": "正则表达式版本：{1}",
    "Regex Versions": "正则版本",
    "Regex will continue parsing the string keeping in mind the last match location. If the next match is not located directly after the last, this next match is discarded.": "从上次匹配成功的下个位置开始后续匹配。若下个相符内容不紧接在后，则不继续匹配。",
    "Regex101 only supports inline modifiers to be placed at the start of the regex for python (which is also best practice)": "Regex101 仅支持将内联修饰符放置在 Python 正则表达式的开头（这也是最佳实践）",
    "RegEx101 Wiki": "RegEx101 维基",
    "Regular Expression": "正则表达式",
    "Relevance": "相关性",
    "Remove from favorites": "从收藏夹中移除",
    "Removes the most recently matched text from the group {1} if the contained pattern matches": "如果包含的模式匹配，则从组 {1} 中删除最近匹配的文本",
    "Removes the most recently matched text from the group {1} if the contained pattern matches, and captures the text between the two groups in {2}": "如果包含的模式匹配，则从组 {1} 中删除最近匹配的文本，并在 {2} 中捕获两个组之间的文本",
    "Replaces the text conditionally depending on if the {1} matched": "根据 {1} 是否匹配有条件地替换文本",
    "Report bugs or make suggestions": "报告错误或提出建议",
    "Reset match": "重置捕获起点",
    "resets the starting point of the reported match. Any previously consumed characters are no longer included in the final match": "重置报告的比赛的起点。任何之前消耗的字符不再包含在最终比赛中",
    "Restrict matches to ASCII only": "仅匹配ASCII",
    "Result": "结果",
    "result will be a String with the substituted value": "结果将是一个带有替换值的字符串",
    "result will be a tuple containing the start and end indices for the first match in the string": "结果将是包含字符串中每个匹配项的开始和结束索引的元组",
    "result will be an iterator over tuples containing the start and end indices for each match in the string": "结果将是包含字符串中每个匹配项的开始和结束索引的元组的迭代器",
    "Returns a string with the full match result. `0` can be replaced with any desired capture group ID to return that part of the match instead.": "返回包含完整匹配结果的字符串。可以使用任何所需的捕获组 ID 替换“0”，以返回匹配的那部分。",
    "Right sidebar Breakpoint {1} ({2})": "右侧边栏断点 {1} ({2})",
    "Run tests": "运行测试",
    "Run unit tests (when view is open)": "运行单元测试（当视图打开时）",
    "Save": "保存",
    "Save & Share": "保存与分享",
    "Save new Regex": "保存新的正则表达式",
    "Save Regular Expression": "保存正则表达式",
    "Save title and tags": "保存标题和标签",
    "Saving settings...": "保存设置......",
    "script": "script",
    "script extension": "script extension",
    "Search among {1} community submitted regex patterns...": "在 {1} 个社区提交的正则表达式模式中搜索...",
    "Search reference": "搜索",
    "Seek one step backwards": "后退一步",
    "Seek one step forward": "前进一步",
    "Select a service provider": "选择服务提供商",
    "Select assertion": "选择断言",
    "Select target": "选择目标",
    "Select the flavor you want to use when the site loads. Note: a saved entry's flavor will override this": "选择网站加载时要使用的风格。注意：已保存条目的风格将覆盖此",
    "Send me an email": "给我发邮件",
    "Separates the true and false case of the parent conditional.": "区分父条件的真假情况。",
    "Set Regex Options": "设置正则选项",
    "Sets the convention for newline matching to {1}, {2}, or {3} for things like the {4} metacharacter.": "对于诸如 {4} 元字符之类的内容，将换行符匹配约定设置为 {1}、{2} 或 {3}。",
    "Sets the given position in the regex as the new start of the match. Nothing preceding {1} will be returned as part of the full match.": "把正则中的给定位置设置为匹配项的新起点，{1} 之前匹配的任何内容都不会被包含在最终匹配结果中。",
    "sets the property mode to {1}": "设置属性模式为{1}",
    "sets the property mode to Unicode": "设置属性模式为Unicode",
    "Settings": "配置",
    "Shortcut": "快捷键",
    "shorthand for {1}": "shorthand for {1}",
    "Show all": "显示全部",
    "Show all tests": "显示所有测试",
    "Show how many steps a regular expression takes to evaluate": "显示正则表达式的执行步骤数",
    "Show informative and helpful tooltips when hovering tokens in the regex editor": "当鼠标掠过正则表达式元素，显示相关提示",
    "Show Line Numbers in Regex Editor": "在正则表达式编辑器中显示行号",
    "Show Line Numbers in Test String Editor and Substitution Result": "在测试文本编辑器和替换结果中显示行号",
    "Show match information panel in text input and substitution output": "在文本输入和替换输出中显示匹配信息面板",
    "Show only failed tests": "仅显示失败的测试",
    "Show only passed tests": "仅显示已通过的测试",
    "Show Sidebar": "显示边栏",
    "Show tooltips": "显示提示信息",
    "Show warning popup when trying to leave site with unsaved data": "离开未保存更改的页面之前弹窗提示",
    "Sign In": "登陆",
    "Sign out": "登出",
    "Similar to {1}, but with the main difference that whitespace is also ignored inside of character classes.": "与 {1} 类似，但主要区别在于字符类内的空格也会被忽略。",
    "Single line": "单行模式",
    "Site Theme": "Site Theme",
    "Social": "Social",
    "Space or tab only": "空格或制表符",
    "specifies a newline convention: {1}, {2} or {3}": "指定换行约定：{1}、{2} 或 {3}",
    "specifies a newline convention: {1}, {2} or {3} only": "指定换行约定：仅限 {1}、{2} 或 {3}",
    "specifies a newline convention: {1}, followed by {2}": "指定换行约定：{1}，后跟 {2}",
    "specifies a newline convention: all unicode newline sequences {1}": "指定换行符约定：所有 unicode 换行符序列 {1}",
    "specifies a newline convention: any Unicode newline sequence": "指定换行约定：任何 Unicode 换行序列",
    "specifies a newline convention: carriage return": "指定换行约定：回车符",
    "specifies a newline convention: line-feed": "指定换行约定：line-feed",
    "Sponsors": "Sponsors",
    "Star Entry": "明星入场",
    "Start of match": "匹配检索开始的位置",
    "Start of string": "文本开头",
    "Start of word": "单词首",
    "Start-of-word boundary": "字首边界",
    "Starting at the current position in the expression, ensures that the given pattern will not match. Does not consume characters.": "断言给定的子表达式在当前位置不能匹配，不消耗字符。",
    "starts with": "开始于",
    "step": "步",
    "Step backwards": "后退",
    "Step forward": "向前迈进",
    "steps": "步",
    "Sticky - searches in strings only from the index of the last match": "粘连模式",
    "Styling with Markdown is supported": "支持Markdown样式",
    "Submit": "提交",
    "Submitted by {1} - {2} {3}": "提交者：{1} - {2} {3}",
    "subpattern {1}": "子模式 {1}",
    "Subpattern definition construct": "子模式定义结构",
    "Subpatterns declared within each alternative of this construct will start over from the same index.": "此构造的每个替代项中声明的子模式将从同一索引开始",
    "Subroutine": "子程序",
    "Substitution": "替换",
    "Substitution result": "替换结果",
    "Success": "成功",
    "suppresses the start-of-match optimizations that are otherwise run by Perl": "禁止由 Perl 运行的「匹配开始」优化",
    "Surrogate in unicode/hex escape is disallowed": "不允许使用 unicode/hex 转义符进行代理",
    "Surrogate Pair": "代理对",
    "Switch to regex list substitution": "切换到正则表达式列表替换",
    "Switch to regex matching": "切换到正则表达式匹配",
    "Switch to regex substitution": "切换到正则表达式替换",
    "Switch to unit tests": "切换到单元测试",
    "Tab": "制表符",
    "Tags": "标签",
    "Task {1}": "任务 {1}",
    "Task Statistics": "任务统计",
    "Tasks": "任务",
    "Terminate any Transformation": "终止转换",
    "Terminates any of the previous {1} (uppercase) or {2} (lowercase) transformations. This is a feature only available on regex101.com.": "终止前面的 {1} (大写) 或 {2} (小写) 转换 。 这是 regex101.com 独有的功能。",
    "Terminates any previous text transformation (initiated with either \\U or \\L)": "终止前面的大小写转换（以 \\U 或 \\L 起始）",
    "Test finished in {1}{2}": "测试用时约 {1}{2}",
    "Test String": "测试文本",
    "Test String Backtrack Indicator": "测试字符串回溯指示器",
    "Text": "普通文本",
    "Text explanation mode": "文字解释模式",
    "Thank you for your contribution": "感谢您的贡献",
    "that is also not present in the complement of the sub-list below": "也不存在于以下子列表的补集中",
    "that is also not present in the sub-list below": "下面的子列表中也没有出现",
    "that is also present in complement of the sub-list below": "也存在于下面的子列表中",
    "that is also present in either the sub-list above or below, but not in both": "也出现在上面或下面的子列表中，但不会同时出现在两个子列表中",
    "that is also present in either the sub-list above or in the complement of the sub-list below, but not in both": "也出现在上面的子列表中或下面子列表的补集中，但不会同时出现在两者中",
    "that is also present in the sub-list below": "也出现在下面的子列表中",
    "The {1} and {2} anchors now match at the beginning/end of each line respectively, instead of beginning/end of the entire string or input.": "{1} 和 {2} 锚点现在分别匹配每行的开头/结尾，而不是整个字符串或输入的开头/结尾。",
    "the above tag defines encoding for this document and is for Python 2.x compatibility": "上述标签定义了本文档的编码，并且与 Python 2.x 兼容",
    "The character offset is too large": "字符偏移量过大",
    "The condition is invalid (you may be referencing a non-existent subpattern or group)": "条件无效（您可能引用了一个不存在的子模式或组）",
    "The conditionals may be nested to create further logic.": "可以嵌套条件以创建进一步的逻辑。",
    "The data can never be recovered again!": "数据再也无法恢复！",
    "The default setting of {1} will split lines on any of {2}, {3} or {4}.": "默认设置 {1} 将在 {2}、{3} 或 {4} 中的任意一个上分割线。",
    "The DEFINE group is completely ignored by regex. It gets treated as a var name=\"value\", whereas you can recall the specific pattern for use via its name. Multiple patterns can be defined in the same DEFINE group.": "DEFINE(定义)组内容不会进行匹配，而是为特定组名定义对应的子表达式，供随后调用。可在一个定义组内定义多条子表达式。",
    "The engine will per default do lazy matching, instead of greedy. This reverses the meaning of {1}, which will now make the previous quantifier greedy.": "引擎默认会进行惰性匹配，而不是贪婪匹配。这会反转 {1} 的含义，现在会使前一个量词变得贪婪。",
    "The escape sequence to match backspace is not supported in the selected flavor": "所选风格不支持与退格符匹配的转义序列",
    "The internal recursion limit was reached.": "已达到内部递归限制。",
    "The Java regex engine reached the maximum call stack size.": "Java 正则表达式引擎已达到最大调用堆栈大小。",
    "The live version of the website was not able to be loaded. This could either be because of a server outage, or your internet connection. Please try again later.": "无法加载网站的实时版本。这可能是由于服务器故障或您的互联网连接问题。请稍后重试。",
    "The match information panel will show useful information about the current caret position and selection in the editor.": "匹配信息面板将显示有关编辑器中当前插入符号的位置和选择的有用信息。",
    "The match was halted because the offset does not point to the beginning of a valid UTF-16 character.": "偏移量没有指向有效的UTF-16字符的开头，因此匹配已停止。",
    "The match was halted because your expression contains a recursive loop. This means either that the whole pattern, or a subpattern, has been called recursively for the second time at the same position in the subject string.": "匹配被暂停，因为您的表达式包含递归循环。这意味着整个模式或子模式已在主题字符串的同一位置第二次被递归调用。",
    "The name of the verb is too long": "动词名称太长",
    "The name of this subpattern is too long": "此子模式的名称太长",
    "The number is too large": "数量太大",
    "The pattern is forced to become anchored at the start of the search or at the position of the last successful match, equivalent to a {1}.": "该模式被强制锚定在搜索的开始处或最后一次成功匹配的位置，相当于 {1}。",
    "The PCRE regex engine automatically applies some internal optimizations to regexes to avoid unnecessary backtracking. This modifier will disable that behavior, and thus the engine will backtrack until the previously matching instruction fails to do so.": "PCRE的正则引擎会自动进行内部优化，避免不必要的回溯，而本标记将禁止该功能，让引擎回溯到上一个匹配指令失败为止。",
    "The posix class is unknown/invalid": "posix 类未知/无效",
    "The preceding token is not quantifiable": "前面的记号（token）无法设定重复次数",
    "The quantifier range is out of order": "数量的范围不符合规定",
    "The quiz is divided into a number of different tasks, which each have a short description of the problem for you to solve.": "测验分为若干不同的任务，每个任务都有一个简短的问题描述供你解决。",
    "The quiz is evaluated using the PCRE2 engine, which is also available in the main editor if you would like to do some testing.": "测验是使用 PCRE2 引擎进行计算的，如果你想进行一些测试，也可以在主编辑器中使用该引擎。",
    "The range is invalid because either the left or right token is erroneous": "该范围是无效的，因为左边或右边的标记是错误的",
    "The regex debugger returned no data for the input you provided.": "正则表达式调试器没有为您提供的输入返回任何数据。",
    "The regex debugger was unable to debug your pattern due to an error.": "由于发生错误，正则调试器无法调试表达式。",
    "The regex did not match the subject string.": "正则表达式与目标字符串不匹配。",
    "The regex engine returns match indices": "正则表达式引擎返回匹配索引",
    "The result can be accessed through the `m`-variable.": "结果可以通过`m变量`访问。",
    "The result of the substitution is": "替换的结果是",
    "the string": "该字符串",
    "The substituted value will be contained in the result variable": "被替换的值将包含在结果变量中",
    "The tab key will by default switch to the next field in the tabbing order. If this option is disabled, input areas for regex, substitution and test string will instead consume the tab key.": "Tab 键的默认行为是切换焦点。如果禁用此选项，在正则表达式、测试文本、替换的输入框中按下 Tab 键会输入一个制表符。",
    "The tasks will get progressively harder, and you will receive less and less hand-holding the further you progress.": "任务会变得越来越难，而且随着你的进步，你得到的帮助会越来越少。",
    "The token is incomplete": "记号不完整",
    "The value specified is too large": "指定的值过大",
    "There are currently no sponsors. {1}": "目前没有赞助商。{1}",
    "There are no available code generators for this regex function": "此正则表达式函数没有可用的代码生成器",
    "There are no unit tests, click {1} to add some.": "没有单元测试，请点击 {1} 添加。",
    "There are too many alternatives within the parent structure": "父结构中有太多替代方案",
    "There does not seem to be anything here": "这里似乎什么都没有",
    "There is currently no data to export": "目前没有要导出的数据",
    "There was a problem trying to fetch the library data. Please try again later.": "尝试获取库数据时出现问题。请稍后再试。",
    "There was a problem when trying to fetch the details for this entry. Please try again later.": "尝试获取此条目的详细信息时出现问题。请稍后再试。",
    "There was a problem while trying to submit your regex to the library. Please try again later.": "尝试将正则表达式提交到您的库时出现问题。请稍后再试。",
    "There was an error fetching the quiz data. Please try again later.": "获取测验数据时出错。请稍后重试。",
    "There was an error querying the server, please try again later:": "查询服务器时出错，请稍后重试：",
    "There was an error trying to save your regex. Please try again later.": "在尝试保存您正则表达式时出现了错误。请稍后再试。",
    "There was an error when trying to load the live version of the website. This could either be due to a server outage, or because of your network connection.": "尝试加载网站的实时版本时出现错误。这可能是由于服务器故障或网络连接问题。",
    "There was an error while fetching your account data. Please try again later.": "在获取您的账户数据时出现了错误。请稍后再试。",
    "These flag modifiers act on the enclosed expression only. Equivalent to {1}": "这些标志修饰符仅作用于封闭的表达式。相当于 {1}",
    "These flag modifiers act on the whole expression. You can also unset flags using a minus sign: {1}, and can combine setting and unsetting flags. {2} would set the single line flag and unset case insensitive.": "这些标志修饰符作用于整个表达式。您还可以使用减号 {1} 取消设置标志，并且可以组合设置和取消设置标志。{2} 将设置单行标志并取消设置不区分大小写。",
    "This allows regex to accept duplicate pattern names, however each capture group still has its own ID. Thus the two capture groups produce their own match instead of a single combined one.": "捕获的子表达式可使用相同组名，但仍被分配独立的ID号。",
    "This allows regex to treat the string as UTF-16, specifically.": "令正则引擎视文本编码为16位UTF。",
    "This allows regex to treat the string as UTF-32, specifically.": "令正则引擎视文本编码为32位UTF。",
    "This allows regex to treat the string as UTF-8, specifically.": "令正则引擎视文本编码为8位UTF。",
    "This allows regex to treat the string as UTF, be it 8, 16, or 32.": "令正则引擎视文本编码为8/16/32位UTF。",
    "This capturing group can be referred to using the given name instead of a number.": "可以使用指定名称而不是数字来指代此捕获组。",
    "This capturing group can be referred to using the given name instead of a number. Alternative notation for {1} and {2} when using a PCRE flavor.": "可以使用给定的名称而不是数字来引用此捕获组。使用 PCRE 风格时，{1} 和 {2} 的替代符号。",
    "This capturing group can be referred to using the given name instead of a number. Alternative notation for {1} or {2}.": "可以使用给定的名称而不是数字来引用此捕获组。{1} 或 {2} 的替代表示法。",
    "This capturing group can be referred to using the given name instead of a number. Alternative notation for {1}.": "可以使用给定的名称而不是数字来引用此捕获组。{1} 的替代表示法。",
    "This causes the regex to end successfully, skipping the rest of the pattern.": "匹配至此后判断为成功并结束，跳过剩余的表达式。",
    "This character must be escaped when placed in the parent construct": "此字符在放入父构造中时必须进行转义",
    "This construct cannot be used with the {1} option": "此构造不能与 {1} 选项一起使用",
    "This construct literally matches nothing, and should be removed.": "该构造实际上不匹配任何内容，应将其删除。",
    "This construct may not be supported in all browsers": "并非所有浏览器都支持此构造",
    "This enables the dot metacharacter {1} to also match newlines. The whole string is treated as a single line input.": "这使得点元字符 {1} 也能匹配换行符。整个字符串被视为单行输入。",
    "This entry has also been automatically been linked to your account for your convenience.": "为方便您使用，此条目也已自动链接到您的帐户。",
    "This entry has been specifically selected by our team to be a great submission": "此作品由我们的团队精心挑选，是一份出色的作品",
    "This feature is not available while in the unit test view": "在单元测试视图中此功能不可用",
    "This feature is only available for the PCRE flavor": "此功能仅适用于 PCRE 风格",
    "This flag does not exist in Python2, as by default your script is parsed in ascii mode. In Python3 this will behave as described.": "Python 2不支持本修饰符，默认为ASCII。",
    "This flag tells the engine to ignore all whitespace and allow for comments in the regex; also called verbose. Comments are indicated by a starting \"#\"-character. If you need to include a space character in your regex, it must now be escaped '\\ '.": "这个标志告诉引擎忽略所有的空白，并允许在正则表达式中添加注释，也称为详细模式（verbose）。注释是以井号 # 开始的。如果你需要在表达式中包含一个空格字符，必须使用反斜杠 \\ 进行转义。",
    "This generator only supports substitution. Please update your regular expression accordingly": "此生成器仅支持替换。请相应地更新您的正则表达式",
    "This group construct will capture the content that lies between the two groups, i.e. from the last position of {1} until {2}, if the pattern contained matches.": "如果包含的模式匹配，则该组构造将捕获位于两个组之间的内容，即从 {1} 的最后位置直到 {2}。",
    "This group construct will remove the content of the referenced group {1}, allowing for balanced matches to be performed, if the pattern contained matches": "如果模式包含匹配项，则此组构造将删除引用组 {1} 的内容，从而允许执行平衡匹配",
    "This group construct will remove the content of the referenced group {1}, allowing for balanced matches to be performed, if the pattern contained matches.": "如果模式包含匹配项，则此组构造将删除引用组 {1} 的内容，从而允许执行平衡匹配。",
    "This hyphen is treated literally, which might be confusing for others. Consider escaping it or placing at the start or end of the class.": "此连字符按字面意思处理，可能会让其他人感到困惑。请考虑将其转义或放置在类的开头或结尾。",
    "This indicates that your expression is not optimized for Java, and you are likely to run into similar issues in your Java code.": "这表明您的表达式并未针对 Java 进行优化，并且您很可能会在 Java 代码中遇到类似的问题。",
    "This is an alternate syntax for {1} or {2}.": "这是 {1} 或 {2} 的替代语法。",
    "This is an interactive learning tool you can use to improve your understanding of regular expressions, and their different applications.": "这是一个交互式学习工具，你可以使用它来提高对正则表达式及其应用的理解。",
    "This is due to the fact that the regex engine is implemented using recursion, and is severely limited by it.": "这是因为正则表达式引擎是使用递归实现的，并且受到递归的严重限制。",
    "This is necessary to avoid infinite loops with zero-width matches": "这对于避免零宽度匹配的无限循环是必要的",
    "This may be an indication of catastrophic backtracking. To find out more and what this is, please read the following article:": "这可能是灾难性回溯的征兆。要了解更多信息以及这是什么，请阅读以下文章：",
    "This may be useful in order to avoid ambiguity with octal characters.": "为了避免八进制字符的歧义，这可能很有用。",
    "This means that your pattern did match but there were no capturing groups that matched anything in the subject string.": "这意味着您的模式确实匹配，但没有与主题字符串中的任何内容匹配的捕获组。",
    "This modifier may not be supported in all browsers": "并非所有浏览器都支持此修饰符",
    "This notation is useful in avoiding ambiguity with octal characters, or when a literal number needs to be matched immediately after a {1} reference in the regex.": "这种表示法有助于避免与八进制字符产生歧义，或者当需要在正则表达式中的 {1} 引用后立即匹配文字数字时。",
    "This POSIX equivalent of the \"\\b\" word boundary is interpreted as": "POSIX下类似于\"\\b\"的词汇后分界，更具体地阐释为",
    "This POSIX equivalent of the {1} (word boundary) is interpreted as {2}": "此 POSIX 等效于 {1}（字边界），被解释为 {2}",
    "This script is unknown/invalid": "此脚本未知/无效",
    "This sets the convention for newline matching to any unicode newline character or sequence thereof, for things like the {1} metacharacter.": "这将设置换行符匹配的约定，即任何 unicode 换行符或其序列，例如 {1} 元字符。",
    "This setting affects how long the matcher will try to match your regex before it decides to give up": "此设置会影响匹配器在决定放弃之前尝试匹配正则表达式的时间",
    "This setting defines how text escapes should be explained in the editor. Choose if alternate notations should be included or not.": "此设置定义应如何在编辑器中解释文本转义。选择是否应包含替代符号。",
    "This setting determines whether groups in your regex, which did not match anything in the subject string, should be included in the results or not": "此设置决定“匹配信息”中是否显示没有参与匹配的分组",
    "This token can not be used in a lookaround due to either making it non-fixed width or interfering with the pattern matching": "由于宽度不固定或干扰模式匹配，此标记不能用于环视",
    "This token has no special meaning and has thus been rendered erroneous": "此记号没有特殊含义，因此被认为是错误的",
    "This token is either not supported by the selected flavor or by regex101": "所选风格或 regex101 不支持此标记",
    "This token is not valid under strict mode, and may cause certain browsers to throw errors. If you need to reference this subpattern, use the {1} syntax, otherwise use the token literally.": "此令牌在严格模式下无效，可能会导致某些浏览器抛出错误。如果您需要引用此子模式，请使用 {1} 语法，否则请按字面意思使用该令牌。",
    "This token may not be used inside of the {1} construct": "此令牌不能在 {1} 构造内使用",
    "This token must be escaped when the {1} flag is enabled unless they form a valid quantifier": "启用 {1} 标志时必须转义此标记，除非它们形成有效的量词",
    "This token references a non-existent or invalid subpattern": "此记号引用了不存在或无效的子模式",
    "this verb causes the match to end successfully, skipping the remainder of the pattern": "此动词导致匹配成功结束，跳过模式的其余部分",
    "this verb causes the match to fail at the current starting position in the subject if the rest of the pattern does not match": "如果模式的其余部分不匹配，则此动词会导致匹配在主题的当前起始位置失败",
    "this verb disables JIT compilation of the pattern": "此动词禁用模式的 JIT 编译",
    "this verb disables matching of empty strings": "此动词禁用空字符串的匹配",
    "this verb disables matching of empty strings at the start of the subject string": "此动词禁用在主题字符串开头匹配空字符串",
    "this verb disables the internal `auto-possessification` optimization in PCRE": "此动词禁用 PCRE 中的内部“自动占有”优化",
    "This verb does not allow regex to continue parsing after a matching failure, even if there are other matching strings ahead, and regardless of how many successful matches are before the failure.": "一旦匹配失败，该标记将终止整个匹配流程，即使之后仍有可成功匹配的文本。",
    "This verb is unknown or invalid": "此动词未知或无效",
    "This verb must be placed at the start of the regex": "此动词必须放在正则表达式的开头",
    "this verb sets the match limit (max iterations) for the pattern": "此动词设置模式的匹配限制（最大迭代次数）",
    "this verb sets the recursion limit (max depth) for the pattern": "该动词设置模式的递归限制（最大深度）",
    "This will insert the entire input string": "这将插入整个输入字符串",
    "This will insert the last group that was most recently captured by the regex": "将会插入最近一次被表达式捕获的分组",
    "This will match only at the starting point of the search or the position the previous successful match ended. Useful with the {1} flag, or when you are only trying to match after a certain point in a string.": "这将仅在搜索的起点或上一次成功匹配结束的位置进行匹配。与 {1} 标志一起使用时很有用，或者当您仅尝试在字符串中的某个点之后进行匹配时很有用。",
    "This will return a portion of the source string that follows the match.": "返回被匹配字符串后的字符串内容。",
    "This will return a portion of the source string that precedes the match.": "返回被匹配字符串前的字符串内容。",
    "This will return a string with the complete match result from the regex.": "返回主表达式匹配捕获的字符串内容。",
    "This will return a string with the contents from the capture group named `foo`. Any name can be used as long as it is defined in the regex. This syntax is made up and specific to only Regex101. If the J-flag is specified, content will be taken from the first capture group with the same name.": "返回被命名为foo的捕获组的字符串内容。若使用了修饰符J，将引用首个同名捕获组的内容。Regex101特有语法。",
    "This will return a string with the contents from the first capture group. The number, in this case 1, can be any number as long as it corresponds to a valid capture group.": "返回首个捕获组的字符串内容。只要能对应有效的捕获组，组号码大小不限。",
    "time": "次",
    "Timeout": "超时（可在配置中调整超时时间）",
    "times": "次",
    "Title": "标题",
    "Title of regular expression": "正则表达式的标题",
    "To reduce ambiguity one may also use {1}, or {2} where `#` is a digit.": "为了减少歧义，也可以使用 {1} 或 {2}，其中 `#` 是数字。",
    "Tools": "工具",
    "Tools and Filters": "工具和过滤器",
    "Transforms text to lowercase until either end of string or a {1} token is encountered. This is a feature only available on regex101.com.": "将文本转换为小写字母，直到字符串末尾或者出现 {1} 标记为止。这是 regex101.com 独有的功能。",
    "Transforms text to uppercase until either the end of string or a {1} token is encountered. This is a feature only available on regex101.com.": "将文本转换为大写字母，直到字符串末尾或者出现 {1} 标记为止。这是 regex101.com 独有的功能。",
    "Try launching the debugger to find out why.": "尝试启动调试器来找出原因。",
    "UCP (Unicode Character Properties) makes the PCRE engine extend {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, and some POSIX character classes to include unicode characters as well, not just ASCII.": "UCP（Unicode 字符属性）使 PCRE 引擎扩展 {1}、{2}、{3}、{4}、{5}、{6}、{7}、{8} 和一些 POSIX 字符类，以包含 Unicode 字符，而不仅仅是 ASCII。",
    "Un-star Entry": "取消星级条目",
    "Unable to delete entry, please try again": "无法删除条目，请重试",
    "Unable to fetch content, please try again later": "无法获取内容，请稍后重试",
    "Unable to fetch detailed task statistics. Please try again later.": "无法获取详细任务统计信息。请稍后重试。",
    "Unable to fetch versions": "无法获取版本信息",
    "Unable to initialize the regex engine! Please try to reload the web page. If the issue persists, please open an issue here: {1}": "无法初始化正则表达式引擎！请尝试重新加载网页。如果问题仍然存在，请在此处打开问题：{1}",
    "Unable to load live version of RegEx101": "无法加载 RegEx101 的实时版本",
    "Unable to perform action, please try again.": "无法执行操作，请重试。",
    "Unable to save changes, please try again": "无法保存更改，请重试",
    "Unable to save settings": "无法保存设置",
    "Understood": "明白",
    "Undescribed specific verb; No description for it yet (nothing's perfect)": "未描述的特定动词；还没有对其进行描述（没有什么是完美的）",
    "Unfavorite Regex": "从收藏夹中移出",
    "Ungreedy": "懒惰模式",
    "Unicode": "Unicode模式",
    "Unicode case insensitive": "Unicode 不区分大小写",
    "Unicode Character Table": "Unicode 字符表",
    "Unicode newlines": "Unicode换行符",
    "Unicode Property": "Unicode Property",
    "Unicode property or script category": "Unicode 属性",
    "Unicode property X": "Unicode 属性 X",
    "Unit Tests": "单元测试",
    "Unit Tests {1}": "单元测试 {1}",
    "unlimited": "无穷",
    "Unmatched opening bracket": "不匹配的开口支架",
    "Unmatched parenthesis": "括号不匹配",
    "Update": "更新",
    "Update Community Entry": "更新社区条目",
    "Update Community Regex": "更新社区正则表达式",
    "Update Regex": "更新正则表达式",
    "Update Regular Expression": "升级正则表达式",
    "uppercase": "大写",
    "Uppercase letters": "大写字母",
    "Uppercase Transformation": "大写转换",
    "Upvote": "赞同",
    "Use the default behavior for the tab key": "使用 Tab 键的默认行为",
    "Used to mark internal engine backtracking. When used in conjunction with the /K modifier (show backtracking control names), pcretest can return the mark together with a successful match. Equivalent to {1}. {2} does not need to be unique.": "用于标记内部引擎回溯。当与 /K 修饰符（显示回溯控件名称）结合使用时，pcretest 可以返回标记以及成功匹配。相当于 {1}。{2} 不需要唯一。",
    "User distribution (%)": "User distribution (%)",
    "Usually referred to as a `backreference`, this will match a repeat of the text matched and captured by the capture group # (number) specified.": "通常称为 `反向引用`，匹配第 # 个捕获分组所捕获到的文本。",
    "Values below {1} are not recommended. Use at your own discretion": "不推荐低于 {1} 的值。请自行决定使用",
    "Verb": "动词",
    "verb synonymous with {1}. Forces a matching failure at the given position in the pattern": "动词与{1}同义。强制在模式中的给定位置匹配失败",
    "Version {1}": "Version {1}",
    "Vertical Tab": "垂直制表符",
    "Vertical whitespace character": "纵向空白字符",
    "View Explanation": "查看解释",
    "View Match Information": "查看匹配信息",
    "View Regex Quick Reference": "查看正则表达式快速参考",
    "Visible characters": "可见字符",
    "Visible characters (not space)": "可见字符(不含空白字符)",
    "Visible punctuation characters": "可见标点字符",
    "Visualize whitespace and other special characters": "显示空白字符",
    "Welcome to the regex101 regex quiz!": "欢迎来到 regex101 正则测验！",
    "What's new?": "什么是新的？",
    "Which version do you want to delete?": "您要删除哪个版本？",
    "Whitespace": "空白字符",
    "Whole match is {1} and its start/end positions can be obtained via {2} and {3}": "整个匹配为 {1}，其起始/结束位置可通过 {2} 和 {3} 获取",
    "with no special consideration for the \\r\\n sequence": "未特别考虑\\r\\n序列的问题",
    "without giving back": "不给予回报",
    "Word characters": "单词字符",
    "Wrap Long Lines": "自动换行",
    "Write": "编写",
    "Yes, delete": "是的，删除",
    "Yes, delete everything": "是的，删除所有内容",
    "You also get a valuable feature set with regards to your data privacy, where you are given the ability to restrict who can view and edit the information you save.": "您还可以获得与数据隐私相关的一组有价值的功能，您可以限制谁可以查看和编辑您保存的信息。",
    "You can add titles and tags to organize your entries, as well as favorite any expressions.": "您可以添加标题和标签来组织您的条目，以及收藏任何表达方式。",
    "You can also perform character class subtraction, by intersecting with a negated character class, like so {1}, in order to match word characters, but not {2}": "您还可以通过与否定字符类相交来执行字符类减法，例如 {1}，以便匹配单词字符，但不匹配 {2}",
    "You can also unset flags using a minus sign: {1}, and can combine enabling and disabling flags. For example: {2} would set enable single line and disable case insensitive.": "您还可以使用减号 {1} 取消设置标志，并且可以组合启用和禁用标志。例如：{2} 将设置启用单行并禁用不区分大小写。",
    "You can continue to edit in this workspace without affecting the entry you just submitted.": "您可以继续在此工作区中编辑，而不会影响刚刚提交的条目。",
    "You can find the community entry here: {1}": "您可以在此处找到社区条目：{1}",
    "You can help with translations by visiting the following url:": "您可以通过访问以下网址来帮助翻译：",
    "You can make any quantifier lazy by appending a question mark to it.": "您可以通过在任何量词后面附加问号来使其成为惰性量词。",
    "You can manually specify the number of replacements by changing the 4th argument": "您可以通过改变第4个参数来手动指定替换的数量",
    "You can not set both the {1} and {2} flag simultaneously": "不能同时设置 {1} 和 {2} 标志",
    "You can use alternates locally as part of a capturing/non-capturing group. For example: {1}": "您可以在本地使用替代项作为捕获/非捕获组的一部分。例如：{1}",
    "You can use hexadecimals to insert any character into the replacement string using the standard syntax.": "可以HEX码在替换文本中插入任意字符。",
    "You cannot create a range with an opening bracket": "不能用左括号创建范围",
    "You cannot create a range with shorthand escape sequences": "无法使用简写转义序列创建范围",
    "You cannot create character ranges with the terminating character class token": "不能使用终止字符类标记创建字符范围",
    "You cannot modify the same flag multiple times in the same definition": "不能在同一个定义中多次修改同一个标志",
    "You cannot nest conditional replacements more than 10 levels deep": "条件替换的嵌套深度不能超过 10 层",
    "You do not appear to have a working internet connection, some features may no longer work.": "您的互联网连接似乎不可用，某些功能可能不再起作用。",
    "You do not have to create an account, just select an existing account from one of the supported service providers.": "您不必创建帐户，只需从支持的服务商中选择一个现有的账号即可。",
    "You have made changes since you last saved, leaving the website will result in a permanent loss of the data.": "您在上次保存之后做了修改，离开网站将导致数据的永久丢失。",
    "You have not added anything to your favorites yet.": "您还没有向收藏夹中添加过任何东西。",
    "You have not created anything yourself yet.": "您还没有创建任何个人内容。",
    "You have not submitted anything to the library yet.": "您还没有向库提交任何东西。",
    "You may not use a null byte in your regex, as that effectively terminates it at that position": "你不能在正则表达式中使用空字节，因为这会有效地终止它在该位置",
    "You must be signed in to vote": "您必须登录后才能投票",
    "Your data can never be recovered again!": "您的数据永远无法恢复！",
    "Your expression caused an unhandled error:": "您的表达式造成了一个未处理的错误：",
    "Your expression took too long to finish and was terminated. Please increase the timeout and try again.": "您的表达式完成时间过长，已被终止。请增加超时时间并重试。",
    "Your pattern contains one or more errors, please see the explanation section above.": "你的模式包含一个或多个错误，请参阅之前的说明。",
    "Your previous best entry has been invalidated and this task is no longer marked as completed for you.": "您之前的最佳参赛作品已失效，并且此任务不再标记为已完成。",
    "Your regex has been saved and may be accessed with this link by anybody you give it to.": "您的正则表达式已保存，任何您提供的人都可以通过此链接访问。",
    "Your regex has been successfully submitted to the library of community patterns!": "您的正则表达式已成功提交到社区模式库！",
    "Your regular expression does not match the subject string.": "您的正则表达式与主题字符串不匹配。",
    "Your search did not match anything": "你的搜索条件未匹配到内容",
    "Your shortest solution thus far is {1} characters long. The overall shortest solution is {2} characters long.": "到目前为止，您的最短解决方案长度为 {1} 个字符。整体最短解决方案长度为 {2} 个字符。",
    "Your tag filtration returned no results.": "你的标签过滤器返回为空。",
    "zero": "0",
    "Zero or more of a": "零个或更多a",
    "Zero or one of a": "零个或一个a"
}