Regular expression to reorder string

Question

I have the result of a query with several joins, and in a row I have the concatenation of 2 groups. The line returns me a string as: 1,4|a1,b4.

What I need is to regroup ID and Valor as follows: array( 1 => a1 , 4 => b4 ), or similarly, but without cluttering with the use of explode and recombine the array.

I thought I’d use preg_replace, but I couldn’t get a working rule.

Answer 1

Alternate version, without Regex

Not as an answer to the main problem, but as an alternative for other users who need to parse of strings in this format, follows a solution without Regex:

$in   = '1,4|a1,b4';

$pair = explode('|',$in);
$out  = array_combine(explode(',',$pair[0]),explode(',',$pair[1]));

See working on IDEONE.

As posted by bfavaretto us comments, follows an alternative that reconstructs the data in a single line:

$s='1,4|a1,b4';
$o=call_user_func_array("array_combine", array_chunk(str_word_count($s,1,'1234567890'),2));
print_r( $o );

I replaced this change because I found it interesting as a showcase for some less known PHP functions. For normal use, the explode gets to the point.

See working on IDEONE.

Answer 2

without clutter using explode and recombine the array

I’m sorry to say, but with regex it doesn’t get simpler. In fact, I would say it gets even more "stuffed", and there’s no escape from recombining the array.

I recommend you continue using explode, as suggested in another answer. But just to show how simple it wouldn’t be:

// testando com mais chaves e valores
$in = '1,4,6,9|a1,b4,c6,d9';
if (preg_match_all('/[^|,]+/', $in, $matches)) {
    $len = count($matches[0]) / 2;
    $out = array_combine(array_slice($matches[0], 0, $len), array_slice($matches[0], $len));
    print_r($out);
}

I mean, I’m taking one or more occurrences (+) of anything that nay be it | comma ([^|,]). The problem is that this regex does not check the format and simply accepts anything between commas.

With this, the array $matches contains a single array that has all keys and values. If I did print_r($matches);, the result would be:

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 4
            [2] => 6
            [3] => 9
            [4] => a1
            [5] => b4
            [6] => c6
            [7] => d9
        )

)

So I need to recombine this array: the first half of the elements are the keys, and the second half are the respective values. That’s what the array_combine above is doing. The end result is:

Array
(
    [1] => a1
    [4] => b4
    [6] => c6
    [9] => d9
)

One problem is that regex does not check the format as it could have several | in the string separating the fields (and no comma), or any other combination. Already the solution with explode "guarantees" at least that it must have a | separating the fields.

Of course if the entries are controlled and you are sure that the format is always correct, there is not so much problem. But it is the caveat.

---

But if you want the regex to be more "rigid" and only accept the format indicated, it would have to be something like:

if (preg_match_all('/(?<=^|,)\d+|(?<=[|,])[a-z]\d/', $in, $matches)) {
    // resto do código é igual
}

I’m assuming that keys are always digits (\d+: one or more digits) and the values are always a letter followed by a digit ([a-z]\d). If it’s not, just adjust it (for example, if it’s multiple letters followed by multiple digits, switch to [a-z]+\d+).

Also use lookbehinds, that verify if something occurs before a certain stretch. In the case, before the numbers have the lookbehind (?<=^|,), that checks if before them has the start of the string (^) or a comma. That is, it takes the numbers that are at the beginning (before the |). And before the values (a1, b2, etc) has the lookbehind (?<=[|,]), which checks whether you have a | or a comma.

The array of pouch will have the same format as the previous code, with all keys and then all values.

Of course, this is an option if you want to force a little more rigid verification. But if you "know" that the format of the input string is always valid, just take everything that is between the commas (and then, in my opinion, it is still better to use explode).

Another alternative is to use capture groups for keys and values:

if (preg_match_all('/(?<=^|,)(\d+)|(?<=[|,])([a-z]\d)/', $in, $matches)) {
    $out = array_combine(array_filter($matches[1]), array_filter($matches[2]));
    print_r($out);
}

Now the keys and values are in parentheses, which creates capture groups. In this case, the keys will be in $matches[1] and their values in $matches[2]. But as in each match only one of them is filled, these arrays have several empty strings (make a print_r($matches) to check), so the need to use array_filter to eliminate them.

---

Anyway, although it is possible, has it gotten "better"? Compare with the solution of another answer, which in my opinion was better in several respects: not only shorter (which should not be the main criterion) but also - in my opinion - clearer, simpler and easier to understand and maintain, not to mention that probably is more efficient (these should be the main criteria).

Of course, I haven’t tested the performance, but my suspicion is that explode is more efficient yes, because regex hides an enormous complexity behind (like the fact that need to be compiled, outside the whole structure behind the engine, see here as it is nothing simple). Compare with the explode to see how simple it is.

Remember that smaller code is not necessarily better (and worse than in this case even became smaller).

Answer 3

I believe this expression captures what you want. Just set up the capture groups to extract the data you want.

([1-9][0-9]*,)*[1-9][0-9]*\|[a-z]*(,[a-z]+)*

An important detail is that there is no way, using regular expression, to ensure that the left side has the same amount of items as the right side. That would be work for at least one Grammar, Free of Context.