Jak uzyskać podciąg między dwoma ciągami w PHP?

Potrzebuję funkcji, która zwraca podciąg między dwoma słowami (lub dwoma znakami). Zastanawiam się, czy istnieje funkcja php, która to osiąga. Nie chcę myśleć o wyrażeniach regularnych (cóż, mógłbym to zrobić, ale naprawdę nie sądzę, że to najlepszy sposób). Myślenie strposi substrfunkcje. Oto przykład:

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

Nazywamy tę funkcję: $substring = getInnerSubstring($string,"foo");
Zwraca: „Chcę ciasto”.

Z góry dziękuję.

Aktualizacja: Cóż, do tej pory mogę po prostu uzyskać podciąg między dwoma słowami w jednym ciągu, czy pozwolisz mi pójść dalej i zapytać, czy mogę rozszerzyć użycie, getInnerSubstring($str,$delim)aby uzyskać ciągi, które znajdują się między wartością delim, przykład:

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

Otrzymuję tablicę jak {"I like php", "I also like asp", "I feel hero"}.

Jeśli ciągi znaków są różne (np .: [foo] i [/ foo]), spójrz na ten post od Justina Cooka. Kopiuję jego kod poniżej:

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)

Wyrażenia regularne to droga:

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

Przykładowe zastosowanie:

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

Przykład użycia:

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

Jeśli chcesz usunąć otaczające spacje, użyj trim. Przykład:

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

na przykład chcesz mieć tablicę ciągów (kluczy) między @@ w poniższym przykładzie, gdzie „/” nie znajduje się pomiędzy

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

print_r($str_arr);

użyj funkcji php strstr dwukrotnie.

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

wyjścia: "is a great day to"

Lubię rozwiązania wyrażeń regularnych, ale żadne z pozostałych mi nie odpowiada.

Jeśli wiesz, że wynik będzie tylko 1, możesz użyć następującego:

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

Zmień PRZED i PO na żądane ograniczniki.

Pamiętaj również, że ta funkcja zwróci cały ciąg, jeśli nic nie zostanie dopasowane.

To rozwiązanie jest wielowierszowe, ale możesz bawić się modyfikatorami w zależności od potrzeb.

Nie jest profesjonalistą od PHP. ale ostatnio też wpadłem na tę ścianę i to właśnie wymyśliłem.

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
)

Jeśli używasz foojako separatora, spójrz naexplode()

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

Przykład:

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

To zwróci „faceta w środku”.

Jeśli masz wiele powtórzeń z jednego ciągu i masz inny wzorzec [początek] i [\ koniec]. Oto funkcja, która wyświetla tablicę.

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

Oto funkcja

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

Użyj tego jak

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

echo $substring;

Wyjście (zwróć uwagę, że zwraca spacje na początku i na końcu łańcucha, jeśli istnieje)

Chcę ciasto

Jeśli chcesz przyciąć wynik, użyj funkcji takiej jak

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

Wynik : Ta funkcja zwróci false, jeśli $boundstringnie zostanie znaleziona w $stringlub jeśli $boundstringistnieje tylko raz w $string, w przeciwnym razie zwraca podciąg między pierwszym a ostatnim wystąpieniem $boundstringin $string.

• strpos ()
• strrpos ()
• substr ()
• trym()

Poprawa odpowiedzi Alejandro . Możesz pozostawić argumenty $startlub $endpuste i użyje początku lub końca ciągu.

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

Posługiwać się:

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

?>

Nieco poprawiony kod z GarciaWebDev i Henry Wang. Jeśli podano puste $ start lub $ end, funkcja zwraca wartości od początku lub końca ciągu $. Dostępna jest również opcja Inclusive, niezależnie od tego, czy chcemy uwzględnić wynik wyszukiwania, czy nie:

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

Muszę coś dodać do postu Juliusa Tilvikasa. Szukałem rozwiązania takiego jak to, które opisał w swoim poście. Ale myślę, że jest błąd. Naprawdę nie widzę ciągu między dwoma ciągami, ale dzięki temu rozwiązaniu otrzymuję więcej, ponieważ muszę odjąć długość ciągu początkowego. Kiedy to robię, naprawdę otrzymuję ciąg między dwoma ciągami.

Oto moje zmiany jego rozwiązania:

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

Spróbuj tego, to działa dla mnie, uzyskaj dane między słowami testowymi .

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

W strposstylu PHP to zwróci, falsejeśli znak początkowy smlub końcowyem nie zostanie znaleziony .

Ten wynik ( false) różni się od pustego ciągu, który otrzymujesz, jeśli nie ma nic między znacznikiem początkowym i końcowym.

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

Funkcja zwróci tylko pierwsze dopasowanie.

To oczywiste, ale warto wspomnieć, że funkcja będzie najpierw szukać, sma potem szukaćem .

Oznacza to, że możesz nie uzyskać pożądanego wyniku / zachowania, jeśli emmusisz najpierw przeszukać, a następnie łańcuch musi zostać przeanalizowany wstecz w poszukiwaniu sm.

To jest funkcja, której do tego używam. Połączyłem dwie odpowiedzi w jednej funkcji dla jednego lub wielu separatorów.

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

Do prostego użycia (zwraca dwa):

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

Aby uzyskać każdy wiersz w tabeli do tablicy wyników:

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

używam

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

Podtytuł <TAG> dla dowolnego separatora.

zredagowana wersja tego, co napisał Alejandro García Iglesias.

Umożliwia to wybranie określonej lokalizacji ciągu, który chcesz uzyskać, na podstawie liczby znalezionych wyników.

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

stosowanie:

$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 ma dodatkowe opcjonalne dane wejściowe, które umożliwiają rozpoczęcie wyszukiwania w określonym miejscu. więc przechowuję poprzednią pozycję w $ cPos, więc gdy pętla for ponownie sprawdza, zaczyna się na końcu miejsca, w którym została przerwana.

Zdecydowana większość odpowiedzi tutaj nie odpowiada edytowanej części, myślę, że zostały dodane wcześniej. Można to zrobić za pomocą wyrażenia regularnego, jak wspomina jedna z odpowiedzi. Miałem inne podejście.

Ta funkcja wyszukuje ciąg $ string i znajduje pierwszy ciąg między $ start i $ end, zaczynając od pozycji $ offset. Następnie aktualizuje pozycję przesunięcia $, aby wskazywała początek wyniku. Jeśli $ includeDelimiters ma wartość true, uwzględnia separatory w wyniku.

Jeśli ciąg $ start lub $ end nie zostanie znaleziony, zwraca wartość null. Zwraca również null, jeśli $ string, $ start lub $ end są pustym łańcuchem.

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

Następująca funkcja znajduje wszystkie ciągi, które znajdują się między dwoma ciągami (bez nakładania się). Wymaga poprzedniej funkcji, a argumenty są takie same. Po wykonaniu, $ offset wskazuje początek ostatnio znalezionego ciągu wynikowego.

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

Przykłady:

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

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

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

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

Posługiwać się:

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

Miałem problemy z zastosowaną tutaj funkcją get_string_between (). Więc przyszedłem z własną wersją. Może mogłoby pomóc ludziom w tej samej sprawie co moja.

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

napisał je jakiś czas temu i uznał je za bardzo przydatne w szerokim zakresie zastosowań.

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

Z pewnym wyłapywaniem błędów. W szczególności większość przedstawionych funkcji wymaga $ end, podczas gdy w rzeczywistości w moim przypadku potrzebowałem go jako opcjonalnego. Użyj tego, że $ end jest opcjonalne i oblicz wartość FALSE, jeśli $ start w ogóle nie istnieje:

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

}

Wersja UTF-8 odpowiedzi @Alejandro Iglesias będzie działać dla znaków spoza alfabetu łacińskiego:

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)

Mam na to najlepsze rozwiązanie od tonyspiro

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

Można to łatwo zrobić za pomocą tej małej funkcji:

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

Używam tego od lat i działa dobrze. Prawdopodobnie mógłby być bardziej wydajny, ale

grabstring ("Ciąg testowy", "", "", 0) zwraca Ciąg testowy
grabstring ("Ciąg testowy", "Test", "", 0) zwraca ciąg
przechwytywania ciągu ("Ciąg testowy", "s", "", 5) zwraca ciąg

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

}