Como obter uma substring entre duas strings no PHP?

Eu preciso de uma função que retorna a substring entre duas palavras (ou dois caracteres). Eu estou querendo saber se existe uma função php que consegue isso. Eu não quero pensar em regex (bem, eu poderia fazer um, mas realmente não acho que seja o melhor caminho a percorrer). Pensando strpose substrfunções. Aqui está um exemplo:

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

Chamamos a função: $substring = getInnerSubstring($string,"foo");
Ele retorna: "Eu quero um bolo".

Desde já, obrigado.

Atualização: Bem, até agora, posso obter uma substring entre duas palavras em uma única string. Você me permite ir um pouco mais longe e perguntar se posso estender o uso de getInnerSubstring($str,$delim)para obter qualquer string que esteja entre o valor delim, exemplo:

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

Eu recebo uma matriz como {"I like php", "I also like asp", "I feel hero"}.

Se as strings são diferentes (por exemplo: [foo] e [/ foo]), dê uma olhada nesta postagem de Justin Cook. Copio seu código abaixo:

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)

Expressões regulares é o caminho a seguir:

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

Uso da amostra:

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

Exemplo de uso:

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

Se você deseja remover o espaço em branco circundante, use trim. Exemplo:

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

por exemplo, você deseja a matriz de strings (chaves) entre @@ no exemplo a seguir, onde '/' não se enquadra no meio

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

print_r($str_arr);

use a função strstr php duas vezes.

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

saídas: "is a great day to"

Gosto das soluções de expressão regular, mas nenhuma das outras combina comigo.

Se você sabe que haverá apenas 1 resultado, você pode usar o seguinte:

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

Altere ANTES e DEPOIS para os delimitadores desejados.

Lembre-se também de que esta função retornará toda a cadeia caso nada corresponda.

Esta solução é multilinha, mas você pode jogar com os modificadores, dependendo de suas necessidades.

Não é um profissional de php. mas recentemente corri contra esse muro também e foi isso que eu criei.

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 você estiver usando foocomo delimitador, vejaexplode()

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

Exemplo:

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

Isso retornará "o cara do meio".

Se você tiver várias recorrências de uma única sequência e tiver um padrão [start] e [\ end] diferente. Aqui está uma função que gera uma matriz.

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

Aqui está uma função

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

Use-o como

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

echo $substring;

Saída (observe que ele retorna espaços à frente e na e da sua sequência, se existir)

Eu quero um bolo

Se você deseja cortar o resultado, use uma função como

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

Resultado : esta função retornará false se $boundstringnão foi encontrado $stringou se $boundstringexiste apenas uma vez $string, caso contrário, retorna a substring entre a primeira e a última ocorrência de $boundstringin $string.

• strpos ()
• strrpos ()
• substr ()
• aparar()

Melhoria da resposta de Alejandro . Você pode deixar os argumentos $startou $endvazios e ele usará o início ou o fim da string.

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

Usar:

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

?>

Um pouco melhor código de GarciaWebDev e Henry Wang. Se $ start ou $ end vazios forem fornecidos, a função retornará valores do início ou do final da string $. A opção Inclusive também está disponível, se queremos incluir o resultado da pesquisa ou não:

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

Tenho que acrescentar algo ao post de Julius Tilvikas. Procurei uma solução como essa que ele descreveu em seu post. Mas acho que há um erro. Eu não entendo muito a string entre duas, também recebo mais com esta solução, porque tenho que subtrair o comprimento da string inicial. Quando faço isso, eu realmente recebo a String entre duas strings.

Aqui estão as minhas alterações de sua solução:

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

Tente isso, seu trabalho para mim, obtenha dados entre as palavras de teste .

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

No strposestilo do PHP, isso retornará falsese a marca inicial smou final emnão forem encontradas.

Esse resultado ( false) é diferente de uma string vazia que é o que você obtém se não houver nada entre as marcas de início e de fim.

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

A função retornará apenas a primeira correspondência.

É óbvio, mas vale a pena mencionar que a função procurará primeiro sme depois para em.

Isso implica que você pode não obter o resultado / comportamento desejado se emfor necessário pesquisar primeiro e, em seguida, a string deverá ser analisada para trás em busca de sm.

Esta é a função que estou usando para isso. Combinei duas respostas em uma função para delimitadores únicos ou múltiplos.

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

Para uso simples (retorna dois):

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

Para obter cada linha de uma tabela na matriz de resultados:

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

eu uso

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

Legenda <TAG> para o delimitador que você desejar.

uma versão editada do que Alejandro García Iglesias colocou.

Isso permite que você escolha um local específico da string que deseja obter com base no número de vezes que o resultado foi encontrado.

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

uso:

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

O strpos possui uma entrada opcional adicional para iniciar sua pesquisa em um ponto específico. então, guardo a posição anterior em $ cPos. Assim, quando o loop for verifica novamente, ele começa no final de onde parou.

A grande maioria das respostas aqui não responde à parte editada, acho que foram adicionadas antes. Isso pode ser feito com regex, como uma resposta menciona. Eu tive uma abordagem diferente.

Essa função pesquisa $ string e localiza a primeira entre $ strings e $ end, começando na posição de deslocamento $. Em seguida, atualiza a posição de deslocamento $ para apontar para o início do resultado. Se $ includeDelimiters for verdadeiro, ele incluirá os delimitadores no resultado.

Se a cadeia $ start ou $ end não for encontrada, ela retornará nulo. Ele também retornará null se $ string, $ start ou $ end forem uma string vazia.

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

A função a seguir localiza todas as cadeias que estão entre duas cadeias (sem sobreposições). Requer a função anterior e os argumentos são os mesmos. Após a execução, $ offset aponta para o início da última sequência de resultados encontrada.

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

Exemplos:

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á [].

Usar:

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

Eu tive alguns problemas com a função get_string_between (), usada aqui. Então eu vim com minha própria versão. Talvez isso possa ajudar as pessoas no mesmo caso que o meu.

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

escreveu isso há algum tempo, achou muito útil para uma ampla gama de aplicativos.

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

Com algum erro de captura. Especificamente, a maioria das funções apresentadas exige que $ end exista, quando na verdade, no meu caso, eu precisava que fosse opcional. Use this is $ end é opcional e avalie FALSE se $ start não existir:

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

}

A versão UTF-8 da resposta @Alejandro Iglesias, funcionará para caracteres não latinos:

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)

Tem a melhor solução para isso da tonyspiro

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

Isso pode ser feito facilmente usando esta pequena função:

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

Eu tenho usado isso há anos e funciona bem. Provavelmente poderia se tornar mais eficiente, mas

grabstring ("Test string", "", "", 0) retorna String de teste
grabstring ("Test string", "Test", "", 0) retorna string
grabstring ("Test string", "s", "", 5) retorna string

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

}