以规则的间隔在字符串中插入分隔符

发布于 2024-09-16 17:58:01 字数 291 浏览 5 评论 0原文

我在 php 中有以下字符串：

$string = 'FEDCBA9876543210';

该字符串可以有 2 个或更多（我的意思是更多）十六进制字符我想将字符串按 2 进行分组，例如：

$output_string = 'FE:DC:BA:98:76:54:32:10';

我想使用正则表达式，我想我看到了一种类似于“递归正则表达式”的方法，但我不记得了。

任何帮助表示赞赏:)

原文

I have the following string in php:

$string = 'FEDCBA9876543210';

The string can be have 2 or more (I mean more) hexadecimal characters
I wanted to group string by 2 like :

$output_string = 'FE:DC:BA:98:76:54:32:10';

I wanted to use regex for that, I think I saw a way to do like "recursive regex" but I can't remember it.

Any help appreciated :)

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

冷血 2024-09-23 17:58:01

如果不需要检查内容，则正则表达式没有用处。

试试这个

$outputString = chunk_split($string, 2, ":");
// generates: FE:DC:BA:98:76:54:32:10:

您可能需要删除最后一个“：”。

或者这个：

$outputString = implode(":", str_split($string, 2));
// generates: FE:DC:BA:98:76:54:32:10

资源：

同一主题：

使用 PHP 将字符串分成相等的部分

If you don't need to check the content, there is no use for regex.

Try this

$outputString = chunk_split($string, 2, ":");
// generates: FE:DC:BA:98:76:54:32:10:

You might need to remove the last ":".

Or this :

$outputString = implode(":", str_split($string, 2));
// generates: FE:DC:BA:98:76:54:32:10

Resources :

On the same topic :

Split string into equal parts using PHP

回复收藏 0 原文

悲歌长辞 2024-09-23 17:58:01

听起来你想要一个像这样的正则表达式：

/([0-9a-f]{2})/${1}:/gi

Which, in PHP is...

<?php
$string = 'FE:DC:BA:98:76:54:32:10';
$pattern = '/([0-9A-F]{2})/gi';
$replacement = '${1}:';
echo preg_replace($pattern, $replacement, $string);
?>

请注意上面的代码当前未经测试。

Sounds like you want a regex like this:

/([0-9a-f]{2})/${1}:/gi

Which, in PHP is...

<?php
$string = 'FE:DC:BA:98:76:54:32:10';
$pattern = '/([0-9A-F]{2})/gi';
$replacement = '${1}:';
echo preg_replace($pattern, $replacement, $string);
?>

Please note the above code is currently untested.

回复收藏 0 原文

爱已欠费 2024-09-23 17:58:01

您可以确保有两个或更多十六进制字符执行此操作：

if (preg_match('!^\d*[A-F]\d*[A-F][\dA-F]*$!i', $string)) {
  ...
}

不需要递归正则表达式。顺便说一下，递归正则表达式是一个矛盾的术语。根据定义，作为常规语言（正则表达式解析）不能递归。

如果您还想将字符与中间的冒号成对分组，暂时忽略两个十六进制字符，请使用：

if (preg_match('!^[\dA-F]{2}(?::[A-F][\dA-F]{2})*$!i', $string)) {
  ...
}

现在，如果您想添加需要两个十六进制字符的条件，请使用正向前瞻：

if (preg_match('!^(?=[\d:]*[A-F][\d:]*[A-F])[\dA-F]{2}(?::[A-F][\dA-F]{2})*$!i', $string)) {
  ...
}

为了解释它是如何工作的，它所做的第一件事就是检查（使用正向前瞻，即 (?=...) 您有零个或多个数字或冒号，后跟一个十六进制字母，后跟零个或多个数字或冒号，然后是一个字母，这将确保表达式中有两个十六进制字母。正向先行之后

是确保字符串是十六进制数字对的原始表达式。

You can make sure there are two or more hex characters doing this:

if (preg_match('!^\d*[A-F]\d*[A-F][\dA-F]*$!i', $string)) {
  ...
}

No need for a recursive regex. By the way, recursive regex is a contradiction in terms. As a regular language (which a regex parses) can't be recursive, by definition.

If you want to also group the characters in pairs with colons in between, ignoring the two hex characters for a second, use:

if (preg_match('!^[\dA-F]{2}(?::[A-F][\dA-F]{2})*$!i', $string)) {
  ...
}

Now if you want to add the condition requiring tow hex characters, use a positive lookahead:

if (preg_match('!^(?=[\d:]*[A-F][\d:]*[A-F])[\dA-F]{2}(?::[A-F][\dA-F]{2})*$!i', $string)) {
  ...
}

To explain how this works, the first thing it does it that it checks (with a positive lookahead ie (?=...) that you have zero or more digits or colons followed by a hex letter followed by zero or more digits or colons and then a letter. This will ensure there will be two hex letters in the expression.

After the positive lookahead is the original expression that makes sure the string is pairs of hex digits.

回复收藏 0 原文

笨死的猪 2024-09-23 17:58:01

递归正则表达式通常是不可能的。您可以在前一个正则表达式的结果上递归地使用正则表达式，但大多数正则表达式语法不允许递归。这就是正则表达式几乎总是不足以解析 HTML 等内容的主要原因。无论如何，您所需要的不需要任何类型的递归性。

简而言之，您想要的就是多次匹配一个组。这非常简单：

preg_match_all("/([a-z0-9]{2})+/i", $string, $matches);

这将填充所有出现的两个十六进制数字（以不区分大小写的方式）。要替换它们，请使用 preg_replace：

echo preg_replace("/([a-z0-9]{2})/i", $string, '\1:');

末尾可能会出现过多的 ':'，您可以使用 substr 将其删除：

echo substr(preg_replace("/([a-z0-9]{2})/i", $string, '\1:'), 0, -1);

Recursive regular expressions are usually not possible. You may use a regular expression recursively on the results of a previous regular expression, but most regular expression grammars will not allow recursivity. This is the main reason why regular expressions are almost always inadequate for parsing stuff like HTML. Anyways, what you need doesn't need any kind of recursivity.

What you want, simply, is to match a group multiple times. This is quite simple:

preg_match_all("/([a-z0-9]{2})+/i", $string, $matches);

This will fill $matches will all occurrences of two hexadecimal digits (in a case-insensitive way). To replace them, use preg_replace:

echo preg_replace("/([a-z0-9]{2})/i", $string, '\1:');

There will probably be one ':' too much at the end, you can strip it with substr:

echo substr(preg_replace("/([a-z0-9]{2})/i", $string, '\1:'), 0, -1);

回复收藏 0 原文

脸赞 2024-09-23 17:58:01

虽然使用 rtrim(chunk_split($string, 2, ':'), ':') 并不是可怕的做法，但我更喜欢使用直接技术，以避免在进行修改后“清理”。

代码：(演示)

$string = 'FEDCBA9876543210';
echo preg_replace('~[\dA-F]{2}(?!$)\K~', ':', $string);

输出：

FE:DC:BA:98:76:54:32:10

不要被正则表达式吓倒。该模式表示：

[\dA-F]{2}   # match exactly two numeric or A through F characters
(?!$)        # that is not located at the end of the string
\K           # restart the fullstring match

当我说“重新启动全字符串匹配”时，我的意思是“忘记以前匹配的字符并从此时开始匹配”。由于 \K 之后没有其他匹配的字符，因此该模式有效地提供了应插入冒号的零宽度位置。这样，替换时就不会丢失原来的字符。

While it is not horrible practice to use rtrim(chunk_split($string, 2, ':'), ':'), I prefer to use direct techniques that avoid "mopping up" after making modifications.

Code: (Demo)

$string = 'FEDCBA9876543210';
echo preg_replace('~[\dA-F]{2}(?!$)\K~', ':', $string);

Output:

FE:DC:BA:98:76:54:32:10

Don't be intimidated by the regex. The pattern says:

[\dA-F]{2}   # match exactly two numeric or A through F characters
(?!$)        # that is not located at the end of the string
\K           # restart the fullstring match

When I say "restart the fullstring match" I mean "forget the previously matched characters and start matching from this point forward". Because there are no additional characters matched after \K, the pattern effectively delivers the zero-width position where the colon should be inserted. In this way, no original characters are lost in the replacement.

回复收藏 0 原文

~没有更多了~