Comment obtenir une sous-chaîne entre deux chaînes en PHP?

J'ai besoin d'une fonction qui renvoie la sous-chaîne entre deux mots (ou deux caractères). Je me demande s'il existe une fonction php qui y parvient. Je ne veux pas penser aux regex (enfin, je pourrais en faire une mais je ne pense vraiment pas que ce soit la meilleure voie à suivre). Pensée strposet substrfonctions. Voici un exemple:

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

Nous appelons la fonction: $substring = getInnerSubstring($string,"foo");
Elle renvoie: "Je veux un gâteau".

Merci d'avance.

Mise à jour: Eh bien, jusqu'à présent, je peux juste obtenir une sous-chaîne entre deux mots dans une seule chaîne, permettez-moi de me laisser aller un peu plus loin et de me demander si je peux étendre l'utilisation de getInnerSubstring($str,$delim)pour obtenir toutes les chaînes entre les valeurs de délimitation, exemple:

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

Je reçois un tableau comme {"I like php", "I also like asp", "I feel hero"}.

Si les chaînes sont différentes (par exemple: [foo] & [/ foo]), jetez un œil à ce post de Justin Cook. Je copie son code ci-dessous:

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)

Les expressions régulières sont la voie à suivre:

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

Exemple d'utilisation:

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

Exemple d'utilisation:

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

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

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

par exemple, vous voulez le tableau de chaînes (clés) entre @@ dans l'exemple suivant, où '/' ne se situe pas entre les deux

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

print_r($str_arr);

utilisez la fonction strstr 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;

les sorties: "is a great day to"

J'aime les solutions d'expression régulière mais aucune des autres ne me convient.

Si vous savez qu'il n'y aura qu'un seul résultat, vous pouvez utiliser ce qui suit:

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

Remplacez AVANT et APRÈS par les délimiteurs souhaités.

Gardez également à l'esprit que cette fonction renverra la chaîne entière au cas où rien ne correspond.

Cette solution est multiligne mais vous pouvez jouer avec les modificateurs en fonction de vos besoins.

Pas un pro de php. mais je suis récemment tombé sur ce mur et c'est ce que j'ai trouvé.

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
)

Si vous utilisez foocomme délimiteur, regardezexplode()

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

Exemple:

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

Cela reviendra "le gars du milieu".

Si vous avez plusieurs récurrences à partir d'une seule chaîne et que vous avez des modèles [début] et [\ fin] différents. 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;
}

Voici une fonction

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

Utilisez-le comme

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

echo $substring;

Sortie (notez qu'il renvoie des espaces devant et à la et de votre chaîne si elles existent)

Je veux un gâteau

Si vous voulez rogner le résultat, utilisez une fonction comme

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

Résultat : cette fonction retournera false si elle $boundstringn'a pas été trouvée dans $stringou si elle $boundstringn'existe qu'une seule fois dans $string, sinon elle retourne une sous-chaîne entre la première et la dernière occurrence de $boundstringin $string.

• strpos ()
• strrpos ()
• substr ()
• réduire()

Amélioration de la réponse d' Alejandro . Vous pouvez laisser les arguments $startou $endvides 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:

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

?>

Code un peu amélioré de GarciaWebDev et Henry Wang. Si $ start ou $ end vide est donné, la fonction renvoie les valeurs du début ou de la fin de la chaîne $. L'option inclusive est également disponible, que nous souhaitons ou non inclure le résultat de la recherche:

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

Je dois ajouter quelque chose au message de Julius Tilvikas. J'ai cherché une solution comme celle qu'il a décrite dans son article. Mais je pense qu'il y a une erreur. Je n'obtiens pas vraiment la chaîne entre deux chaînes, j'en ai aussi plus avec cette solution, car je dois soustraire la longueur de la chaîne de début. Quand faire cela, j'obtiens vraiment la chaîne entre deux chaînes.

Voici mes modifications de sa solution:

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

Essayez ceci, son travail pour moi, obtenez des données entre les mots de test .

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

Dans le strposstyle PHP, cela reviendra falsesi la marque de début smou la marque de fin emne sont pas trouvées.

Ce résultat ( false) est différent d'une chaîne vide qui est ce que vous obtenez s'il n'y a rien entre les marques de début et de fin.

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 fonction retournera uniquement la première correspondance.

Il est évident, mais il convient de mentionner que la fonction recherchera d'abord sm, puis em.

Cela implique que vous n'obtiendrez peut-être pas le résultat / comportement souhaité si la emrecherche doit d'abord être effectuée, puis la chaîne doit être analysée en arrière à la recherche de sm.

C'est la fonction que j'utilise pour cela. J'ai combiné deux réponses en une seule fonction pour des délimiteurs simples ou multiples.

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 (renvoie deux):

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

Pour obtenir chaque ligne d'une table en tableau de résultats:

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

j'utilise

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

Sous-titre <TAG> pour le délimiteur de votre choix.

une version éditée de ce qu'Alejandro García Iglesias a mis.

Cela vous permet de choisir un emplacement spécifique de la chaîne que vous souhaitez obtenir en fonction du nombre de fois où le résultat est trouvé.

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

usage:

$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 a une entrée facultative supplémentaire pour démarrer sa recherche à un point spécifique. donc je stocke la position précédente dans $ cPos donc quand la boucle for vérifie à nouveau, elle commence à la fin de là où elle s'est arrêtée.

Une grande majorité des réponses ici ne répondent pas à la partie éditée, je suppose qu'elles ont été ajoutées auparavant. Cela peut être fait avec regex, comme le mentionne une réponse. J'avais une approche différente.

Cette fonction recherche $ string et trouve la première chaîne entre $ start et $ end, en commençant à la position $ offset. Il met ensuite à jour la position $ offset pour pointer vers le début du résultat. Si $ includeDelimiters est vrai, il inclut les délimiteurs dans le résultat.

Si la chaîne $ start ou $ end n'est pas trouvée, elle renvoie null. Il renvoie également null si $ string, $ start ou $ end sont une chaîne vide.

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 fonction suivante recherche toutes les chaînes situées entre deux chaînes (pas de chevauchements). Il nécessite la fonction précédente et les arguments sont les mêmes. Après l'exécution, $ offset pointe vers le début de la dernière chaîne de résultat trouvée.

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

Exemples:

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

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

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

str_between_all('foo 1 bar', 'foo', 'foo')donne [].

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

J'ai eu quelques problèmes avec la fonction get_string_between (), utilisée ici. Je suis donc venu avec ma propre version. Peut-être que cela pourrait aider les gens dans le même cas que le mien.

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

a écrit ces derniers il y a quelque temps, l'a trouvé 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);
}
?>

Avec quelques erreurs de capture. Plus précisément, la plupart des fonctions présentées nécessitent l'existence de $ end, alors qu'en fait, dans mon cas, j'avais besoin qu'il soit optionnel. Utiliser this is $ end est facultatif, et évaluer FALSE si $ start n'existe pas du tout:

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 version UTF-8 de la réponse @Alejandro Iglesias fonctionnera 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)

Vous avez la meilleure solution pour cela de tonyspiro

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

Cela peut être facilement fait en utilisant cette petite fonction:

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

Je l'utilise depuis des années et cela fonctionne bien. Pourrait probablement être rendu plus efficace, mais

grabstring ("Test string", "", "", 0) renvoie la chaîne de test
grabstring ("Test string", "Test", "", 0) renvoie la chaîne
grabstring ("Test string", "s", "", 5) renvoie la chaîne

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

}