Wie bekomme ich einen Teilstring zwischen zwei Strings in PHP?

Ich benötige eine Funktion, die den Teilstring zwischen zwei Wörtern (oder zwei Zeichen) zurückgibt. Ich frage mich, ob es eine PHP-Funktion gibt, die das erreicht. Ich möchte nicht über Regex nachdenken (nun, ich könnte einen machen, denke aber wirklich nicht, dass dies der beste Weg ist). Denken strposund substrFunktionen. Hier ist ein Beispiel:

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

Wir rufen die Funktion auf: $substring = getInnerSubstring($string,"foo");
Sie gibt zurück: "Ich möchte einen Kuchen".

Danke im Voraus.

Update: Nun, bis jetzt kann ich nur einen Teilstring zwischen zwei Wörtern in nur einer Zeichenfolge erhalten. Erlauben Sie mir, mich etwas weiter gehen zu lassen und zu fragen, ob ich die Verwendung von erweitern kann getInnerSubstring($str,$delim), um Zeichenfolgen zu erhalten, die zwischen dem Begrenzungswert liegen. Beispiel:

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

Ich bekomme ein Array wie {"I like php", "I also like asp", "I feel hero"}.

Wenn die Zeichenfolgen unterschiedlich sind (z. B. [foo] & [/ foo]), schauen Sie sich diesen Beitrag von Justin Cook an. Ich kopiere seinen Code unten:

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)

Reguläre Ausdrücke sind der richtige Weg:

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

Beispielverwendung:

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

Anwendungsbeispiel:

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

Wenn Sie umgebende Leerzeichen entfernen möchten, verwenden Sie trim. Beispiel:

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

Zum Beispiel möchten Sie das Array von Zeichenfolgen (Schlüsseln) zwischen @@ im folgenden Beispiel, wobei '/' nicht dazwischen liegt

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

print_r($str_arr);

benutze die strstr php Funktion zweimal.

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

Ausgänge: "is a great day to"

Ich mag die Lösungen für reguläre Ausdrücke, aber keine der anderen passt zu mir.

Wenn Sie wissen, dass es nur 1 Ergebnis geben wird, können Sie Folgendes verwenden:

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

Ändern Sie VOR und NACH den gewünschten Trennzeichen.

Beachten Sie auch, dass diese Funktion den gesamten String zurückgibt, falls nichts übereinstimmt.

Diese Lösung ist mehrzeilig, aber Sie können je nach Bedarf mit den Modifikatoren spielen.

Kein PHP-Profi. Aber ich bin kürzlich auch gegen diese Wand gelaufen und das habe ich mir ausgedacht.

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
)

Wenn Sie fooals Trennzeichen verwenden, schauen Sie sich anexplode()

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

Beispiel:

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

Dies wird "den Kerl in der Mitte" zurückgeben.

Wenn Sie mehrere Wiederholungen aus einer einzelnen Zeichenfolge haben und unterschiedliche [Start] - und [\ End] -Muster haben. Hier ist eine Funktion, die ein Array ausgibt.

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

Hier ist eine Funktion

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

Verwenden Sie es wie

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

echo $substring;

Ausgabe (beachten Sie, dass Leerzeichen vor und am und Ihrer Zeichenfolge zurückgegeben werden, falls vorhanden)

Ich will einen Kuchen

Wenn Sie das Ergebnis trimmen möchten, verwenden Sie die Funktion wie

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

Ergebnis : Diese Funktion gibt false zurück, wenn sie $boundstringnicht gefunden wurde $stringoder $boundstringnur einmal vorhanden $stringist. Andernfalls wird die Teilzeichenfolge zwischen dem ersten und dem letzten Auftreten von $boundstringin zurückgegeben $string.

• strpos ()
• strrpos ()
• substr ()
• trimmen()

Verbesserung von Alejandros Antwort . Sie können die Argumente $startoder $endleer lassen und es wird der Anfang oder das Ende der Zeichenfolge verwendet.

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

Verwenden:

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

?>

Ein bisschen verbesserter Code von GarciaWebDev und Henry Wang. Wenn $ start oder $ end leer angegeben ist, gibt die Funktion Werte vom Anfang oder bis zum Ende des $ -Strings zurück. Es ist auch die Option "Inklusive" verfügbar, unabhängig davon, ob das Suchergebnis eingeschlossen werden soll oder nicht:

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

Ich muss dem Beitrag von Julius Tilvikas etwas hinzufügen. Ich habe nach einer Lösung wie dieser gesucht, die er in seinem Beitrag beschrieben hat. Aber ich denke, es gibt einen Fehler. Ich bekomme nicht wirklich die Zeichenfolge zwischen zwei Zeichenfolgen, ich bekomme auch mehr mit dieser Lösung, weil ich die Länge der Startzeichenfolge subtrahieren muss. Wenn ich das mache, bekomme ich wirklich den String zwischen zwei Strings.

Hier sind meine Änderungen seiner Lösung:

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.

Versuchen Sie dies, seine Arbeit für mich, erhalten Sie Daten zwischen Testwort .

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

Im PHP- strposStil wird dies zurückgegeben, falsewenn die Start- smoder Endmarke emnicht gefunden wird.

Dieses Ergebnis ( false) unterscheidet sich von einer leeren Zeichenfolge, die Sie erhalten, wenn zwischen der Start- und der Endmarke nichts steht.

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

Die Funktion gibt nur die erste Übereinstimmung zurück.

Es ist offensichtlich, aber erwähnenswert, dass die Funktion zuerst sucht smund dann sucht em.

Dies bedeutet, dass Sie möglicherweise nicht das gewünschte Ergebnis / Verhalten erhalten, wenn emzuerst gesucht werden muss und dann die Zeichenfolge auf der Suche nach rückwärts analysiert werden muss sm.

Dies ist die Funktion, die ich dafür benutze. Ich habe zwei Antworten in einer Funktion für einzelne oder mehrere Trennzeichen kombiniert.

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

Zur einfachen Verwendung (gibt zwei zurück):

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

Um jede Zeile in einer Tabelle zum Ergebnisarray zu bringen:

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

ich benutze

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

Ersetzen Sie <TAG> durch das gewünschte Trennzeichen.

eine bearbeitete Version dessen, was Alejandro García Iglesias gesagt hat.

Auf diese Weise können Sie eine bestimmte Position der Zeichenfolge auswählen, die Sie abrufen möchten, basierend darauf, wie oft das Ergebnis gefunden wird.

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

Verwendung:

$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 verfügt über eine zusätzliche optionale Eingabe, um die Suche an einem bestimmten Punkt zu starten. Daher speichere ich die vorherige Position in $ cPos. Wenn die for-Schleife erneut überprüft wird, beginnt sie am Ende der Stelle, an der sie aufgehört hat.

Die überwiegende Mehrheit der Antworten hier beantwortet den bearbeiteten Teil nicht, ich denke, sie wurden zuvor hinzugefügt. Es kann mit Regex gemacht werden, wie eine Antwort erwähnt. Ich hatte einen anderen Ansatz.

Diese Funktion durchsucht $ string und findet die erste Zeichenfolge zwischen $ start- und $ end-Zeichenfolgen, beginnend an der $ offset-Position. Anschließend wird die $ offset-Position aktualisiert, um auf den Anfang des Ergebnisses zu zeigen. Wenn $ includeDelimiters true ist, werden die Trennzeichen in das Ergebnis aufgenommen.

Wenn die Zeichenfolge $ start oder $ end nicht gefunden wird, wird null zurückgegeben. Es wird auch null zurückgegeben, wenn $ string, $ start oder $ end eine leere Zeichenfolge sind.

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

Die folgende Funktion findet alle Zeichenfolgen, die zwischen zwei Zeichenfolgen liegen (keine Überlappungen). Es erfordert die vorherige Funktion und die Argumente sind dieselben. Nach der Ausführung zeigt $ offset auf den Anfang der zuletzt gefundenen Ergebniszeichenfolge.

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

Beispiele:

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

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

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

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

Verwenden:

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

Ich hatte einige Probleme mit der hier verwendeten Funktion get_string_between (). Also kam ich mit meiner eigenen Version. Vielleicht könnte es Menschen im selben Fall wie mir helfen.

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

schrieb diese vor einiger Zeit, fand es sehr nützlich für eine breite Palette von Anwendungen.

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

Mit einigem Fehler fangen. Insbesondere erfordern die meisten der vorgestellten Funktionen, dass $ end vorhanden ist, obwohl es in meinem Fall tatsächlich optional sein musste. Verwenden Sie dies, wenn $ end optional ist, und bewerten Sie FALSE, wenn $ start überhaupt nicht vorhanden ist:

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

}

Die UTF-8-Version der Antwort von @Alejandro Iglesias funktioniert für nicht-lateinische Zeichen:

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)

Ich habe die beste Lösung dafür von tonyspiro bekommen

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

Mit dieser kleinen Funktion ist dies ganz einfach möglich:

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

Ich benutze dies seit Jahren und es funktioniert gut. Könnte wohl effizienter gemacht werden, aber

Grabstring ("Teststring", "", "", 0) gibt
Teststring zurück. Grabstring ("Teststring", "Test", "", 0) gibt String-
Grabstring ("Teststring", "s", "", zurück) 5) gibt einen String zurück

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

}}