किसी पाठ फ़ाइल की पंक्तियों की संख्या को कुशलता से गिनना। (200MB +)

Question 1

मुझे अभी पता चला है कि मेरी स्क्रिप्ट मुझे एक घातक त्रुटि देती है:

Fatal error: Allowed memory size of 268435456 bytes exhausted (tried to allocate 440 bytes) in C:\process_txt.php on line 109

वह लाइन यह है:

$lines = count(file($path)) - 1;

इसलिए मुझे लगता है कि फ़ाइल को मेमरी में लोड करने और लाइनों की संख्या की गिनती करने में कठिनाई हो रही है, क्या कोई अधिक कुशल तरीका है कि मैं स्मृति मुद्दों के बिना ऐसा कर सकता हूं?

पाठ फ़ाइलें जिन्हें मुझे 2 एमबी से 500 एमबी तक की लाइनों की संख्या की गणना करने की आवश्यकता है। शायद एक टमटम कभी कभी।

किसी भी मदद के लिए धन्यवाद।

Question 2

यह कम मेमोरी का उपयोग करेगा, क्योंकि यह पूरी फाइल को मेमोरी में लोड नहीं करता है:

$file="largefile.txt";
$linecount = 0;
$handle = fopen($file, "r");
while(!feof($handle)){
  $line = fgets($handle);
  $linecount++;
}

fclose($handle);

echo $linecount;

fgets स्मृति में एक पंक्ति लोड करता है (यदि दूसरा तर्क $length छोड़ दिया जाता है तो यह धारा से तब तक पढ़ता रहेगा जब तक यह पंक्ति के अंत तक नहीं पहुंच जाता, जो हम चाहते हैं)। यह अभी भी PHP के अलावा किसी अन्य चीज़ का उपयोग करने के रूप में जल्दी होने की संभावना नहीं है, अगर आप दीवार के समय के साथ-साथ मेमोरी उपयोग के बारे में परवाह करते हैं।

इसके साथ एकमात्र खतरा यह है कि यदि कोई लाइनें विशेष रूप से लंबी हैं (क्या होगा यदि आप बिना लाइन ब्रेक के 2 जीबी फाइल का सामना करते हैं?)। जिस स्थिति में आप इसे घुटनों में मोड़ना और अंत वर्णों की गिनती करना बेहतर समझते हैं:

$file="largefile.txt";
$linecount = 0;
$handle = fopen($file, "r");
while(!feof($handle)){
  $line = fgets($handle, 4096);
  $linecount = $linecount + substr_count($line, PHP_EOL);
}

fclose($handle);

echo $linecount;

Question 3

fgets()कॉल का एक लूप का उपयोग करना ठीक समाधान है और यह लिखने के लिए सबसे सरल है, हालांकि:

भले ही आंतरिक रूप से फ़ाइल को 8192 बाइट्स के बफर का उपयोग करके पढ़ा जाता है, फिर भी आपके कोड को प्रत्येक पंक्ति के लिए उस फ़ंक्शन को कॉल करना होगा।
यदि आप बाइनरी फ़ाइल पढ़ रहे हैं तो यह संभव है कि एक भी लाइन उपलब्ध मेमोरी से बड़ी हो सकती है।

यह कोड 8kB के प्रत्येक भाग में एक फ़ाइल पढ़ता है और फिर उस चंक के भीतर नए नंबर की संख्या को गिनता है।

function getLines($file)
{
    $f = fopen($file, 'rb');
    $lines = 0;

    while (!feof($f)) {
        $lines += substr_count(fread($f, 8192), "\n");
    }

    fclose($f);

    return $lines;
}

यदि प्रत्येक पंक्ति की औसत लंबाई अधिकतम 4kB है, तो आप पहले से ही फ़ंक्शन कॉल पर बचत करना शुरू कर देंगे, और जब आप अन्य फ़ाइलों को संसाधित करते हैं तो वे जोड़ सकते हैं।

बेंचमार्क

मैंने 1GB फ़ाइल के साथ एक परीक्षण चलाया; यहाँ परिणाम हैं:

             +-------------+------------------+---------+
             | This answer | Dominic's answer | wc -l   |
+------------+-------------+------------------+---------+
| Lines      | 3550388     | 3550389          | 3550388 |
+------------+-------------+------------------+---------+
| Runtime    | 1.055       | 4.297            | 0.587   |
+------------+-------------+------------------+---------+

समय को वास्तविक समय में मापा जाता है, यहां देखें कि वास्तविक अर्थ क्या है

Question 4

सरल उन्मुख वस्तु समाधान

$file = new \SplFileObject('file.extension');

while($file->valid()) $file->fgets();

var_dump($file->key());

अपडेट करें

इसे बनाने का एक और तरीका विधि के साथ PHP_INT_MAXहै SplFileObject::seek।

$file = new \SplFileObject('file.extension', 'r');
$file->seek(PHP_INT_MAX);

echo $file->key() + 1;

Question 5

यदि आप इसे लिनक्स / यूनिक्स होस्ट पर चला रहे हैं, exec()तो कमांड को चलाने के लिए सबसे आसान समाधान उपयोग या समान होगा wc -l $path। बस सुनिश्चित करें कि आपने $pathपहले यह सुनिश्चित किया है कि यह "/ पथ / से / फ़ाइल; rm -rf /" जैसा कुछ नहीं है।

Question 6

एक तेज़ तरीका है जो मैंने पाया कि पूरी फ़ाइल के माध्यम से लूपिंग की आवश्यकता नहीं है

केवल * निक्स सिस्टम पर , विंडोज़ पर एक समान तरीका हो सकता है ...

$file = '/path/to/your.file';

//Get number of lines
$totalLines = intval(exec("wc -l '$file'"));

Question 7

यदि आप PHP 5.5 का उपयोग कर रहे हैं, तो आप एक जनरेटर का उपयोग कर सकते हैं । यह नहीं होगा 5.5 से पहले PHP के किसी भी संस्करण में काम । Php.net से:

"जेनरेटर ओवरहेड या जटिलता को लागू करने वाले वर्ग के बिना सरल पुनरावृत्तियों को लागू करने का एक आसान तरीका प्रदान करता है जो Iterator इंटरफ़ेस को लागू करता है।"

// This function implements a generator to load individual lines of a large file
function getLines($file) {
    $f = fopen($file, 'r');

    // read each line of the file without loading the whole file to memory
    while ($line = fgets($f)) {
        yield $line;
    }
}

// Since generators implement simple iterators, I can quickly count the number
// of lines using the iterator_count() function.
$file = '/path/to/file.txt';
$lineCount = iterator_count(getLines($file)); // the number of lines in the file

Question 8

यह वालेस डी सूजा के समाधान के लिए एक अतिरिक्त है

यह भी गिनती करते समय खाली लाइनों को छोड़ देता है:

function getLines($file)
{
    $file = new \SplFileObject($file, 'r');
    $file->setFlags(SplFileObject::READ_AHEAD | SplFileObject::SKIP_EMPTY | 
SplFileObject::DROP_NEW_LINE);
    $file->seek(PHP_INT_MAX);

    return $file->key() + 1; 
}

Question 9

यदि आप linux में हैं तो आप बस ऐसा कर सकते हैं:

number_of_lines = intval(trim(shell_exec("wc -l ".$file_name." | awk '{print $1}'")));

यदि आप किसी अन्य OS का उपयोग कर रहे हैं तो आपको बस सही कमांड ढूंढनी होगी

सादर

Question 10

private static function lineCount($file) {
    $linecount = 0;
    $handle = fopen($file, "r");
    while(!feof($handle)){
        if (fgets($handle) !== false) {
                $linecount++;
        }
    }
    fclose($handle);
    return  $linecount;     
}

मैं ऊपर के फंक्शन में थोड़ा फिक्स जोड़ना चाहता था ...

एक विशिष्ट उदाहरण में जहां मेरे पास एक फाइल थी जिसमें 'परीक्षण' शब्द था, जिसके परिणामस्वरूप फ़ंक्शन 2 वापस आ गया। इसलिए मुझे एक जांच जोड़ने की जरूरत है कि क्या गलत झूठे लौट आए या नहीं :)

मज़े करो :)

Question 11

निम्नलिखित कोड द्वारा लाइनों की संख्या की गणना की जा सकती है:

<?php
$fp= fopen("myfile.txt", "r");
$count=0;
while($line = fgetss($fp)) // fgetss() is used to get a line from a file ignoring html tags
$count++;
echo "Total number of lines  are ".$count;
fclose($fp);
?>

Question 12

आपके पास कई विकल्प हैं। सबसे पहले स्वीकार्य स्मृति को बढ़ाना है, जो कि दी गई चीजों को करने का सबसे अच्छा तरीका नहीं है, जो कि आप कहते हैं कि फ़ाइल बहुत बड़ी हो सकती है। दूसरा तरीका है कि लाइन द्वारा फाइल लाइन को पढ़ने और काउंटर को बढ़ाने के लिए फिजिट्स का उपयोग किया जाए, जिससे किसी भी तरह की मेमोरी इश्यू नहीं हो।

Question 13

एक और जवाब है कि मुझे लगा कि इस सूची में एक अच्छा जोड़ हो सकता है।

यदि आपने perlइंस्टॉल किया है और PHP में शेल से चीजों को चलाने में सक्षम हैं:

$lines = exec('perl -pe \'s/\r\n|\n|\r/\n/g\' ' . escapeshellarg('largetextfile.txt') . ' | wc -l');

यह यूनिक्स या विंडोज द्वारा बनाई गई फ़ाइलों से अधिकांश पंक्ति विराम संभालना चाहिए।

दो डाउनसाइड्स (कम से कम):

1) यह एक महान विचार नहीं है कि आपकी स्क्रिप्ट इतनी प्रणाली पर निर्भर करती है कि यह चल रहा है (पर्ल और डब्ल्यूसी उपलब्ध होने के लिए यह सुरक्षित नहीं हो सकता है)

2) भागने में बस एक छोटी सी गलती और आपने अपनी मशीन पर एक शेल को एक्सेस सौंप दिया है।

कोडिंग के बारे में मुझे जो कुछ भी पता है (या मुझे लगता है कि मुझे पता है) के साथ, मुझे यह जानकारी कहीं और से मिली:

जॉन रीव अनुच्छेद

Question 14

public function quickAndDirtyLineCounter()
{
    echo "<table>";
    $folders = ['C:\wamp\www\qa\abcfolder\',
    ];
    foreach ($folders as $folder) {
        $files = scandir($folder);
        foreach ($files as $file) {
            if($file == '.' || $file == '..' || !file_exists($folder.'\\'.$file)){
                continue;
            }
                $handle = fopen($folder.'/'.$file, "r");
                $linecount = 0;
                while(!feof($handle)){
                    if(is_bool($handle)){break;}
                    $line = fgets($handle);
                    $linecount++;
                  }
                fclose($handle);
                echo "<tr><td>" . $folder . "</td><td>" . $file . "</td><td>" . $linecount . "</td></tr>";
            }
        }
        echo "</table>";
}

Question 15

प्रभुत्व वाले रॉजर के समाधान के आधार पर, यहाँ मैं उपयोग करता हूँ (यह उपलब्ध होने पर wc का उपयोग करता है, अन्यथा रॉजर के समाधान पर हावी हो जाता है)।

class FileTool
{

    public static function getNbLines($file)
    {
        $linecount = 0;

        $m = exec('which wc');
        if ('' !== $m) {
            $cmd = 'wc -l < "' . str_replace('"', '\\"', $file) . '"';
            $n = exec($cmd);
            return (int)$n + 1;
        }


        $handle = fopen($file, "r");
        while (!feof($handle)) {
            $line = fgets($handle);
            $linecount++;
        }
        fclose($handle);
        return $linecount;
    }
}

https://github.com/lingtalfi/Bat/blob/master/FileTool.php

Question 16

मैं इस पद्धति का उपयोग विशुद्ध रूप से गिनती के लिए करता हूं कि किसी फाइल में कितनी लाइनें हैं। ऐसा करने का नकारात्मक पक्ष यह है कि अन्य उत्तर छंद हैं। मैं अपने दो लाइन समाधान के विपरीत कई लाइनें देख रहा हूं। मुझे लगता है कि कोई भी ऐसा नहीं करता है।

$lines = count(file('your.file'));
echo $lines;

Question 17

सबसे रसीला क्रॉस-प्लेटफ़ॉर्म समाधान जो एक समय में केवल एक लाइन को बफ़र करता है।

$file = new \SplFileObject(__FILE__);
$file->setFlags($file::READ_AHEAD);
$lines = iterator_count($file);

दुर्भाग्य से, हमें READ_AHEADध्वज को स्थापित करना होगा अन्यथा iterator_countअनिश्चित काल के लिए ब्लॉक। अन्यथा, यह वन-लाइनर होगा।

Question 18

केवल लाइनों के उपयोग के लिए:

$handle = fopen("file","r");
static $b = 0;
while($a = fgets($handle)) {
    $b++;
}
echo $b;