3

Background

I have an array which I create by splitting a string based on every occurrence of 0d0a using preg_split('/(?<=0d0a)(?!$)/').

For example:

$string = "78781110d0a78782220d0a";

will be split into:

Array ( [0] => 78781110d0a [1] => 78782220d0a )

A valid array element has to start with 7878 and end with 0d0a.

The Problem

But sometimes, there's an additional 0d0a in the string which splits into an extra and invalid array element, i.e., that doesn't begin with 7878.

Take this string for example:

$string = "78781110d0a2220d0a78783330d0a";

This is split into:

Array ( [0] => 78781110d0a [1] => 2220d0a [2] => 78783330d0a )

But it should actually be:

Array ( [0] => 78781110d0a2220d0a [1] => 78783330d0a)

My Solution

I've written the following (messy) code to get around this:

    $data = Array('78781110d0a','2220d0a','78783330d0a');
    $i = 0; //count for $data array;
    $j = 0; //count for $dataFixed array;
    $dataFixed = $data;

    foreach($data as $packet) {
        if (substr($packet,0,4) != "7878") { //if packet doesn't start with 7878, do some fixing
            if ($i != 0) { //its the first packet, can't help it!
                $j++;                    

                if ((substr(strtolower($packet), -4, 4) == "0d0a")) { //if the packet doesn't end with 0d0a, its 'mostly' not valid, so discard it
                    $dataFixed[$i-$j] = $dataFixed[$i-$j] . $packet;
                }
                    unset($dataFixed[$i-$j+1]);                        
                    $dataFixed = array_values($dataFixed);
            }
        }
        $i++;
    }

Description

I first copy the array to another array $dataFixed. In a foreach loop of the $data array, I check whether it starts with 7878. If it doesn't, I join it with the previous array in $data. I then unset the current array in $dataFixed and reset the array elements with array_values.

But I'm not very confident about this solution.. Is there a better, more efficient way?

UPDATE

What if the input string doesn't end in 0d0a like its supposed to? It will stick to the previous array element..

For e.g.: in the string 78781110d0a2220d0a78783330d0a0000, 0000 should be separated as another array element.

Improve this question
2
  • 1
    Do these strings have a definitive end? Why don't you latch onto the end of the string: preg_split('/7878([0-9][a-zA-Z])*0d0a$') where $ is the end of the string. This will force 0d0a to be at the end of the line. If you have a long string with no end of line marker then you have a problem as there's no way to tell regex which 0d0a is the RIGHT one to match. In that case, you need to look into regex greed. Commented Apr 12, 2013 at 5:36
  • @Reddox curious if my answer has worked for you, or if you can provide a full data set to test further. Thanks! Commented Apr 17, 2013 at 1:59

3 Answers 3

Reset to default
3

Use another positive lookahead (?=7878) to form:

preg_split('/(?<=0d0a)(?=7878)/',$string)

Note: I removed (?!$) because I wasn't sure what that was for, based on your example data.

For example, this code:

$string = "78781110d0a2220d0a78783330d0a";
$array  = preg_split('/(?<=0d0a)(?=7878)(?!$)/',$string);
print_r($array);

Results in:

Array ( [0] => 78781110d0a2220d0a [1] => 78783330d0a )

UPDATE:

Based on your revised question of having possible random characters at the end of the input string, you can add three lines to make a complete program of:

$string = "78781110d0a2220d0a787830d0a330d0a0000";
$array  = preg_split('/(?<=0d0a)(?=7878)/',$string);
$temp = preg_split('/(7878.*0d0a)/',$array[count($array)-1],null,PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE);
$array[count($array)-1] = $temp[0];
if(count($temp)>1) { $array[] = $temp[1]; }
print_r($array);

We basically do the initial splitting, then split the last element of the resulting array by the expected data format, keeping the delimiter using PREG_SPLIT_DELIM_CAPTURE. The PREG_SPLIT_NO_EMPTY ensures we won't get an empty array element if the input string doesn't end in random characters.

UPDATE 2:

Based on your comment below where it seems you're implying there might be random characters between any of the desired matches, and you want these random characters preserved, you could do this:

$string = "0078781110d0a2220d0a2220d0a0000787830d0a330d0a000078781110d0a2220d0a0000787830d0a330d0a0000";
$split1 = preg_split('/(7878.*?0d0a)/',$string,null,PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE);
$result = array();
foreach($split1 as $e){
  $split2 = preg_split('/(.*0d0a)/',$e,null,PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE);
  foreach($split2 as $el){
    // test if $el doesn't start with 7878 and ends with 0d0a
    if(strpos($el,'7878') !== 0 && substr($el,-4) == '0d0a'){
    //if(preg_match('/^(?!7878).*0d0a$/',$el) === 1){
      $result[ count($result)-1 ] = $result[ count($result)-1 ] . $el;
    } else {
      $result[] = $el;
    }
  }
}
print_r($result);

The strategy employed here is different than above. First we split the input string based on the delimiter that matches your desired data, using the nongreedy regex .*?. At this point we have some strings that contain the ending of a desired value and some garbage at the end, so we split again based on the last occurrence of "0d0a" with the greedy regex .*0d0a. We then append any of those resulting values that don't start with "7878" but end with "0d0a" to the previous value, as this should repair the first and second halves that got split because it contained an extra "0d0a".

I provided two methods for the innermost if statement, one using regular expressions. The regex one is marginally slower in my testing, so I've left that one commented out.

I might still not have your full requirements, so you'll have to let me know if it works and perhaps provided your full dataset.

Improve this answer
Sign up to request clarification or add additional context in comments.

16 Comments

@Reddox wants to keep the delimeter, not discard it.
And then implode('0d0a,7878'...)
@Reddox I really think you should use preg_match_all instead. It's really what you're looking for, and preg_split is more of a fancy solution (finding and splitting delimiters as opposed to matching the data format you're looking for). Otherwise, try stripping the string of the extra characters before doing the split. See how that performs.
I added the condition to my regex to ignore trailing characters: /7878.*?0d0a(?=7878|[^(7878)]*?$)/. See my answer.
@ Reddox I added a section to my answer to address your possible extra characters at the end of the input string. I think you will find this adds a negligible amount of time, keeping this answer the most efficient, and hopefully earning me the answer again. :P If you change the requirements some more, though, you'll want to use @bozdoz's answer. ^_^
|
1

I think you are using a delimiter "0d0a" which also happens to be part of a content! Its not possible to avoid getting junk data as long as delimiter can also be part of content. Somehow delimiter must be unique.

Possible solutions.

  • Change the delimited to something else that doesn't occur as part of your data ( 000000, @!.;)
  • If you are definite about length of text that easy arrange item may have, use it. As per examples its not possible.

Solutions given in answers considering only sample data you have shared. If you are confidant about what will be the content of string, then these solutions given by others are pretty good to use. Otherwise these solutions wont assure you guarantee!

Best solution: Fix right delimiter then use regex or explode whatever you prefer.

Improve this answer

1 Comment

Thanks for the advice, unfortunately, the delimeter isn't in my control! I get this data from a device and process it as best as I can..
1

Why don't you use preg_match_all instead? You can avoid all of the non-capturing groups (the look aheads, look behinds) in order to split the string (which without the non-capturing groups removes the matches), and just find the matches you're looking for:

Updated

<?php
$string = "00787817878110d0a22278780d0a78783330d0a00";
preg_match_all('/7878.*?0d0a(?=7878|[^(7878)]*?$)/', $string, $arr);
print_r($arr);
?>

Gives an array $arr[0] => ( [0] => 787817878110d0a22278780d0a, [1] => 78783330d0a ). Strips leading and trailing garbage characters (whatever doesn't start with 7878 or end with 7878 or 0d0a.

So $arr[0] would be the array of values that you are looking for.

See example on ideone

Works with multiple 7878 values and multiple 0d0a values (even though that's ridiculous).

Update

If splitting is more your style, why not avoid regular expressions altogether? 

<?php
$string = "787817878110d0a22278780d0a78783330d0a";
$arr = explode('0d0a7878', $string);
$string = implode('0d0a,7878', $arr);
$arr = explode(',', $string);
print_r($arr);
?>

Here we split the string by the delimiter 0d0a7878, which is what @CharlieGorichanaz's solution is doing, and props to him for the quick, accurate solution. We then add a comma, because who doesn't love comma separated values? And we explode again on the commas for an array of desired values. Performance-wise, this ought to be faster than using regular expressions. See example.

Improve this answer

13 Comments

I mean first result should be 78781110d0a2220d0a
The values must start with 7878 but it doesn't say they won't ever contain 7878.
@CharlieGorichanaz You gave a working answer, and I +1'd you for it. I still think it's ridiculous to be using preg_split with so many non-capturing groups. It's regex acrobatics, and there's probably a better solution to OP's real problem that is not apparent in the example. I've updated my answer again (just because in principle, I think he's looking for matches, not delimiters).
@Reddox Not sure. Your example string is parsed by both scripts at .01s on ideone.com at least. You'd have to research some benchmarking.
bozdoz: @CharlieGorichanaz 's is roughly 3 times faster at 0.0000160, while preg_match_all averages at 0.0000470. +1 for the idea of matches and not delimeters! I learnt something about preg_match_all today!
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.