¿Cómo obtener una subcadena entre dos cadenas en PHP?

Necesito una función que devuelva la subcadena entre dos palabras (o dos caracteres). Me pregunto si hay una función php que lo logre. No quiero pensar en expresiones regulares (bueno, podría hacer una, pero realmente no creo que sea la mejor manera de hacerlo). Pensamiento strposy substrfunciones. Aquí hay un ejemplo:

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

Llamamos a la función: $substring = getInnerSubstring($string,"foo");
Devuelve: "Quiero un pastel".

Gracias por adelantado.

Actualización: Bueno, hasta ahora, solo puedo obtener una subcadena entre dos palabras en una sola cadena, ¿me permites ir un poco más lejos y preguntar si puedo extender el uso de getInnerSubstring($str,$delim)para obtener cualquier cadena que esté entre el valor delim, ejemplo:

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

Me sale una serie como {"I like php", "I also like asp", "I feel hero"}.

Si las cadenas son diferentes (es decir: [foo] y [/ foo]), eche un vistazo a esta publicación de Justin Cook. Copio su código a continuación:

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)

Las expresiones regulares son el camino 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 de la muestra:

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

Ejemplo de uso:

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

Si desea eliminar los espacios en blanco circundantes, use trim. Ejemplo:

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 ejemplo, desea la matriz de cadenas (claves) entre @@ en el siguiente ejemplo, donde '/' no se encuentra entre

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

print_r($str_arr);

use la función strstr php dos veces.

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

salidas: "is a great day to"

Me gustan las soluciones de expresión regular, pero ninguna de las otras me conviene.

Si sabe que solo habrá 1 resultado, puede usar lo siguiente:

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

Cambie ANTES y DESPUÉS a los delimitadores deseados.

También tenga en cuenta que esta función devolverá toda la cadena en caso de que nada coincida.

Esta solución es multilínea, pero puedes jugar con los modificadores según tus necesidades.

No es un profesional de php. pero recientemente me encontré con este muro también y esto es lo que se me ocurrió.

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 lo está utilizando foocomo delimitador, mireexplode()

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

Ejemplo:

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

Esto devolverá "el chico en el medio".

Si tiene múltiples recurrencias de una sola cadena y tiene un patrón [inicio] y [\ final] diferente. Aquí hay una función que genera una 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;
}

Aquí hay una función

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

Úselo como

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

echo $substring;

Salida (tenga en cuenta que devuelve espacios en frente y en y de su cadena si existe)

Quiero un pastel

Si desea recortar el resultado, utilice la función como

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

Resultado : esta función devolverá falso si $boundstringno se encontró en $stringo si $boundstringexiste solo una vez $string, de lo contrario, devuelve la subcadena entre la primera y la última aparición de $boundstringin $string.

• strpos ()
• strrpos ()
• substr ()
• podar()

Mejora de la respuesta de Alejandro . Puede dejar los argumentos $starto $endvacíos y usará el inicio o el final de la cadena.

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

Utilizar:

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

?>

Un código un poco mejorado de GarciaWebDev y Henry Wang. Si se da $ start o $ end vacío, la función devuelve valores desde el principio o hasta el final de la cadena $. También está disponible la opción Inclusivo, tanto si queremos incluir el resultado de la búsqueda como si no:

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

Tengo que agregar algo a la publicación de Julius Tilvikas. Busqué una solución como esta que él describió en su publicación. Pero creo que hay un error. No consigo realmente la cadena entre dos cadenas, también obtengo más con esta solución, porque tengo que restar la longitud de la cadena de inicio. Cuando hago esto, realmente obtengo la Cadena entre dos cadenas.

Aquí están mis cambios de su solución:

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

Saludar

V

Prueba esto, es trabajo para mí, obtener datos entre la palabra de prueba .

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

En el strposestilo de PHP, esto regresará falsesi no se encuentra la marca de inicio smo la marca de finalización em.

Este resultado ( false) es diferente de una cadena vacía que es lo que obtienes si no hay nada entre las marcas de inicio y 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 función devolverá solo la primera coincidencia.

Es obvio, pero vale la pena mencionar que la función primero buscará smy luego buscará em.

Esto implica que es posible que no obtenga el resultado / comportamiento deseado si emprimero debe buscarse y luego la cadena debe analizarse hacia atrás en busca de sm.

Esta es la función que estoy usando para esto. Combiné dos respuestas en una función para delimitadores simples o múltiples.

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 simple (devuelve dos):

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

Para obtener cada fila de una tabla en la matriz de resultados:

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

yo suelo

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

Subtitúle <TAG> para cualquier delimitador que desee.

una versión editada de lo que puso Alejandro García Iglesias.

Esto le permite elegir una ubicación específica de la cadena que desea obtener en función de la cantidad de veces que se encuentra el resultado.

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

strpos tiene una entrada opcional adicional para comenzar su búsqueda en un punto específico. así que almaceno la posición anterior en $ cPos para que cuando el ciclo for vuelva a comprobar, comience al final de donde lo dejó.

La gran mayoría de las respuestas aquí no responden a la parte editada, supongo que se agregaron antes. Se puede hacer con expresiones regulares, como una respuesta menciona. Tenía un enfoque diferente.

Esta función busca $ string y encuentra la primera cadena entre $ start y $ end strings, comenzando en la posición $ offset. Luego actualiza la posición $ offset para señalar el inicio del resultado. Si $ includeDelimiters es verdadero, incluye los delimitadores en el resultado.

Si no se encuentra la cadena $ start o $ end, devuelve nulo. También devuelve un valor nulo si $ string, $ start o $ end son una cadena vacía.

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 siguiente función encuentra todas las cadenas que se encuentran entre dos cadenas (sin superposiciones). Requiere la función anterior, y los argumentos son los mismos. Después de la ejecución, $ offset apunta al inicio de la última cadena de resultados encontrados.

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

Ejemplos:

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

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

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

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

Utilizar:

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

Tuve algunos problemas con la función get_string_between (), utilizada aquí. Entonces vine con mi propia versión. Tal vez podría ayudar a las personas en el mismo caso que el mío.

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

escribí esto hace algún tiempo, lo encontré muy útil para una amplia gama de aplicaciones.

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

Con algún error en la captura. Específicamente, la mayoría de las funciones presentadas requieren que $ end exista, cuando en realidad en mi caso necesitaba que fuera opcional. Use this $ end es opcional y evalúe FALSE si $ start no existe en absoluto:

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 versión UTF-8 de la respuesta de @Alejandro Iglesias funcionará para caracteres no 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)

Tengo la mejor solución para esto de tonyspiro

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

Se puede hacer fácilmente usando esta pequeña función:

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

He estado usando esto durante años y funciona bien. Probablemente podría hacerse más eficiente, pero

grabstring ("Test string", "", "", 0) devuelve Test string
grabstring ("Test string", "Test", "", 0) devuelve string
grabstring ("Test string", "s", "", 5) devuelve cadena

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

}