Come ottenere una sottostringa tra due stringhe in PHP?

Ho bisogno di una funzione che restituisca la sottostringa tra due parole (o due caratteri). Mi chiedo se esiste una funzione php che lo raggiunga. Non voglio pensare a regex (beh, potrei farne uno ma davvero non credo sia il modo migliore di procedere). Pensiero strpose substrfunzioni. Ecco un esempio:

$string = "foo I wanna a cake foo";

Chiamiamo la funzione: $substring = getInnerSubstring($string,"foo");
restituisce: "Voglio una torta".

Grazie in anticipo.

Aggiornamento: Bene, fino ad ora, posso solo ottenere una sottostringa tra due parole in una sola stringa, mi permetti di farmi andare un po 'più lontano e chiedere se posso estendere l'uso di getInnerSubstring($str,$delim)per ottenere eventuali stringhe che sono tra il valore delimitato, esempio:

$string =" foo I like php foo, but foo I also like asp foo, foo I feel hero  foo";

Ottengo un array come {"I like php", "I also like asp", "I feel hero"}.

Se le stringhe sono diverse (ad es. [Foo] & [/ foo]), dai un'occhiata a questo post di Justin Cook. Copio il suo codice qui sotto:

function get_string_between($string, $start, $end){
    $string = ' ' . $string;
    $ini = strpos($string, $start);
    if ($ini == 0) return '';
    $ini += strlen($start);
    $len = strpos($string, $end, $ini) - $ini;
    return substr($string, $ini, $len);
}

$fullstring = 'this is my [tag]dog[/tag]';
$parsed = get_string_between($fullstring, '[tag]', '[/tag]');

echo $parsed; // (result = dog)

Le espressioni regolari sono la strada da percorrere:

$str = 'before-str-after';
if (preg_match('/before-(.*?)-after/', $str, $match) == 1) {
    echo $match[1];
}

onlinePhp

function getBetween($string, $start = "", $end = ""){
    if (strpos($string, $start)) { // required if $start not exist in $string
        $startCharCount = strpos($string, $start) + strlen($start);
        $firstSubStr = substr($string, $startCharCount, strlen($string));
        $endCharCount = strpos($firstSubStr, $end);
        if ($endCharCount == 0) {
            $endCharCount = strlen($firstSubStr);
        }
        return substr($firstSubStr, 0, $endCharCount);
    } else {
        return '';
    }
}

Esempio di utilizzo:

echo getBetween("abc","a","c"); // returns: 'b'

echo getBetween("hello","h","o"); // returns: 'ell'

echo getBetween("World","a","r"); // returns: ''

function getInnerSubstring($string,$delim){
    // "foo a foo" becomes: array(""," a ","")
    $string = explode($delim, $string, 3); // also, we only need 2 items at most
    // we check whether the 2nd is set and return it, otherwise we return an empty string
    return isset($string[1]) ? $string[1] : '';
}

Esempio di utilizzo:

var_dump(getInnerSubstring('foo Hello world foo','foo'));
// prints: string(13) " Hello world "

Se si desidera rimuovere gli spazi bianchi circostanti, utilizzare trim. Esempio:

var_dump(trim(getInnerSubstring('foo Hello world foo','foo')));
// prints: string(11) "Hello world"

function getInbetweenStrings($start, $end, $str){
    $matches = array();
    $regex = "/$start([a-zA-Z0-9_]*)$end/";
    preg_match_all($regex, $str, $matches);
    return $matches[1];
}

per esempio, vuoi la matrice di stringhe (chiavi) tra @@ nel seguente esempio, dove '/' non rientra tra

$str = "C://@@ad_custom_attr1@@/@@upn@@/@@samaccountname@@";
$str_arr = getInbetweenStrings('@@', '@@', $str);

print_r($str_arr);

usa due volte la funzione strstr php.

$value = "This is a great day to be alive";
$value = strstr($value, "is"); //gets all text from needle on
$value = strstr($value, "be", true); //gets all text before needle
echo $value;

uscite: "is a great day to"

Mi piacciono le soluzioni di espressione regolare ma nessuna delle altre mi va bene.

Se sai che ci sarà solo 1 risultato puoi usare quanto segue:

$between = preg_replace('/(.*)BEFORE(.*)AFTER(.*)/sm', '\2', $string);

Modificare PRIMA e DOPO i delimitatori desiderati.

Ricorda inoltre che questa funzione restituirà l'intera stringa nel caso in cui nulla corrisponda.

Questa soluzione è multilinea ma puoi giocare con i modificatori in base alle tue esigenze.

Non è un php pro. ma di recente mi sono imbattuto anche in questo muro e questo è quello che mi è venuto in mente.

function tag_contents($string, $tag_open, $tag_close){
   foreach (explode($tag_open, $string) as $key => $value) {
       if(strpos($value, $tag_close) !== FALSE){
            $result[] = substr($value, 0, strpos($value, $tag_close));;
       }
   }
   return $result;
}

$string = "i love cute animals, like [animal]cat[/animal],
           [animal]dog[/animal] and [animal]panda[/animal]!!!";

echo "<pre>";
print_r(tag_contents($string , "[animal]" , "[/animal]"));
echo "</pre>";

//result
Array
(
    [0] => cat
    [1] => dog
    [2] => panda
)

Se stai usando foocome delimitatore, guardaexplode()

<?php
  function getBetween($content,$start,$end){
    $r = explode($start, $content);
    if (isset($r[1])){
        $r = explode($end, $r[1]);
        return $r[0];
    }
    return '';
  }
?>

Esempio:

<?php 
  $content = "Try to find the guy in the middle with this function!";
  $start = "Try to find ";
  $end = " with this function!";
  $output = getBetween($content,$start,$end);
  echo $output;
?>

Questo restituirà "il ragazzo nel mezzo".

Se si hanno più ricorrenze da una singola stringa e si hanno diversi modelli [inizio] e [\ fine]. Ecco una funzione che genera un array.

function get_string_between($string, $start, $end){
    $split_string       = explode($end,$string);
    foreach($split_string as $data) {
         $str_pos       = strpos($data,$start);
         $last_pos      = strlen($data);
         $capture_len   = $last_pos - $str_pos;
         $return[]      = substr($data,$str_pos+1,$capture_len);
    }
    return $return;
}

Ecco una funzione

function getInnerSubstring($string, $boundstring, $trimit=false) {
    $res = false;
    $bstart = strpos($string, $boundstring);
    if ($bstart >= 0) {
        $bend = strrpos($string, $boundstring);
        if ($bend >= 0 && $bend > $bstart)
            $res = substr($string, $bstart+strlen($boundstring), $bend-$bstart-strlen($boundstring));
    }
    return $trimit ? trim($res) : $res;
}

Usalo come

$string = "foo I wanna a cake foo";
$substring = getInnerSubstring($string, "foo");

echo $substring;

Output (nota che restituisce spazi davanti e alla e della tua stringa se esistono)

Voglio una torta

Se vuoi tagliare il risultato usa la funzione like

$substring = getInnerSubstring($string, "foo", true);

Risultato : questa funzione restituirà false se $boundstringnon è stata trovata in $stringo se $boundstringesiste solo una volta in $string, altrimenti restituisce una sottostringa tra la prima e l'ultima occorrenza di $boundstringin $string.

• strpos ()
• strrpos ()
• substr ()
• trim ()

Miglioramento della risposta di Alejandro . Puoi lasciare gli argomenti $starto $endvuoti e utilizzerà l'inizio o la fine della stringa.

echo get_string_between("Hello my name is bob", "my", ""); //output: " name is bob"

private function get_string_between($string, $start, $end){ // Get
    if($start != ''){ //If $start is empty, use start of the string
        $string = ' ' . $string;
        $ini = strpos($string, $start);
        if ($ini == 0) return '';
        $ini += strlen($start);
    }
    else{
        $ini = 0;
    }

    if ($end == '') { //If $end is blank, use end of string
        return substr($string, $ini);
    }
    else{
        $len = strpos($string, $end, $ini) - $ini; //Work out length of string
        return substr($string, $ini, $len);
    }
}

Uso:

<?php

$str = "...server daemon started with pid=6849 (parent=6848).";
$from = "pid=";
$to = "(";

echo getStringBetween($str,$from,$to);

function getStringBetween($str,$from,$to)
{
    $sub = substr($str, strpos($str,$from)+strlen($from),strlen($str));
    return substr($sub,0,strpos($sub,$to));
}

?>

Codice leggermente migliorato da GarciaWebDev e Henry Wang. Se viene specificato $ start o $ end vuoti, la funzione restituisce valori dall'inizio o alla fine della stringa $. È disponibile anche l'opzione inclusiva, che si desideri includere o meno i risultati della ricerca:

function get_string_between ($string, $start, $end, $inclusive = false){
    $string = " ".$string;

    if ($start == "") { $ini = 0; }
    else { $ini = strpos($string, $start); }

    if ($end == "") { $len = strlen($string); }
    else { $len = strpos($string, $end, $ini) - $ini;}

    if (!$inclusive) { $ini += strlen($start); }
    else { $len += strlen($end); }

    return substr($string, $ini, $len);
}

Devo aggiungere qualcosa al post di Julius Tilvikas. Ho cercato una soluzione come questa che ha descritto nel suo post. Ma penso che ci sia un errore. Non ottengo davvero la stringa tra due stringhe, ne ottengo di più con questa soluzione, perché devo sottrarre la lunghezza della stringa iniziale. Quando faccio questo, ottengo davvero la stringa tra due stringhe.

Ecco i miei cambiamenti alla sua soluzione:

function get_string_between ($string, $start, $end, $inclusive = false){
    $string = " ".$string;

    if ($start == "") { $ini = 0; }
    else { $ini = strpos($string, $start); }

    if ($end == "") { $len = strlen($string); }
    else { $len = strpos($string, $end, $ini) - $ini - strlen($start);}

    if (!$inclusive) { $ini += strlen($start); }
    else { $len += strlen($end); }

    return substr($string, $ini, $len);
}

Greetz

V

Prova questo, per me funziona, ottieni i dati tra le parole di prova .

$str = "Xdata test HD01 test 1data";  
$result = explode('test',$str);   
print_r($result);
echo $result[1];

Nello strposstile di PHP questo tornerà falsese il segno di partenza smo il segno di fineem non vengono trovati.

Questo risultato ( false) è diverso da una stringa vuota che è ciò che ottieni se non c'è nulla tra i segni di inizio e fine.

function between( $str, $sm, $em )
{
    $s = strpos( $str, $sm );
    if( $s === false ) return false;
    $s += strlen( $sm );
    $e = strpos( $str, $em, $s );
    if( $e === false ) return false;
    return substr( $str, $s, $e - $s );
}

La funzione restituirà solo la prima corrispondenza.

È ovvio, ma vale la pena ricordare che la funzione cercherà prima sme poi em.

Ciò implica che potresti non ottenere il risultato / comportamento desiderato se emprima devi cercare e poi cercare la stringa al contrario sm.

Questa è la funzione che sto usando per questo. Ho combinato due risposte in una funzione per delimitatori singoli o multipli.

function getStringBetweenDelimiters($p_string, $p_from, $p_to, $p_multiple=false){
    //checking for valid main string  
    if (strlen($p_string) > 0) {
        //checking for multiple strings 
        if ($p_multiple) {
            // getting list of results by end delimiter
            $result_list = explode($p_to, $p_string);
            //looping through result list array 
            foreach ( $result_list AS $rlkey => $rlrow) {
                // getting result start position
                $result_start_pos   = strpos($rlrow, $p_from);
                // calculating result length
                $result_len         =  strlen($rlrow) - $result_start_pos;

                // return only valid rows
                if ($result_start_pos > 0) {
                    // cleanying result string + removing $p_from text from result
                    $result[] =   substr($rlrow, $result_start_pos + strlen($p_from), $result_len);                 
                }// end if 
            } // end foreach 

        // if single string
        } else {
            // result start point + removing $p_from text from result
            $result_start_pos   = strpos($p_string, $p_from) + strlen($p_from);
            // lenght of result string
            $result_length      = strpos($p_string, $p_to, $result_start_pos);
            // cleaning result string
            $result             = substr($p_string, $result_start_pos+1, $result_length );
        } // end if else 
    // if empty main string
    } else {
        $result = false;
    } // end if else 

    return $result;


} // end func. get string between

Per uso semplice (restituisce due):

$result = getStringBetweenDelimiters(" one two three ", 'one', 'three');

Per ottenere ogni riga in una tabella per ottenere l'array:

$result = getStringBetweenDelimiters($table, '<tr>', '</tr>', true);

Io uso

if (count(explode("<TAG>", $input))>1){
      $content = explode("</TAG>",explode("<TAG>", $input)[1])[0];
}else{
      $content = "";
}

Sottotitoli <TAG> per qualsiasi delimitatore desiderato.

una versione modificata di ciò che ha messo Alejandro García Iglesias.

Ciò consente di scegliere una posizione specifica della stringa che si desidera ottenere in base al numero di volte in cui viene trovato il risultato.

function get_string_between_pos($string, $start, $end, $pos){
    $cPos = 0;
    $ini = 0;
    $result = '';
    for($i = 0; $i < $pos; $i++){
      $ini = strpos($string, $start, $cPos);
      if ($ini == 0) return '';
      $ini += strlen($start);
      $len = strpos($string, $end, $ini) - $ini;
      $result = substr($string, $ini, $len);
      $cPos = $ini + $len;
    }
    return $result;
  }

utilizzo:

$text = 'string has start test 1 end and start test 2 end and start test 3 end to print';

//get $result = "test 1"
$result = $this->get_string_between_pos($text, 'start', 'end', 1);

//get $result = "test 2"
$result = $this->get_string_between_pos($text, 'start', 'end', 2);

//get $result = "test 3"
$result = $this->get_string_between_pos($text, 'start', 'end', 3);

strpos ha un input opzionale aggiuntivo per iniziare la sua ricerca in un punto specifico. quindi memorizzo la posizione precedente in $ cPos, quindi quando il ciclo for verifica di nuovo, inizia alla fine del punto in cui era stato interrotto.

La stragrande maggioranza delle risposte qui non risponde alla parte modificata, immagino che siano state aggiunte prima. Può essere fatto con regex, come menziona una risposta. Ho avuto un approccio diverso.

Questa funzione cerca $ string e trova la prima stringa tra $ start e $ end stringhe, iniziando dalla posizione $ offset. Quindi aggiorna la posizione $ offset in modo che punti all'inizio del risultato. Se $ includeDelimiters è true, include i delimitatori nel risultato.

Se la stringa $ start o $ end non viene trovata, restituisce null. Restituisce inoltre null se $ stringa, $ inizio o $ fine sono una stringa vuota.

function str_between(string $string, string $start, string $end, bool $includeDelimiters = false, int &$offset = 0): ?string
{
    if ($string === '' || $start === '' || $end === '') return null;

    $startLength = strlen($start);
    $endLength = strlen($end);

    $startPos = strpos($string, $start, $offset);
    if ($startPos === false) return null;

    $endPos = strpos($string, $end, $startPos + $startLength);
    if ($endPos === false) return null;

    $length = $endPos - $startPos + ($includeDelimiters ? $endLength : -$startLength);
    if (!$length) return '';

    $offset = $startPos + ($includeDelimiters ? 0 : $startLength);

    $result = substr($string, $offset, $length);

    return ($result !== false ? $result : null);
}

La seguente funzione trova tutte le stringhe che si trovano tra due stringhe (senza sovrapposizioni). Richiede la funzione precedente e gli argomenti sono gli stessi. Dopo l'esecuzione, $ offset punta all'inizio dell'ultima stringa di risultati trovata.

function str_between_all(string $string, string $start, string $end, bool $includeDelimiters = false, int &$offset = 0): ?array
{
    $strings = [];
    $length = strlen($string);

    while ($offset < $length)
    {
        $found = str_between($string, $start, $end, $includeDelimiters, $offset);
        if ($found === null) break;

        $strings[] = $found;
        $offset += strlen($includeDelimiters ? $found : $start . $found . $end); // move offset to the end of the newfound string
    }

    return $strings;
}

Esempi:

str_between_all('foo 1 bar 2 foo 3 bar', 'foo', 'bar')dà [' 1 ', ' 3 '].

str_between_all('foo 1 bar 2', 'foo', 'bar')dà [' 1 '].

str_between_all('foo 1 foo 2 foo 3 foo', 'foo', 'foo')dà [' 1 ', ' 3 '].

str_between_all('foo 1 bar', 'foo', 'foo')dà [].

Uso:

function getdatabetween($string, $start, $end){
    $sp = strpos($string, $start)+strlen($start);
    $ep = strpos($string, $end)-strlen($start);
    $data = trim(substr($string, $sp, $ep));
    return trim($data);
}
$dt = "Find string between two strings in PHP";
echo getdatabetween($dt, 'Find', 'in PHP');

Ho avuto dei problemi con la funzione get_string_between (), usata qui. Quindi sono arrivato con la mia versione. Forse potrebbe aiutare le persone nello stesso caso del mio.

protected function string_between($string, $start, $end, $inclusive = false) { 
   $fragments = explode($start, $string, 2);
   if (isset($fragments[1])) {
      $fragments = explode($end, $fragments[1], 2);
      if ($inclusive) {
         return $start.$fragments[0].$end;
      } else {
         return $fragments[0];
      }
   }
   return false;
}

li ho scritti qualche tempo fa, l'ho trovato molto utile per una vasta gamma di applicazioni.

<?php

// substr_getbykeys() - Returns everything in a source string that exists between the first occurance of each of the two key substrings
//          - only returns first match, and can be used in loops to iterate through large datasets
//          - arg 1 is the first substring to look for
//          - arg 2 is the second substring to look for
//          - arg 3 is the source string the search is performed on.
//          - arg 4 is boolean and allows you to determine if returned result should include the search keys.
//          - arg 5 is boolean and can be used to determine whether search should be case-sensative or not.
//

function substr_getbykeys($key1, $key2, $source, $returnkeys, $casematters) {
    if ($casematters === true) {
        $start = strpos($source, $key1);
        $end = strpos($source, $key2);
    } else {
        $start = stripos($source, $key1);
        $end = stripos($source, $key2);
    }
    if ($start === false || $end === false) { return false; }
    if ($start > $end) {
        $temp = $start;
        $start = $end;
        $end = $temp;
    }
    if ( $returnkeys === true) {
        $length = ($end + strlen($key2)) - $start;
    } else {
        $start = $start + strlen($key1);
        $length = $end - $start;
    }
    return substr($source, $start, $length);
}

// substr_delbykeys() - Returns a copy of source string with everything between the first occurance of both key substrings removed
//          - only returns first match, and can be used in loops to iterate through large datasets
//          - arg 1 is the first key substring to look for
//          - arg 2 is the second key substring to look for
//          - arg 3 is the source string the search is performed on.
//          - arg 4 is boolean and allows you to determine if returned result should include the search keys.
//          - arg 5 is boolean and can be used to determine whether search should be case-sensative or not.
//

function substr_delbykeys($key1, $key2, $source, $returnkeys, $casematters) {
    if ($casematters === true) {
        $start = strpos($source, $key1);
        $end = strpos($source, $key2);
    } else {
        $start = stripos($source, $key1);
        $end = stripos($source, $key2);
    }
    if ($start === false || $end === false) { return false; }
    if ($start > $end) {
        $temp = $start; 
        $start = $end;
        $end = $temp;
    }
    if ( $returnkeys === true) {
        $start = $start + strlen($key1);
        $length = $end - $start;
    } else {
        $length = ($end + strlen($key2)) - $start;  
    }
    return substr_replace($source, '', $start, $length);
}
?>

Con qualche errore di cattura. Nello specifico, la maggior parte delle funzioni presentate richiede l'esistenza di $ end, mentre in realtà nel mio caso avevo bisogno che fosse facoltativo. Utilizzare this is $ end è facoltativo e valutare FALSE se $ start non esiste affatto:

function get_string_between( $string, $start, $end ){
    $string = " " . $string;
    $start_ini = strpos( $string, $start );
    $end = strpos( $string, $end, $start+1 );
    if ($start && $end) {
        return substr( $string, $start_ini + strlen($start), strlen( $string )-( $start_ini + $end ) );
    } elseif ( $start && !$end ) {
        return substr( $string, $start_ini + strlen($start) );
    } else {
        return FALSE;
    }

}

La versione UTF-8 della risposta di @Alejandro Iglesias funzionerà con caratteri non latini:

function get_string_between($string, $start, $end){
    $string = ' ' . $string;
    $ini = mb_strpos($string, $start, 0, 'UTF-8');
    if ($ini == 0) return '';
    $ini += mb_strlen($start, 'UTF-8');
    $len = mb_strpos($string, $end, $ini, 'UTF-8') - $ini;
    return mb_substr($string, $ini, $len, 'UTF-8');
}

$fullstring = 'this is my [tag]dog[/tag]';
$parsed = get_string_between($fullstring, '[tag]', '[/tag]');

echo $parsed; // (result = dog)

Ho la migliore soluzione per questo da tonyspiro

function getBetween($content,$start,$end){
   $r = explode($start, $content);
   if (isset($r[1])){
       $r = explode($end, $r[1]);
       return $r[0];
   }
   return '';
}

Può essere facilmente fatto usando questa piccola funzione:

function getString($string, $from, $to) {
    $str = explode($from, $string);
    $str = explode($to, $str[1]);
    return $s[0];
}
$myString = "<html>Some code</html>";
print getString($myString, '<html>', '</html>');

// Prints: Some code

Lo uso da anni e funziona bene. Probabilmente potrebbe essere reso più efficiente, ma

grabstring ("Test string", "", "", 0) restituisce Test string
grabstring ("Test string", "Test", "", 0) restituisce string
grabstring ("Test string", "s", "", 5) restituisce una stringa

function grabstring($strSource,$strPre,$strPost,$StartAt) {
if(@strpos($strSource,$strPre)===FALSE && $strPre!=""){
    return("");
}
@$Startpoint=strpos($strSource,$strPre,$StartAt)+strlen($strPre);
if($strPost == "") {
    $EndPoint = strlen($strSource);
} else {
    if(strpos($strSource,$strPost,$Startpoint)===FALSE){
        $EndPoint= strlen($strSource);
    } else {
        $EndPoint = strpos($strSource,$strPost,$Startpoint);
    }
}
if($strPre == "") {
    $Startpoint = 0;
}
if($EndPoint - $Startpoint < 1) {
    return "";
} else {
        return substr($strSource, $Startpoint, $EndPoint - $Startpoint);
}

}