Sostituzione Tag con Comprende con espressioni regolari in PHP

Question

Ho bisogno di leggere una stringa, rilevare un {var}, e poi fare un file_get_contents ( 'VAR.php') al posto di {var}. Il "VAR" può essere chiamato qualsiasi cosa, come TEST, o modulo di contatto, ecc io non voglio sapere che cosa è VAR - non fare una condizione di hard-coded, ma basta vedere un tag alfanumerico maiuscolo circondato da graffe e basta fare un file_get_contents () per caricarla.

Lo so che ho bisogno di usare preg_match e preg_replace, ma sto inciampando attraverso le espressioni regolari su questo.

Come è utile? E 'utile in aggancio WordPress.

Answer 1

Orion sopra ha una soluzione giusta, ma non è proprio necessario utilizzare una funzione di callback nel tuo caso semplice.

Supponendo che i nomi dei file sono A-Z + trattini si può fare in 1 linea utilizzando PHP / e bandiera nel regex:

$str = preg_replace('/{([-A-Z]+)}/e', 'file_get_contents(\'$1.html\')', $str);

Questa sarà sostituire qualsiasi istanza di {var} con il contenuto di VAR.html. Si potrebbe precedere un percorso nel secondo termine se è necessario specificare una particolare directory.

Ci sono le stesse preoccupazioni di sicurezza vaghi come sopra indicato, ma non riesco a pensare a niente di specifico.

Answer 2

È necessario fare una serie di cose. Sto supponendo che si può fare la noia per ottenere i dati pagina che si desidera pre-elaborazione in una stringa.

1. In primo luogo, è necessario l'espressione regolare per abbinare in modo corretto. Questo dovrebbe essere abbastanza facile con qualcosa di simile /{\w+}/.

2. Avanti avrete bisogno di utilizzare tutte le bandiere per funzione preg_match per ottenere la posizione offset i dati della pagina. Questo offset vi permetterà di dividere la stringa nella prima, di corrispondenza, e dopo le parti della partita.

3. Una volta che avete le 3 parti, sarà necessario eseguire il vostro comprendono, e attaccarli di nuovo insieme.

4. Schiuma, sciacquare, ripetere.

5. Fermarsi quando non si trovano più variabili.

Questa non è molto efficiente, e ci sono modi probabilmente migliori. Si potrebbe desiderare di prendere in considerazione facendo un preg_split invece, la scissione in /[{}]/. Non importa come la tagli si sta assumendo che ci si può fidare dei dati in entrata, e questo semplificherà l'intero processo molto. Per fare questo, mi piacerebbe lay out il codice in questo modo:

1. Prendete il contenuto e dividerlo in questo modo: $parts = preg_split('/[{}]/', $page_string);

2. Scrivi una funzione ricorsiva sopra le parti con i seguenti criteri:

   • Arresto quando la lunghezza di arg è <3
   • Else, restituire un nuovo array composto da
   • $ arg [0]. load_data ($ arg [1]). $ Arg [2]
   • , più tutto ciò che è a sinistra in $ argv [3 ...]

3. Esegui la funzione oltre $ parti.

Answer 3

È possibile farlo senza regex (Dio non voglia), qualcosa come:

//return true if $str ends with $sub
function endsWith($str,$sub) {
    return ( substr( $str, strlen( $str ) - strlen( $sub ) ) === $sub );
}

$theStringWithVars = "blah.php cool.php awesome.php";
$sub = '.php';
$splitStr = split(" ", $theStringWithVars);
for($i=0;$i<count($splitStr);$i++) {
    if(endsWith(trim($splitStr[$i]),$sub)) {
        //file_get_contents($splitStr[$i]) etc...
    }    
}

Answer 4

Al largo della parte superiore della mia testa, si desidera che questo:

// load the "template" file
$input = file_get_contents($template_file_name);

// define a callback. Each time the regex matches something, it will call this function.
// whatever this function returns will be inserted as the replacement
function replaceCallback($matches){
  // match zero will be the entire match - eg {FOO}. 
  // match 1 will be just the bits inside the curly braces because of the grouping parens in the regex - eg FOO
  // convert it to lowercase and append ".html", so you're loading foo.html

  // then return the contents of that file.
  // BEWARE. GIANT MASSIVE SECURITY HOLES ABOUND. DO NOT DO THIS
  return file_get_contents( strtolower($matches[1]) . ".html" );
};
// run the actual replace method giving it our pattern, the callback, and the input file contents
$output = preg_replace_callback("\{([-A-Z]+)\}", replaceCallback, $input);

// todo: print the output

Ora ti spiego l'espressione regolare

 \{([-A-Z]+)\}

• Il \{ e \} solo dicono che per abbinare le parentesi graffe. Sono necessari i tagli, come { e } sono caratteri speciali, quindi hanno bisogno di fuggire.
• Il ( e ) creare un raggruppamento. Fondamentalmente questo ti permette di estrarre particolari parti della partita. Io lo uso in funzione di cui sopra per abbinare appena le cose all'interno delle parentesi, senza corrispondere le parentesi graffe stessi. Se non ho fatto questo, allora avrei bisogno di striscia la { e } fuori della partita, che sarebbe fastidioso
• Il [-A-Z] dice "corrisponde ad alcun carattere maiuscolo, o un -
• Il + dopo la [-A-Z] significa che dobbiamo avere almeno 1 carattere, ma possiamo avere fino a qualsiasi numero.

Answer 5

Comparativamente parlando, espressioni regolari sono costosi. Mentre si potrebbe averne bisogno per capire quali file da caricare, certamente non ne hanno bisogno per fare la sostituzione, e probabilmente non dovrebbe usare le espressioni regolari. Dopo tutto, si sa esattamente cosa si sta sostituendo così perché avete bisogno di ricerca fuzzy?

Utilizzare un array associativo e str_replace per fare le vostre sostituzioni. str_replace supporta array per fare sostituzioni multiple in una sola volta. Una sostituzione di linea, nessun cicli.

Ad esempio:

$substitutions = array('{VAR}'=>file_get_contents('VAR.php'),
'{TEST}'=>file_get_contents('TEST.php'),
...
);

$outputContents = str_replace( array_keys($substitutions), $substitutions, $outputContents);