Comment obtenir une sous-chaîne entre deux chaînes de caractères en PHP?

Des expressions régulières est le chemin à parcourir:

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

onlinePhp

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] : '';
}

Exemple d'utilisation:

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

Si vous souhaitez supprimer environnant les espaces, utilisez trim. Exemple:

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

J'aime l'expression régulière solutions, mais les autres ne me conviennent.

Si vous savez qu'il y est seulement va être 1 résultat vous pouvez utiliser les éléments suivants:

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

Changement AVANT et APRÈS souhaité délimiteurs.

Également garder à l'esprit que cette fonction retourne l'ensemble de la chaîne au cas où rien ne correspondait.

Cette solution est multi-ligne, mais vous pouvez jouer avec les modificateurs en fonction de vos besoins.

utilisation strstr fonction php deux fois.

$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;

sorties:
"is a great day to"

Si vous avez de multiples récidives à partir d'une seule chaîne et vous avez différentes [start] et [\end] modèle.
Voici une fonction qui génère un tableau.

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;
}

Pas un php pro. mais j'ai récemment rencontré ce mur trop et c'est ce que je suis venu avec.

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
)

Un peu à l'amélioration du code de GarciaWebDev et Henry Wang. Si vide $démarrer ou $fin est donné, la fonction retourne les valeurs à partir du début ou de la fin de la chaîne$. Compris également l'option est disponible, si nous voulons inclure le résultat de la recherche ou pas:

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);
}

Essayer cela, Son travail pour moi, d'obtenir des données entre test mot.

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

C'est la fonction que j'utilise pour ce. J'ai combiné deux réponses en une seule fonction pour un seul ou plusieurs séparateurs.

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

Pour une utilisation simple (retourne deux):

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

Pour l'obtention de chaque ligne dans un tableau de tableau résultat :

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

Amélioration de Alejandro réponse. Vous pouvez laisser le $start ou $end arguments vides et il utilisera le début ou la fin de la chaîne.

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);
    }
}

Utilisation:

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');

écrit ces il y a quelque temps, le trouve très utile pour un large éventail d'applications.

<?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);
}
?>

UTF-8 version de @Alejandro Iglesias réponse, va travailler pour les caractères non latins:

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)

d'une version révisée de ce que Alejandro García Iglesias mettre.

Cela vous permet de choisir un emplacement spécifique de la chaîne que vous souhaitez obtenir sur la base du nombre de fois que le résultat est obtenu.

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;
}

utilisation:

$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 dispose d'une option d'entrée de commencer sa recherche à un point précis. afin de stocker la position précédente de $cpo ainsi, lorsque la boucle vérifie une fois encore, il commence à la fin de l'endroit où il l'avait laissé.

function strbtwn($s,$start,$end){
$i = strpos($s,$start);
$j = strpos($s,$end,$i);
return $i===false||$j===false? false: substr(substr($s,$i,$j-$i),strlen($start));
}

utilisation:

echo strbtwn($s,"<h2>","</h2>");//<h2>:)</h2> --> :)