DISABILITARE ADBLOCK

ADBlock sta bloccando alcuni contenuti del sito

ADBlock errore
risultati trovati: 

DOMANDA

Quali sono le migliori pratiche per la creazione di strutture di database di file flat in PHP?

Molti dei framework di file flat PHP più maturi che vedo là fuori tentano di implementare una sintassi di query simile a SQL, che è eccessiva per i miei scopi nella maggior parte dei casi (vorrei usare un database a quel punto).

Esistono trucchi eleganti per ottenere buone prestazioni e funzionalità con un piccolo overhead di codice?

SOLUZIONE

Bene, qual è la natura dei database piatti. Sono grandi o piccoli. Sono matrici semplici con matrici in esse? se è qualcosa di semplice dire userprofiles costruito come tale:

$user = array("name" => "dubayou", 
              "age" => 20,
              "websites" => array("dubayou.com","willwharton.com","codecream.com"),
              "and_one" => "more");

e per salvare o aggiornare il record db per quell'utente.

$dir = "../userdata/";  //make sure to put it bellow what the server can reach.
file_put_contents($dir.$user['name'],serialize($user));

e per caricare il record per l'utente

function &get_user($name){
    return unserialize(file_get_contents("../userdata/".$name));
}

ma ancora questa implementazione varierà sull'applicazione e sulla natura del database di cui hai bisogno.

Se ti va lasciaci una tua opinione

L'articolo ti è stato utile ed è tradotto correttamente?

ALTRI SUGGERIMENTI

Potresti prendere in considerazione SQLite . È quasi semplice come file flat, ma ottieni un motore SQL per le query. funziona bene anche con PHP .

Secondo me, usando un "Database di file flat" nel senso che intendi (e la risposta che hai accettato) non è necessariamente il modo migliore per procedere. Prima di tutto, l'uso di serialize () e unserialize () può causare mal di testa MAJOR se qualcuno entra e modifica il file (in effetti, può inserire il codice arbritrary nel tuo " database " da eseguire ogni volta.)

Personalmente, direi: perché non guardare al futuro? Ci sono state così tante volte che ho avuto problemi perché ho creato il mio "proprietario" file e il progetto è esploso al punto in cui ha bisogno di un database, e sto pensando "Sai, vorrei aver scritto questo per un database per iniziare con" - perché il refactoring del codice richiede troppo tempo e sforzi.

Da questo ho appreso che la mia applicazione sarà messa a punto per il futuro in modo che quando diventa più grande non devo andare e passare giorni a refactoring è la strada da percorrere. Come posso farlo?

SQLite. Funziona come un database, usa SQL ed è abbastanza facile passare a mySQL (soprattutto se stai usando classi astratte per la manipolazione del database come faccio io!)

In effetti, soprattutto con il metodo della "risposta accettata", è possibile ridurre drasticamente l'utilizzo della memoria della tua app (non è necessario caricare tutti i "RECORDS" in PHP)

Un framework che sto prendendo in considerazione sarebbe per una piattaforma di blog. Dal momento che quasi ogni possibile vista dei dati che desideri sarebbe ordinata per data, stavo pensando a questa struttura:

Una directory per nodo del contenuto:

./content/YYYYMMDDHHMMSS/

Sottodirectory di ciascun nodo incluso

/tags  
/authors  
/comments  

Oltre a semplici file di testo nella directory del nodo per contenuti pre e post resi e simili.

Ciò consentirebbe una semplice glob () semplice PHP (e probabilmente un'inversione dell'array dei risultati) per eseguire query su qualsiasi cosa all'interno della struttura del contenuto:

glob("content/*/tags/funny");  

Restituirebbe i percorsi inclusi tutti gli articoli taggati " divertente " ;.

Ecco il codice che usiamo per Lilina:

<?php
/**
 * Handler for persistent data files
 *
 * @author Ryan McCue <cubegames@gmail.com>
 * @package Lilina
 * @version 1.0
 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
 */

/**
 * Handler for persistent data files
 *
 * @package Lilina
 */
class DataHandler {
    /**
     * Directory to store data.
     *
     * @since 1.0
     *
     * @var string
     */
    protected $directory;

    /**
     * Constructor, duh.
     *
     * @since 1.0
     * @uses $directory Holds the data directory, which the constructor sets.
     *
     * @param string $directory 
     */
    public function __construct($directory = null) {
        if ($directory === null)
            $directory = get_data_dir();

        if (substr($directory, -1) != '/')
            $directory .= '/';

        $this->directory = (string) $directory;
    }

    /**
     * Prepares filename and content for saving
     *
     * @since 1.0
     * @uses $directory
     * @uses put()
     *
     * @param string $filename Filename to save to
     * @param string $content Content to save to cache
     */
    public function save($filename, $content) {
        $file = $this->directory . $filename;

        if(!$this->put($file, $content)) {
            trigger_error(get_class($this) . " error: Couldn't write to $file", E_USER_WARNING);
            return false;
        }

        return true;
    }

    /**
     * Saves data to file
     *
     * @since 1.0
     * @uses $directory
     *
     * @param string $file Filename to save to
     * @param string $data Data to save into $file
     */
    protected function put($file, $data, $mode = false) {
        if(file_exists($file) && file_get_contents($file) === $data) {
            touch($file);
            return true;
        }

        if(!$fp = @fopen($file, 'wb')) {
            return false;
        }

        fwrite($fp, $data);
        fclose($fp);

        $this->chmod($file, $mode);
        return true;

    }

    /**
     * Change the file permissions
     *
     * @since 1.0
     *
     * @param string $file Absolute path to file
     * @param integer $mode Octal mode
     */
    protected function chmod($file, $mode = false){
        if(!$mode)
            $mode = 0644;
        return @chmod($file, $mode);
    }

    /**
     * Returns the content of the cached file if it is still valid
     *
     * @since 1.0
     * @uses $directory
     * @uses check() Check if cache file is still valid
     *
     * @param string $id Unique ID for content type, used to distinguish between different caches
     * @return null|string Content of the cached file if valid, otherwise null
     */
    public function load($filename) {
        return $this->get($this->directory . $filename);
    }

    /**
     * Returns the content of the file
     *
     * @since 1.0
     * @uses $directory
     * @uses check() Check if file is valid
     *
     * @param string $id Filename to load data from
     * @return bool|string Content of the file if valid, otherwise null
     */
    protected function get($filename) {
        if(!$this->check($filename))
            return null;

        return file_get_contents($filename);
    }

    /**
     * Check a file for validity
     *
     * Basically just a fancy alias for file_exists(), made primarily to be
     * overriden.
     *
     * @since 1.0
     * @uses $directory
     *
     * @param string $id Unique ID for content type, used to distinguish between different caches
     * @return bool False if the cache doesn't exist or is invalid, otherwise true
     */
    protected function check($filename){
        return file_exists($filename);
    }

    /**
     * Delete a file
     *
     * @param string $filename Unique ID
     */
    public function delete($filename) {
        return unlink($this->directory . $filename);
    }
}

?>

Memorizza ogni voce come un file separato, che abbiamo trovato abbastanza efficiente per l'uso (non vengono caricati dati non necessari ed è più veloce da salvare).

Se si intende utilizzare un file flat per conservare i dati, utilizzare XML per strutturare i dati. PHP ha un parser XML incorporato .

Ho scritto due semplici funzioni progettate per memorizzare i dati in un file. Puoi giudicare da solo se è utile in questo caso. Il punto è salvare una variabile php (se è un array una stringa o un oggetto) in un file.

<?php
function varname(&$var) {
    $oldvalue=$var;
    $var='AAAAB3NzaC1yc2EAAAABIwAAAQEAqytmUAQKMOj24lAjqKJC2Gyqhbhb+DmB9eDDb8+QcFI+QOySUpYDn884rgKB6EAtoFyOZVMA6HlNj0VxMKAGE+sLTJ40rLTcieGRCeHJ/TI37e66OrjxgB+7tngKdvoG5EF9hnoGc4eTMpVUDdpAK3ykqR1FIclgk0whV7cEn/6K4697zgwwb5R2yva/zuTX+xKRqcZvyaF3Ur0Q8T+gvrAX8ktmpE18MjnA5JuGuZFZGFzQbvzCVdN52nu8i003GEFmzp0Ny57pWClKkAy3Q5P5AR2BCUwk8V0iEX3iu7J+b9pv4LRZBQkDujaAtSiAaeG2cjfzL9xIgWPf+J05IQ==';
    foreach($GLOBALS as $var_name => $value) {
        if ($value === 'AAAAB3NzaC1yc2EAAAABIwAAAQEAqytmUAQKMOj24lAjqKJC2Gyqhbhb+DmB9eDDb8+QcFI+QOySUpYDn884rgKB6EAtoFyOZVMA6HlNj0VxMKAGE+sLTJ40rLTcieGRCeHJ/TI37e66OrjxgB+7tngKdvoG5EF9hnoGc4eTMpVUDdpAK3ykqR1FIclgk0whV7cEn/6K4697zgwwb5R2yva/zuTX+xKRqcZvyaF3Ur0Q8T+gvrAX8ktmpE18MjnA5JuGuZFZGFzQbvzCVdN52nu8i003GEFmzp0Ny57pWClKkAy3Q5P5AR2BCUwk8V0iEX3iu7J+b9pv4LRZBQkDujaAtSiAaeG2cjfzL9xIgWPf+J05IQ==')
        {
            $var=$oldvalue;
            return $var_name;
        }
    }
    $var=$oldvalue;
    return false;
}

function putphp(&$var, $file=false)
    {
    $varname=varname($var);
    if(!$file)
    {
        $file=$varname.'.php';
    }
    $pathinfo=pathinfo($file);
    if(file_exists($file))
    {
        if(is_dir($file))
        {
            $file=$pathinfo['dirname'].'/'.$pathinfo['basename'].'/'.$varname.'.php';
        }
    }
    file_put_contents($file,'<?php'."\n\<*>quot;.$varname.'='.var_export($var, true).";\n");
    return true;
}

Se vuoi un risultato leggibile dall'uomo, puoi anche usare questo tipo di file:

ofaurax|27|male|something|
another|24|unknown||
...

In questo modo, hai un solo file, puoi eseguirne il debug (e correggerlo manualmente) facilmente, puoi aggiungere campi in seguito (alla fine di ogni riga) e il codice PHP è semplice (per ogni riga, diviso in base a |.)

Tuttavia, gli svantaggi sono che dovresti analizzare l'intero file per cercare qualcosa (se hai milioni di voci, non va bene) e dovresti gestire il separatore nei dati (ad esempio se il nick è WaR | ordz).

Questo è stimolante come soluzione pratica:
https://github.com/mhgolkar/FlatFire
Utilizza più strategie per la gestione dei dati ...
[Copiato dal file Leggimi]

Gratuito o strutturato o misto

- STRUCTURED
Regular (table, row, column) format.
[DATABASE]
/   \
TX  TableY
    \_____________________________
    |ROW_0 Colum_0 Colum_1 Colum_2|
    |ROW_1 Colum_0 Colum_1 Colum_2|
    |_____________________________|
- FREE
More creative data storing. You can store data in any structure you want for each (free) element, its similar to storing an array with a unique "Id".
[DATABASE]
/   \
EX  ElementY (ID)
    \________________
    |Field_0 Value_0 |
    |Field_1 Value_1 |
    |Field_2 Value_2 |
    |________________|
recall [ID]: get_free("ElementY") --> array([Field_0]=>Value_0,[Field_1]=>Value_1...
- MIXD (Mixed)
Mixed databases can store both free elements and tables.If you add a table to a free db or a free element to a structured db, flat fire will automatically convert FREE or SRCT to MIXD database.
[DATABASE]
/   \
EX  TY

IMHO, hai due opzioni se vuoi evitare qualcosa di homebrewing:

  1. SQLite

    Se hai familiarità con PDO, puoi installare un driver PDO che supporti SQLite. Non l'ho mai usato, ma ho usato un sacco di DOP con MySQL. Ho intenzione di provarlo su un progetto in corso.

  2. XML

    Fatto questo molte volte per quantità relativamente piccole di dati. XMLReader è una classe leggera, read-forward, di tipo cursore. SimpleXML semplifica la lettura di un documento XML in un oggetto che puoi accesso come qualsiasi altra istanza di classe.

Semplicemente sottolineando un potenziale problema con un database di file flat con questo tipo di sistema:

data|some text|more data

row 2 data|bla hbalh|more data

... etc

Il problema è che i dati della cella contengono un " | " o un " \ n " quindi i dati andranno persi. A volte sarebbe più facile dividere per combinazioni di lettere che la maggior parte delle persone non userebbe.

Ad esempio:

Divisore di colonna: # $% (Maiusc + 345)

Divisore di riga: ^ & amp; * (Shift + 678)

File di testo: dati test # $% blah blah # $% ^ & amp; * nuova riga # $% dati nuova riga 2

Quindi usa: esplodi (" # $% " ;, $ data); usa foreach, esplodi di nuovo per separare le colonne

O qualcosa del genere. Inoltre, potrei aggiungere che i database di file flat sono buoni per i sistemi con piccole quantità di dati (cioè meno di 20 righe), ma diventano enormi porci di memoria per database più grandi.

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow