Comment traiter une chaîne massive de 30 millions de caractères sans manquer de mémoire ?

Analyse d'une chaîne massive de 30 millions de caractères

Les rencontres avec des erreurs « mémoire insuffisante » peuvent être déroutantes lorsqu'il s'agit de volumes de données importants. Considérez ce scénario : vous récupérez un fichier CSV d'environ 30,5 millions de caractères à l'aide de curl. Tenter de disséquer ces données en un tableau de lignes à l'aide de méthodes courantes telles que l'explosion de r et n déclenche la redoutable erreur d'allocation de mémoire. Cela pose la question : comment éviter de telles erreurs tout en manipulant efficacement des données volumineuses ?

Stratégies pour éviter les erreurs d'allocation de mémoire

Comme astucieusement souligné dans les réponses précédentes :

1. Évitez de stocker l'intégralité de l'ensemble de données en mémoire : Tenter de charger l'intégralité de la chaîne de 30 millions de caractères en mémoire est intrinsèquement peu pratique.
2. Exploitez CURLOPT_FILE : Une approche alternative consiste à utiliser l'option CURLOPT_FILE de curl pour diriger les données directement vers un fichier, permettant ainsi un traitement en temps réel sans avoir besoin de stockage intermédiaire en mémoire.

Approche alternative : utilisation d'un wrapper de flux personnalisé.

Bien que CURLOPT_FILE résolve efficacement le problème en écrivant des données dans un fichier, certains scénarios peuvent nécessiter un traitement en mémoire. Dans de tels cas, l'implémentation d'un wrapper de flux personnalisé fournit une solution viable.

1. Implémentation du Stream Wrapper : Définissez une classe de wrapper de flux qui définit les méthodes stream_open() et stream_write().
2. Extraction de ligne dynamique : Dans stream_write(), utilisez éclater("n") pour isoler les lignes des morceaux de données au fur et à mesure de leur arrivée, en maintenant un tampon pour les lignes incomplètes reportées des morceaux précédents.
3. Effectuer le traitement : Effectuer le traitement nécessaire sur les lignes extraites dans stream_write(). Cela peut impliquer la validation, le filtrage ou l'insertion des données dans une base de données.

Exemple de Stream Wrapper :

class MyStream {
    protected $buffer;

    function stream_open($path, $mode, $options, &$opened_path) {
        return true;
    }

    public function stream_write($data) {
        $lines = explode("\n", $data);
        $lines[0] = $this->buffer . $lines[0];
        $this->buffer = $lines[count($lines)-1];
        unset($lines[count($lines)-1]);

        // Perform your processing here
        var_dump($lines);
        echo '<hr />';

        return strlen($data);
    }
}

Enregistrement du Stream Wrapper :

stream_wrapper_register("test", "MyStream");

Combinaison avec Curl :

// Configure curl using CURLOPT_FILE
curl_setopt($ch, CURLOPT_FILE, fopen("test://MyTestVariableInMemory", "r+"));

// Execute curl to retrieve data from the source
curl_exec($ch);

// Close the stream
fclose($fp);

En employant un wrapper de flux personnalisé, vous pouvez traiter de grands ensembles de données en morceaux gérables sans rencontrer erreurs d'allocation de mémoire. Cette méthode permet de traiter les données au fur et à mesure de leur arrivée, garantissant une utilisation efficace de la mémoire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!