Belirtilen karakter / dize ile başlıyor veya onunla bitiyorsa, bir dize alıp geri dönen iki işlevi nasıl yazabilirim?

Örneğin:

$str = '|apples}';

echo startsWith($str, '|'); //Returns true
echo endsWith($str, '}'); //Returns true

function startsWith($haystack, $needle)
{
     $length = strlen($needle);
     return (substr($haystack, 0, $length) === $needle);
}

function endsWith($haystack, $needle)
{
    $length = strlen($needle);
    if ($length == 0) {
        return true;
    }

    return (substr($haystack, -$length) === $needle);
}

Normal ifade kullanmak istemiyorsanız bunu kullanın.

substr_compareBaşlangıç ​​ve bitiş noktalarını kontrol etmek için işlevi kullanabilirsiniz :

function startsWith($haystack, $needle) {
    return substr_compare($haystack, $needle, 0, strlen($needle)) === 0;
}
function endsWith($haystack, $needle) {
    return substr_compare($haystack, $needle, -strlen($needle)) === 0;
}

^{Bu PHP 7 ( benchmark script ) üzerindeki en hızlı çözümlerden biri olmalıdır . 8KB haystacks, çeşitli uzunluktaki iğneler ve tam, kısmi ve eşleşmeyen durumlara karşı test edilmiştir. strncmpbaşlangıç ​​için daha hızlı bir dokunuştur ancak bitiş noktalarını kontrol edemez.}

Güncelleme 23 Ağustos 2016

Fonksiyonlar

function substr_startswith($haystack, $needle) {
    return substr($haystack, 0, strlen($needle)) === $needle;
}

function preg_match_startswith($haystack, $needle) {
    return preg_match('~' . preg_quote($needle, '~') . '~A', $haystack) > 0;
}

function substr_compare_startswith($haystack, $needle) {
    return substr_compare($haystack, $needle, 0, strlen($needle)) === 0;
}

function strpos_startswith($haystack, $needle) {
    return strpos($haystack, $needle) === 0;
}

function strncmp_startswith($haystack, $needle) {
    return strncmp($haystack, $needle, strlen($needle)) === 0;
}

function strncmp_startswith2($haystack, $needle) {
    return $haystack[0] === $needle[0]
        ? strncmp($haystack, $needle, strlen($needle)) === 0
        : false;
}

Testler

echo 'generating tests';
for($i = 0; $i < 100000; ++$i) {
    if($i % 2500 === 0) echo '.';
    $test_cases[] = [
        random_bytes(random_int(1, 7000)),
        random_bytes(random_int(1, 3000)),
    ];
}
echo "done!\n";


$functions = ['substr_startswith', 'preg_match_startswith', 'substr_compare_startswith', 'strpos_startswith', 'strncmp_startswith', 'strncmp_startswith2'];
$results = [];

foreach($functions as $func) {
    $start = microtime(true);
    foreach($test_cases as $tc) {
        $func(...$tc);
    }
    $results[$func] = (microtime(true) - $start) * 1000;
}

asort($results);

foreach($results as $func => $time) {
    echo "$func: " . number_format($time, 1) . " ms\n";
}

Sonuçlar (PHP 7.0.9)

(En hızlıdan en yavaşına)

strncmp_startswith2: 40.2 ms
strncmp_startswith: 42.9 ms
substr_compare_startswith: 44.5 ms
substr_startswith: 48.4 ms
strpos_startswith: 138.7 ms
preg_match_startswith: 13,152.4 ms

Sonuçlar (PHP 5.3.29)

(En hızlıdan en yavaşına)

strncmp_startswith2: 477.9 ms
strpos_startswith: 522.1 ms
strncmp_startswith: 617.1 ms
substr_compare_startswith: 706.7 ms
substr_startswith: 756.8 ms
preg_match_startswith: 10,200.0 ms

startswith_benchmark.php

Bütün cevaplar şu ana kadar gereksiz iş yükleri yapmak gibi görünüyor, strlen calculations, string allocations (substr)vb 'strpos've 'stripos'işlevleri ilk geçtiği dizinini döndürür $needleiçinde $haystack:

function startsWith($haystack,$needle,$case=true)
{
    if ($case)
        return strpos($haystack, $needle, 0) === 0;

    return stripos($haystack, $needle, 0) === 0;
}

function endsWith($haystack,$needle,$case=true)
{
    $expectedPosition = strlen($haystack) - strlen($needle);

    if ($case)
        return strrpos($haystack, $needle, 0) === $expectedPosition;

    return strripos($haystack, $needle, 0) === $expectedPosition;
}

function startsWith($haystack, $needle, $case = true) {
    if ($case) {
        return (strcmp(substr($haystack, 0, strlen($needle)), $needle) === 0);
    }
    return (strcasecmp(substr($haystack, 0, strlen($needle)), $needle) === 0);
}

function endsWith($haystack, $needle, $case = true) {
    if ($case) {
        return (strcmp(substr($haystack, strlen($haystack) - strlen($needle)), $needle) === 0);
    }
    return (strcasecmp(substr($haystack, strlen($haystack) - strlen($needle)), $needle) === 0);
}

Kredi Alıcı :

Bir dizenin başka bir dizeyle bitip bitmediğini kontrol edin

Bir dizenin başka bir dizeyle başlayıp başlamadığını kontrol edin

Normal ifade yukarıda işlev görür, ancak yukarıda önerilen diğer ayarlamalar ile:

 function startsWith($needle, $haystack) {
     return preg_match('/^' . preg_quote($needle, '/') . '/', $haystack);
 }

 function endsWith($needle, $haystack) {
     return preg_match('/' . preg_quote($needle, '/') . '$/', $haystack);
 }

Bu sorunun zaten birçok cevabı var, ancak bazı durumlarda hepsinden daha basit bir şeye razı olabilirsiniz. Aradığınız dize biliniyorsa (sabit kodlanmışsa), herhangi bir alıntı yapmadan normal ifadeleri kullanabilirsiniz.

Bir dizenin 'ABC' ile başlayıp başlamadığını kontrol edin:

preg_match('/^ABC/', $myString); // "^" here means beginning of string

'ABC' ile biter:

preg_match('/ABC$/', $myString); // "$" here means end of string

Basit durumumda, bir dizenin eğik çizgi ile bitip bitmediğini kontrol etmek istedim:

preg_match('#/$#', $myPath);   // Use "#" as delimiter instead of escaping slash

Avantajı: çok kısa ve basit olduğu için, endsWith()yukarıda gösterildiği gibi bir işlev (örneğin ) tanımlamanız gerekmez .

Ama yine de - bu her durum için bir çözüm değil, sadece bu çok spesifik olanı.

Hız sizin için önemliyse, bunu deneyin. (Bunun en hızlı yöntem olduğuna inanıyorum)

Yalnızca dizeler için çalışır ve $ haystack yalnızca 1 karakter ise

function startsWithChar($needle, $haystack)
{
   return ($needle[0] === $haystack);
}

function endsWithChar($needle, $haystack)
{
   return ($needle[strlen($needle) - 1] === $haystack);
}

$str='|apples}';
echo startsWithChar($str,'|'); //Returns true
echo endsWithChar($str,'}'); //Returns true
echo startsWithChar($str,'='); //Returns false
echo endsWithChar($str,'#'); //Returns false

İğneler büyük ölçüde büyük olduğunda yararlı olabilecek geçici bir dize tanımayan iki işlev şunlardır:

function startsWith($haystack, $needle)
{
    return strncmp($haystack, $needle, strlen($needle)) === 0;
}

function endsWith($haystack, $needle)
{
    return $needle === '' || substr_compare($haystack, $needle, -strlen($needle)) === 0;
}

En hızlı uçlarWith () çözümü:

# Checks if a string ends in a string
function endsWith($haystack, $needle) {
    return substr($haystack,-strlen($needle))===$needle;
}

Karşılaştırma:

# This answer
function endsWith($haystack, $needle) {
    return substr($haystack,-strlen($needle))===$needle;
}

# Accepted answer
function endsWith2($haystack, $needle) {
    $length = strlen($needle);

    return $length === 0 ||
    (substr($haystack, -$length) === $needle);
}

# Second most-voted answer
function endsWith3($haystack, $needle) {
    // search forward starting from end minus needle length characters
    if ($needle === '') {
        return true;
    }
    $diff = \strlen($haystack) - \strlen($needle);
    return $diff >= 0 && strpos($haystack, $needle, $diff) !== false;
}

# Regex answer
function endsWith4($haystack, $needle) {
    return preg_match('/' . preg_quote($needle, '/') . '$/', $haystack);
}

function timedebug() {
    $test = 10000000;

    $time1 = microtime(true);
    for ($i=0; $i < $test; $i++) {
        $tmp = endsWith('TestShortcode', 'Shortcode');
    }
    $time2 = microtime(true);
    $result1 = $time2 - $time1;

    for ($i=0; $i < $test; $i++) {
        $tmp = endsWith2('TestShortcode', 'Shortcode');
    }
    $time3 = microtime(true);
    $result2 = $time3 - $time2;

    for ($i=0; $i < $test; $i++) {
        $tmp = endsWith3('TestShortcode', 'Shortcode');
    }
    $time4 = microtime(true);
    $result3 = $time4 - $time3;

    for ($i=0; $i < $test; $i++) {
        $tmp = endsWith4('TestShortcode', 'Shortcode');
    }
    $time5 = microtime(true);
    $result4 = $time5 - $time4;

    echo $test.'x endsWith: '.$result1.' seconds # This answer<br>';
    echo $test.'x endsWith2: '.$result4.' seconds # Accepted answer<br>';
    echo $test.'x endsWith3: '.$result2.' seconds # Second most voted answer<br>';
    echo $test.'x endsWith4: '.$result3.' seconds # Regex answer<br>';
    exit;
}
timedebug();

Deney Sonuçları:

10000000x endsWith: 1.5760900974274 seconds # This answer
10000000x endsWith2: 3.7102129459381 seconds # Accepted answer
10000000x endsWith3: 1.8731069564819 seconds # Second most voted answer
10000000x endsWith4: 2.1521229743958 seconds # Regex answer

Bunun bittiğini anlıyorum, ancak karşılaştırmak için dizenin uzunluğunu koymanıza izin verdiği için strncmp'ye bakmak isteyebilirsiniz , bu yüzden:

function startsWith($haystack, $needle, $case=true) {
    if ($case)
        return strncasecmp($haystack, $needle, strlen($needle)) == 0;
    else
        return strncmp($haystack, $needle, strlen($needle)) == 0;
}    

Kullanabilirsiniz strposvestrrpos

$bStartsWith = strpos($sHaystack, $sNeedle) == 0;
$bEndsWith = strrpos($sHaystack, $sNeedle) == strlen($sHaystack)-strlen($sNeedle);

Kabul edilen cevabın çok baytlı güvenli bir sürümü, UTF-8 dizeleri için iyi çalışıyor:

function startsWith($haystack, $needle)
{
    $length = mb_strlen($needle, 'UTF-8');
    return (mb_substr($haystack, 0, $length, 'UTF-8') === $needle);
}

function endsWith($haystack, $needle)
{
    $length = mb_strlen($needle, 'UTF-8');
    return $length === 0 ||
        (mb_substr($haystack, -$length, $length, 'UTF-8') === $needle);
}

Düzenli ifadeler olmadan kısa ve anlaşılması kolay tek gömlekler.

startsWith () doğrudan ileri gider.

function startsWith($haystack, $needle) {
   return (strpos($haystack, $needle) === 0);
}

endsWith () hafif süslü ve yavaş strrev () kullanır:

function endsWith($haystack, $needle) {
   return (strpos(strrev($haystack), strrev($needle)) === 0);
}

Dizgelerin boş olmadığından eminseniz, odaklanmadan önce, karşılaştırmadan önce, stlen, vb. İlk karaktere bir test eklenir,

function startswith5b($haystack, $needle) {
    return ($haystack{0}==$needle{0})?strncmp($haystack, $needle, strlen($needle)) === 0:FALSE;
}

Bir şekilde (% 20 -% 30) daha hızlı. $ Haystack {1} === $ {{}} gibi başka bir char testi eklemek işleri hızlandırmıyor gibi görünebilir, hatta yavaşlayabilir.

===daha hızlı görünüyor == Koşullu operatör (a)?b:cdaha hızlı görünüyorif(a) b; else c;

"Neden strpos kullanmıyorsunuz?" diğer çözümlere "gereksiz çalışma" diyoruz

strpos hızlıdır, ancak bu iş için doğru araç değildir.

Anlamak için, örnek olarak küçük bir simülasyon var:

Search a12345678c inside bcdefga12345678xbbbbb.....bbbbba12345678c

Bilgisayar "içeride" ne yapar?

    With strccmp, etc...

    is a===b? NO
    return false



    With strpos

    is a===b? NO -- iterating in haysack
    is a===c? NO
    is a===d? NO
    ....
    is a===g? NO
    is a===g? NO
    is a===a? YES
    is 1===1? YES -- iterating in needle
    is 2===3? YES
    is 4===4? YES
    ....
    is 8===8? YES
    is c===x? NO: oh God,
    is a===1? NO -- iterating in haysack again
    is a===2? NO
    is a===3? NO
    is a===4? NO
    ....
    is a===x? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    ...
    ... may many times...
    ...
    is a===b? NO
    is a===a? YES -- iterating in needle again
    is 1===1? YES
    is 2===3? YES
    is 4===4? YES
    is 8===8? YES
    is c===c? YES YES YES I have found the same string! yay!
    was it at position 0? NOPE
    What you mean NO? So the string I found is useless? YEs.
    Damn.
    return false

Strlen'in tüm dizeyi yinelemediğini varsayarsak (ancak bu durumda bile) bu hiç de uygun değildir.

Umarım aşağıdaki cevap etkili ve basit olabilir:

$content = "The main string to search";
$search = "T";
//For compare the begining string with case insensitive. 
if(stripos($content, $search) === 0) echo 'Yes';
else echo 'No';

//For compare the begining string with case sensitive. 
if(strpos($content, $search) === 0) echo 'Yes';
else echo 'No';

//For compare the ending string with case insensitive. 
if(stripos(strrev($content), strrev($search)) === 0) echo 'Yes';
else echo 'No';

//For compare the ending string with case sensitive. 
if(strpos(strrev($content), strrev($search)) === 0) echo 'Yes';
else echo 'No';

Genellikle bugünlerde alt çizgi-php gibi bir kütüphane ile devam ediyorum .

require_once("vendor/autoload.php"); //use if needed
use Underscore\Types\String; 

$str = "there is a string";
echo( String::startsWith($str, 'the') ); // 1
echo( String::endsWith($str, 'ring')); // 1   

Kütüphane diğer kullanışlı işlevlerle doludur.

Cevap tarafından mpen maalesef sağlanan kriter çok önemli ve zararlı gözetim vardır, inanılmaz titiz, ama olmaz.

İğnelerdeki ve samanlıklardaki her bayt tamamen rasgele olduğundan, bir iğne samanlığı çiftinin ilk baytta farklı olma olasılığı% 99.609375'tir, yani ortalama 100000 çiftinin yaklaşık 99609'u ilk baytta farklı olacaktır. . Diğer bir deyişle, karşılaştırma ölçütü, startswithilk baytı olduğu gibi açık bir şekilde kontrol eden uygulamalara büyük ölçüde önyargılıdır strncmp_startswith2.

Test üreten döngü bunun yerine aşağıdaki gibi uygulanırsa:

echo 'generating tests';
for($i = 0; $i < 100000; ++$i) {
    if($i % 2500 === 0) echo '.';

    $haystack_length = random_int(1, 7000);
    $haystack = random_bytes($haystack_length);

    $needle_length = random_int(1, 3000);
    $overlap_length = min(random_int(0, $needle_length), $haystack_length);
    $needle = ($needle_length > $overlap_length) ?
        substr($haystack, 0, $overlap_length) . random_bytes($needle_length - $overlap_length) :
        substr($haystack, 0, $needle_length);

    $test_cases[] = [$haystack, $needle];
}
echo " done!<br />";

kıyaslama sonuçları biraz farklı bir hikaye anlatıyor:

strncmp_startswith: 223.0 ms
substr_startswith: 228.0 ms
substr_compare_startswith: 238.0 ms
strncmp_startswith2: 253.0 ms
strpos_startswith: 349.0 ms
preg_match_startswith: 20,828.7 ms

Tabii ki, bu kıyaslama hala mükemmel derecede tarafsız olmayabilir, ancak kısmen eşleşen iğneler verildiğinde algoritmaların verimliliğini test eder.

Kısacası:

function startsWith($str, $needle){
   return substr($str, 0, strlen($needle)) === $needle;
}

function endsWith($str, $needle){
   $length = strlen($needle);
   return !$length || substr($str, - $length) === $needle;
}

Sadece bir öneri:

function startsWith($haystack,$needle) {
    if($needle==="") return true;
    if($haystack[0]<>$needle[0]) return false; // ------------------------- speed boost!
    return (0===substr_compare($haystack,$needle,0,strlen($needle)));
}

Dizelerin ilk karakterini karşılaştıran bu ekstra çizgi, yanlış durumun hemen geri dönmesini sağlayabilir , bu nedenle karşılaştırmalarınızın çoğunu çok daha hızlı hale getirir (ölçtüğümde 7 kat daha hızlı). Gerçek durumda, bu tek hat için performansta neredeyse hiç fiyat ödemezsiniz, bu yüzden dahil etmeye değer olduğunu düşünüyorum. (Ayrıca, pratikte, belirli bir başlangıç ​​parçası için birçok dizeyi test ettiğinizde, çoğu karşılaştırma, tipik bir durumda bir şey aradığınız için başarısız olur.)

substrİşlev dönebilir falseişte benim sürüm, bu konuyla ilgileniyor, birçok özel durumlarda:

function startsWith( $haystack, $needle ){
  return $needle === ''.substr( $haystack, 0, strlen( $needle )); // substr's false => empty string
}

function endsWith( $haystack, $needle ){
  $len = strlen( $needle );
  return $needle === ''.substr( $haystack, -$len, $len ); // ! len=0
}

Testler ( trueiyi anlamına gelir):

var_dump( startsWith('',''));
var_dump( startsWith('1',''));
var_dump(!startsWith('','1'));
var_dump( startsWith('1','1'));
var_dump( startsWith('1234','12'));
var_dump(!startsWith('1234','34'));
var_dump(!startsWith('12','1234'));
var_dump(!startsWith('34','1234'));
var_dump('---');
var_dump( endsWith('',''));
var_dump( endsWith('1',''));
var_dump(!endsWith('','1'));
var_dump( endsWith('1','1'));
var_dump(!endsWith('1234','12'));
var_dump( endsWith('1234','34'));
var_dump(!endsWith('12','1234'));
var_dump(!endsWith('34','1234'));

Ayrıca, substr_compareişlev de bakmaya değer. http://www.php.net/manual/en/function.substr-compare.php

Bu işe yarayabilir

function startsWith($haystack, $needle) {
     return substr($haystack, 0, strlen($needle)) == $needle;
}

Kaynak: https://stackoverflow.com/a/4419658

Böyle yapardım

     function startWith($haystack,$needle){
              if(substr($haystack,0, strlen($needle))===$needle)
              return true;
        }

  function endWith($haystack,$needle){
              if(substr($haystack, -strlen($needle))===$needle)
              return true;
        }

James Black'in cevabına dayanarak, işte sonu:

function startsWith($haystack, $needle, $case=true) {
    if ($case)
        return strncmp($haystack, $needle, strlen($needle)) == 0;
    else
        return strncasecmp($haystack, $needle, strlen($needle)) == 0;
}

function endsWith($haystack, $needle, $case=true) {
     return startsWith(strrev($haystack),strrev($needle),$case);

}

Not: James Black'in startsWith işlevi için if-else parçasını değiştirdim, çünkü strncasecmp aslında strncmp'ın büyük / küçük harfe duyarlı olmayan sürümüdür.

Neden aşağıdakiler olmasın?

//How to check if a string begins with another string
$haystack = "valuehaystack";
$needle = "value";
if (strpos($haystack, $needle) === 0){
    echo "Found " . $needle . " at the beginning of " . $haystack . "!";
}

Çıktı:

Valuehaystack başlangıcında bulunan değer!

Unutmayın strpos, iğne samanlıkta bulunmazsa false değerini döndürür ve yalnızca ve eğer indeks 0'da (başlangıç ​​AKA) iğne bulunursa 0 değerini döndürür.

Ve işte bitiyor

$haystack = "valuehaystack";
$needle = "haystack";

//If index of the needle plus the length of the needle is the same length as the entire haystack.
if (strpos($haystack, $needle) + strlen($needle) === strlen($haystack)){
    echo "Found " . $needle . " at the end of " . $haystack . "!";
}

Bu senaryoda, startWith () işlevine gerek yoktur.

(strpos($stringToSearch, $doesItStartWithThis) === 0)

doğru veya yanlış döndürür.

Burada çok vahşi çalışan tüm vahşi fonksiyonları ile bu kadar basit görünüyor.

Önceki cevapların birçoğu da aynı şekilde işe yarayacaktır. Ancak, bu muhtemelen yapabileceğiniz kadar kısa ve istediğinizi yapmasını sağlar. Siz sadece 'gerçeğe dönmesini' istediğinizi söylersiniz. Bu yüzden boolean true / false ve textual true / false döndüren çözümler ekledim.

// boolean true/false
function startsWith($haystack, $needle)
{
    return strpos($haystack, $needle) === 0 ? 1 : 0;
}

function endsWith($haystack, $needle)
{
    return stripos($haystack, $needle) === 0 ? 1 : 0;
}


// textual true/false
function startsWith($haystack, $needle)
{
    return strpos($haystack, $needle) === 0 ? 'true' : 'false';
}

function endsWith($haystack, $needle)
{
    return stripos($haystack, $needle) === 0 ? 'true' : 'false';
}

Ayrıca düzenli ifadeler kullanabilirsiniz:

function endsWith($haystack, $needle, $case=true) {
  return preg_match("/.*{$needle}$/" . (($case) ? "" : "i"), $haystack);
}

Kopyasız ve stajyersiz döngü:

function startsWith(string $string, string $start): bool
{
    return strrpos($string, $start, - strlen($string)) !== false;
}

function endsWith(string $string, string $end): bool
{
    return ($offset = strlen($string) - strlen($end)) >= 0 
    && strpos($string, $end, $offset) !== false;
}

İşte PHP 4 için verimli bir çözüm. PHP 5 substr_compareyerine kullanarak daha hızlı sonuç alabilirsiniz strcasecmp(substr(...)).

function stringBeginsWith($haystack, $beginning, $caseInsensitivity = false)
{
    if ($caseInsensitivity)
        return strncasecmp($haystack, $beginning, strlen($beginning)) === 0;
    else
        return strncmp($haystack, $beginning, strlen($beginning)) === 0;
}

function stringEndsWith($haystack, $ending, $caseInsensitivity = false)
{
    if ($caseInsensitivity)
        return strcasecmp(substr($haystack, strlen($haystack) - strlen($ending)), $haystack) === 0;
    else
        return strpos($haystack, $ending, strlen($haystack) - strlen($ending)) !== false;
}

Bunun için fnmatch işlevini kullanabilirsiniz .

// Starts with.
fnmatch('prefix*', $haystack);
// Ends with.
fnmatch('*suffix', $haystack);