PHP iki dize arasında bir alt dize nasıl edinilir?

İki kelime (veya iki karakter) arasında alt dize döndüren bir işlev gerekir. Bunu başaran bir php işlevi olup olmadığını merak ediyorum. Normal ifade hakkında düşünmek istemiyorum (iyi, bir tane yapabilirim ama gerçekten bunun en iyi yol olduğunu düşünmüyorum). Düşünme strposve substrişlevleri. İşte bir örnek:

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

İşlevi diyoruz: $substring = getInnerSubstring($string,"foo");
Geri döner: "Kek istiyorum".

Şimdiden teşekkürler.

Güncelleme: Şimdiye kadar, sadece bir dizede iki kelimeden oluşan bir alt dize alabilirim, biraz daha ileri gitmeme izin veriyorum ve getInnerSubstring($str,$delim)sınır değeri arasında herhangi bir dizeyi almak için kullanımını uzatabilir miyim diye soruyor musunuz , misal:

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

Gibi bir dizi alıyorum {"I like php", "I also like asp", "I feel hero"}.

Dizeler farklıysa (yani: [foo] & [/ foo]), Justin Cook'un bu yazısına bir göz atın . Kodunu aşağıya kopyaladım:

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)

Düzenli ifadeler şu şekildedir:

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

Örnek kullanım:

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

Kullanım örneği:

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

Çevredeki boşlukları kaldırmak istiyorsanız kullanın trim. Misal:

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

inceleme için, aşağıdaki örnekte @@ arasında bir dizi (anahtarlar) dizisini istiyorsunuz, burada '/' arada kalmıyor

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

print_r($str_arr);

strstr php fonksiyonunu iki kez kullanın.

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

çıktılar: "is a great day to"

Düzenli ifade çözümlerinden hoşlanıyorum ama hiçbiri bana uymuyor.

Sadece 1 sonuç olacağını biliyorsanız, aşağıdakileri kullanabilirsiniz:

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

ÖNCE ve SONRA istediğiniz ayırıcılara değiştirin.

Ayrıca, hiçbir şey eşleşmediği takdirde bu işlevin tüm dizeyi döndüreceğini unutmayın.

Bu çözüm çok satırlıdır, ancak ihtiyaçlarınıza bağlı olarak değiştiricilerle oynayabilirsiniz.

Bir php pro değil. ama son zamanlarda ben de bu duvara girdim ve ben de bunu buldum.

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
)

fooSınırlayıcı olarak kullanıyorsanız ,explode()

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

Misal:

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

Bu "ortadaki adam" dönecektir.

Tek bir dizeden birden çok yineleme varsa ve farklı [başlat] ve [\ bitiş] deseniniz varsa. İşte bir dizi çıktısı veren bir fonksiyon.

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

İşte bir işlev

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

Gibi kullanın

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

echo $substring;

Çıktı (dizginizin önünde ve önünde boşluklar olduğunu unutmayın)

Kek istiyorum

Sonucu kırpmak istiyorsanız aşağıdaki gibi bir işlev kullanın

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

Sonuç : Bu fonksiyon dönecektir yanlış ise $boundstringbulunamadı $stringveya eğer $boundstringsadece bir kez var $string, aksi takdirde ilk ve son olay arasındaki alt dize döndürür $boundstringiçinde $string.

• strpos ()
• strrpos ()
• substr ()
• ) (Döşeme

Alejandro'nun cevabının iyileştirilmesi . $startVeya $endbağımsız değişkenlerini boş bırakabilirsiniz; bu, dizenin başlangıcını veya sonunu kullanır.

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

kullanın:

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

?>

GarciaWebDev ve Henry Wang'ın kodunu biraz geliştirdi. Boş $ start veya $ end verilirse, işlev $ string'in başlangıcından sonuna kadar döndürür. Ayrıca, arama sonucunu dahil etmek isteyip istemediğimizi de içeren:

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

Julius Tilvikas'ın görevine bir şeyler eklemeliyim. Görevinde tarif ettiği gibi bir çözüm aradım. Ama bence bir hata var. Gerçekten iki dize arasında dize alamadım, ben de bu çözüm ile daha fazla olsun, çünkü ben start-string uzunluğunu substract gerekir. Bunu yaptığınızda, gerçekten iki dize arasında dize olsun.

İşte onun çözümündeki değişikliklerim:

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

Selamlamak

V

Bunu deneyin, Benim işim, test kelimesi arasında veri alın .

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

PHP strposstilinde false, başlangıç ​​işareti smveya bitiş işareti embulunmazsa bu geri dönecektir .

Bu sonuç ( false), başlangıç ​​ve bitiş işaretleri arasında hiçbir şey yoksa aldığınız boş dizeden farklıdır .

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

İşlev yalnızca ilk eşleşmeyi döndürür.

Açıktır, ancak işlevin önce smve sonra arayacağını belirtmek gerekir em.

Bu, emönce aranması ve ardından dizenin aranırken geriye doğru ayrıştırılması gerektiğinde istediğiniz sonucu / davranışı alamayabileceğiniz anlamına gelir sm.

Bunun için kullandığım işlev bu. Tek veya çoklu sınırlayıcılar için iki işlevi tek bir işlevde birleştirdim.

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

Basit kullanım için (iki tane döndürür):

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

Bir tablodaki her satırı sonuç dizisine almak için:

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

kullanırım

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

İstediğiniz sınırlayıcı için <TAG> alt başlığı.

Alejandro García Iglesias'ın söylediklerinin düzenlenmiş bir versiyonu.

Bu, sonucun kaç kez bulunduğuna bağlı olarak almak istediğiniz dizenin belirli bir yerini seçmenize olanak tanır.

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

kullanımı:

$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 , aramasını belirli bir noktada başlatmak için ek bir isteğe bağlı girişe sahiptir. Bu yüzden for döngüsü tekrar kontrol ettiğinde, bıraktığı yerin sonunda başlar, böylece önceki konumu $ cPos içinde saklar.

Buradaki cevapların büyük çoğunluğu düzenlenen bölüme cevap vermiyor, sanırım daha önce eklenmişlerdi. Bir cevaptan bahsedildiği gibi regex ile yapılabilir. Farklı bir yaklaşımım vardı.

Bu işlev $ dizesini arar ve $ offset konumundan başlayarak $ start ve $ end dizeleri arasındaki ilk dizeyi bulur . Daha sonra, sonucun başlangıcını göstermek için $ ofset konumunu günceller. $ İncludeDelimiters true olursa, sonuçtaki sınırlayıcıları içerir.

$ Start veya $ end dizesi bulunmazsa, null değerini döndürür. $ String, $ start veya $ end boş bir dize ise null değerini döndürür.

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şağıdaki işlev iki dize (çakışma olmadan) arasındaki tüm dizeleri bulur . Önceki işlevi gerektirir ve bağımsız değişkenler aynıdır. Yürütme sonrasında $ offset, bulunan son sonuç dizesinin başlangıcını gösterir.

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

Örnekler:

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

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

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

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

kullanın:

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

Burada kullanılan get_string_between () işlevi ile bazı sorunlar vardı. Ben de kendi versiyonumla geldim. Belki de benimkiyle aynı durumda olan insanlara yardımcı olabilir.

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

Bunları bir süre önce yazdı, çok çeşitli uygulamalar için çok yararlı buldu.

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

Bazı hata yakalama ile. Özellikle, sunulan işlevlerin çoğu $ end olmasını gerektirir, aslında benim durumumda isteğe bağlı olması gerektiğinde. $ End isteğe bağlıdır ve $ start hiç yoksa FALSE değerini değerlendirin:

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

}

@Alejandro Iglesias cevabının UTF-8 sürümü, latin olmayan karakterler için çalışacaktır:

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)

Tonyspiro'dan bunun için en iyi çözüm var

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

Bu küçük işlev kullanılarak kolayca yapılabilir:

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

Bunu yıllardır kullanıyorum ve iyi çalışıyor. Muhtemelen daha verimli hale getirilebilir, ancak

grabstring ("Test string", "", "", 0) döndürür Test string
grabstring ("Test string", "Test", "", 0) string
grabstring ("Test string", "s", "", 5) Dize döndürür

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

}