Detect EOL type using PHP

Question

Reference: This is a self-answered question. It was meant to share the knowledge, Q&A style.

How do I detect the ty

Answer 1

My answer, because I could make neither ohaal's one or transilvlad's one work, is:

function detect_newline_type($content) {
    $arr = array_count_values(
               explode(
                   ' ',
                   preg_replace(
                       '/[^\r\n]*(\r\n|\n|\r)/',
                       '\1 ',
                       $content
                   )
               )
           );
    arsort($arr);
    return key($arr);
}

Explanation:

The general idea in both proposed solutions is good, but implementation details hinder the usefulness of those answers.

Indeed, the point of this function is to return the kind of newline used in a file, and that newline can either be one or two character long.

This alone renders the use of str_split() incorrect. The only way to cut the tokens correctly is to use a function that cuts a string with variable lengths, based on character detection instead. That is when explode() comes into play.

But to give useful markers to explode, it is necessary to replace the right characters, in the right amount, by the right match. And most of the magic happens in the regular expression.

3 points have to be considered:

1. using .* as suggested by ohaal will not work. While it is true that . will not match newline characters, on a system where \r is not a newline character, or part of a newline character, . will match it incorrectly (reminder: we are detecting newlines because they could be different from the ones on our system. Otherwise there is no point).
2. replacing /[^\r\n]*/ with anything will "work" to make the text vanish, but will be an issue as soon as we want to have a separator (since we remove all characters but the newlines, any character that isn't a newline will be a valid separator). Hence the idea to create a match with the newline, and use a backreference to that match in the replacement.
3. It is possible that in the content, multiple newlines will be in a row. However we do not want to group them in that case, since they will be seen by the rest of the code as different types of newlines. That is why the list of newlines is explicitly stated in the match for the backreference.

Answer 2

If you care just about LF/CRs here is a method I wrote. No need to treat all possible cases of files you'll never ever see.

/**
 * @param  string  $path
 * @param  string  $format  real or human_readable
 * @return false|string
 * @author Sorin-Iulian Trimbitas
 */
public static function getLineBreak(string $path, $format = 'real')
{
    // Hopefully my idea is ok, the rest of the stuff from the internet doesn't seem to work ok in some cases
    // 1. Take the first line of the CSV
    $file = new \SplFileObject($path);
    $line = $file->getCurrentLine();
    // Do we have an empty line?
    if (mb_strlen($line) == 1) {
        // Try the next line
        $file->next();
        $line = $file->getCurrentLine();
        if (mb_strlen($line) == 1) {
            // Give up
            return false;
        }
    }
    // What does we have at its end?
    $last_char = mb_substr($line, -1);
    $penultimate_char = mb_substr($line, -2, 1);
    if ($last_char == "\n" || $last_char == "\r") {
        $real_format = $last_char;
        if ($penultimate_char == "\n" || $penultimate_char == "\r") {
            $real_format = $penultimate_char.$real_format;
        }
        if ($format == 'real') {
            return $real_format;
        }
        return str_replace(["\n", "\r"], ['LF', 'CR'], $real_format);
    }
    return false;
}

Answer 3

Wouldn't it be easier to just replace everything except new lines using regex?

_{The dot matches a single character, without caring what that character is. The only exception are newline characters.}

With that in mind, we do some magic:

$string = 'some string with new lines';
$newlines = preg_replace('/.*/', '', $string);
// $newlines is now filled with new lines, we only need one
$newline = substr($newlines, 0, 1);

Not sure if we can trust regex to do all this, but I don't have anything to test with.

Answer 4

The here already given answers provide the user of enough information. The following code (based on the already given anwers) might help even more: