නිශ්චිත අක්ෂර / නූලකින් ආරම්භ වී හෝ එය අවසන් වුවහොත්, නූලක් ගෙන ආපසු එන ශ්‍රිත දෙකක් මා ලියන්නේ කෙසේද?

උදාහරණයක් වශයෙන්:

$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 ) {
        return true;
    }
    return substr( $haystack, -$length ) === $needle;
}

ඔබට රීජෙක්ස් භාවිතා කිරීමට අවශ්‍ය නැතිනම් මෙය භාවිතා කරන්න.

substr_compareආරම්භය සහ අවසානය සමඟ පරීක්ෂා කිරීමට ඔබට ශ්‍රිතය භාවිතා කළ හැකිය :

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

^{මෙය PHP 7 ( මිණුම් සලකුණු ස්ක්‍රිප්ට් ) හි වේගවත්ම විසඳුමක් විය යුතුය . 8KB පිදුරු, විවිධ දිග ඉඳිකටු සහ සම්පූර්ණ, අර්ධ හා ගැලපුම් අවස්ථා වලට එරෙහිව පරීක්ෂා කර ඇත. strncmpආරම්භය සඳහා වේගවත් ස්පර්ශයක් වන නමුත් එයට කෙළවර පරීක්ෂා කළ නොහැක.}

යාවත්කාලීන කරන ලද්දේ 23-අගෝස්තු -2016

කාර්යයන්

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

පරීක්ෂණ

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

ප්‍රති Results ල (PHP 7.0.9)

(වේගයෙන් හා මන්දගාමීව වර්ග කර ඇත)

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

ප්‍රති Results ල (PHP 5.3.29)

(වේගයෙන් හා මන්දගාමීව වර්ග කර ඇත)

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

startwith_benchmark.php

සියලු පිළිතුරු මෙතෙක් අනවශ්ය වැඩ ළාබාල දේවල් වලට, strlen calculations, string allocations (substr), ආදිය සඳහා 'strpos'සහ 'stripos'කාර්යයන් පළමු සිදුවීමෙ දර්ශකය ආපසු $needleදී $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);
}

ණය :

නූලක් වෙනත් නූලකින් අවසන් වේදැයි පරීක්ෂා කරන්න

නූලක් වෙනත් නූලකින් ආරම්භ වේදැයි පරීක්ෂා කරන්න

ඉහත රීජෙක්ස් ක්‍රියා කරයි, නමුත් අනෙක් යෝජනා සමඟද ඉහත යෝජනා කර ඇත:

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

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

මෙම ප්‍රශ්නයට දැනටමත් බොහෝ පිළිතුරු ඇත, නමුත් සමහර අවස්ථාවල ඔබට ඒ සියල්ලටම වඩා සරල දෙයකට විසඳුම් ලබා දිය හැකිය. ඔබ සොයන නූල දන්නේ නම් (දෘ c කේත කර ඇත), ඔබට කිසිදු උපුටා දැක්වීමකින් තොරව සාමාන්‍ය ප්‍රකාශන භාවිතා කළ හැකිය.

'ABC' සමඟ නූලක් ආරම්භ වේදැයි පරීක්ෂා කරන්න:

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

'ABC' සමඟ අවසන් වේ:

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

මගේ සරල අවස්ථාවෙහිදී, කප්පාදුවකින් නූලක් අවසන් වේදැයි පරීක්ෂා කිරීමට මට අවශ්‍ය විය:

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

වාසිය: එය ඉතා කෙටි හා සරල බැවින්, endsWith()ඉහත පෙන්වා ඇති පරිදි ශ්‍රිතයක් (වැනි ) නිර්වචනය කිරීමට ඔබට අවශ්‍ය නැත .

නමුත් නැවතත් - මෙය සෑම අවස්ථාවකටම විසඳුමක් නොවේ, මෙය ඉතා සුවිශේෂී එකක් පමණි.

වේගය ඔබට වැදගත් නම්, මෙය උත්සාහ කරන්න (එය වේගවත්ම ක්‍රමය යැයි මම විශ්වාස කරමි)

ක්‍රියා කරන්නේ නූල් සඳහා පමණක් වන අතර $ පිදුරු යනු අක්ෂර 1 ක් නම්

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

තාවකාලික නූලක් හඳුන්වා නොදෙන කාර්යයන් දෙකක් මෙන්න, ඉඳිකටු සැලකිය යුතු තරම් විශාල වන විට ප්‍රයෝජනවත් විය හැකිය:

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

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

වේගවත්ම කෙළවර () විසඳුම සමඟ:

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

මිණුම් ලකුණ:

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

මිණුම් සලකුණු ප්‍රති Results ල:

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

මෙය අවසන් වී ඇති බව මට වැටහී ඇත, නමුත් ඔබට strncmp දෙස බැලීමට අවශ්‍ය විය හැකි බැවින් එය සංසන්දනය කිරීම සඳහා නූල් වල දිග තැබීමට ඉඩ සලසයි, එබැවින්:

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

ඔබට භාවිතා කළ හැකි strposහාstrrpos

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

පිළිගත් පිළිතුරේ බහු-බයිට් ආරක්ෂිත අනුවාදය මෙන්න, එය UTF-8 නූල් සඳහා හොඳින් ක්‍රියා කරයි:

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

නිත්‍ය ප්‍රකාශන නොමැතිව කෙටි හා පහසුවෙන් තේරුම් ගත හැකි එක්-ලයිනර්.

startWith () කෙළින්ම ඉදිරියට.

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

endWith () තරමක් විසිතුරු හා මන්දගාමී strrev () භාවිතා කරයි:

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

ආරම්භය කෙරෙහි අවධානය යොමු කිරීම, නූල් හිස් නොවන බව ඔබට විශ්වාස නම්, පළමු වර්‍ගයෙහි පරීක්ෂණයක් එකතු කිරීම, සැසඳීමට පෙර, නූල් ආදිය, දේවල් ටිකක් වේගවත් කරයි:

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

එය කෙසේ හෝ (20% -30%) වේගවත් වේ. Char පිදුරු {1} === $ ඉඳිකටුවක් {1 like වැනි තවත් වර්‍ග පරීක්‍ෂණයක් එකතු කිරීමෙන් දේවල් වේගවත් වන බවක් නොපෙනේ.

===වඩා වැඩි වේගයකින් පෙනේ == කොන්දේසි සහගතව ක්රියාකරු (a)?b:cවඩා වේගයෙන් පෙනේif(a) b; else c;

"ඇයි strpos භාවිතා නොකරන්නේ?" වෙනත් විසඳුම් "අනවශ්‍ය වැඩ" ලෙස හැඳින්වීම

strpos වේගවත් නමුත් එය මෙම කාර්යය සඳහා නිවැරදි මෙවලම නොවේ.

තේරුම් ගැනීමට, උදාහරණයක් ලෙස මෙහි කුඩා අනුකරණයක් ඇත:

Search a12345678c inside bcdefga12345678xbbbbb.....bbbbba12345678c

පරිගණකය "ඇතුළත" කරන්නේ කුමක්ද?

    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

ස්ට්‍රෙලන් උපකල්පනය කිරීමෙන් මුළු නූලම පුනරාවර්තනය නොවේ (නමුත් එවැනි අවස්ථාවකදී පවා) මෙය කිසිසේත් පහසු නොවේ.

පහත පිළිතුර කාර්යක්ෂම හා සරල විය හැකි යැයි මම බලාපොරොත්තු වෙමි:

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

PHP 8 යාවත්කාලීන කිරීම

මෙම ගැටලුවට කාර්ය සාධනය සහ පහසු විසඳුමක් ලබා දෙන නව str_starts_withසහ str_ends_withකාර්යයන් PHP 8 ට ඇතුළත් වේ :

$str = "beginningMiddleEnd";
if (str_starts_with($str, "beg")) echo "printed\n";
if (str_starts_with($str, "Beg")) echo "not printed\n";
if (str_ends_with($str, "End")) echo "printed\n";
if (str_ends_with($str, "end")) echo "not printed\n";

මෙම මෙම ලක්ෂණය සඳහා RFC හුරුවට හා පැහැදිලිව පෙනෙන (සහ එතරම් පැහැදිලි නැත) userland ක්රියාවට නැංවීම් ගැටලු සාකච්ඡා වැඩි විස්තර සපයන හා, ද.

මම සාමාන්‍යයෙන් මේ දිනවල අවතක්සේරු-පීඑච්පී වැනි පුස්තකාලයක් සමඟ යමි .

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   

පුස්තකාලය වෙනත් පහසු කාර්යයන් වලින් පිරී ඇත.

මෙම පිළිතුර විසින් mpen , අවාසනාවකට මෙන්, එම වරප්රසාදය ලබා මිණුම් ලකුණක් ඉතා වැදගත් හා අහිතකර අධීක්ෂණ ඇති ඇදහිය නොහැකි තරම් ගැඹුරු වන අතර, නමුත්.

ඉඳිකටු සහ පිදුරු මඩුවල ඇති සෑම බයිටයක්ම සම්පූර්ණයෙන්ම අහඹු බැවින්, ඉඳිකටුවක්-පිදුරු යුගලයක් පළමු බයිටයේම වෙනස් වීමේ සම්භාවිතාව 99.609375% ක් වන අතර, එයින් අදහස් වන්නේ සාමාන්‍යයෙන් යුගල 100000 න් 99609 ක්ම පළමු බයිටයෙන් වෙනස් වන බවයි. . වෙනත් වචන වලින් කිවහොත්, startswithපළමු බයිටය පැහැදිලිවම පරික්ෂා කරන පරිදි ක්‍රියාත්මක කිරීම කෙරෙහි මිණුම් ලකුණ දැඩි ලෙස පක්ෂග්‍රාහී strncmp_startswith2වේ.

පරීක්ෂණ උත්පාදක ලූපය පහත පරිදි ක්‍රියාත්මක කරන්නේ නම්:

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 />";

මිණුම් සලකුණු ප්‍රති results ල තරමක් වෙනස් කතාවක් කියයි:

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

ඇත්ත වශයෙන්ම, මෙම මිණුම් ලකුණ තවමත් අපක්ෂපාතී නොවිය හැකි නමුත් අර්ධ වශයෙන් ගැලපෙන ඉඳිකටු ලබා දීමේදී එය ඇල්ගොරිතම වල කාර්යක්ෂමතාව පරීක්ෂා කරයි.

කෙටියෙන්:

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

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

නිර්දේශයක් පමණි:

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

එම අමතර රේඛාව, නූල්වල පළමු අක්‍ෂරය සංසන්දනය කිරීමෙන් ව්‍යාජ නඩුව වහාම ආපසු ලබා දිය හැකිය , එබැවින් ඔබේ සැසඳීම් බොහෝ වේගවත් කරයි (මා මනින විට 7x වේගවත්). සත්‍ය අවස්ථාවේ දී ඔබ එම තනි පේළිය සඳහා කාර්ය සාධනය සඳහා කිසිදු මිලක් ගෙවන්නේ නැති නිසා එය ඇතුළත් කිරීම වටී යැයි මම සිතමි. (එසේම, ප්‍රායෝගිකව, ඔබ නිශ්චිත ආරම්භක කැබැල්ලක් සඳහා බොහෝ නූල් පරික්ෂා කරන විට, සාමාන්‍ය දෙයක් තුළ ඔබ යමක් සොයන බැවින් බොහෝ සැසඳීම් අසාර්ථක වනු ඇත.)

මෙම substrකාර්යය නැවත පැමිණීමට falseඑසේ නම් මෙන්න, බොහෝ විශේෂ අවස්ථාවල දී මේ කරුණු සම්බන්ධයෙන් කටයුතු කරන මාගේ අනුවාදය, ය:

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
}

පරීක්ෂණ ( trueහොඳ තේරුම):

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

එසේම, substr_compareශ්‍රිතය ද බැලීම වටී. http://www.php.net/manual/en/function.substr-compare.php

මෙය ක්‍රියාත්මක විය හැකිය

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

මුලාශ්‍රය: https://stackoverflow.com/a/4419658

මම මේ විදියට කරන්නම්

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

ජේම්ස් බ්ලැක්ගේ පිළිතුර මත පදනම්ව, එහි අවසානය මෙහි ඇත:

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

}

සටහන: මම ජේම්ස් බ්ලැක්ගේ ආරම්භක විත් ශ්‍රිතය සඳහා if-else කොටස මාරු කර ඇත්තෙමි, මන්ද strncasecmp ඇත්ත වශයෙන්ම strncmp හි අකුරු සංවේදී නොවන අනුවාදයයි.

පහත සඳහන් දේ නොකරන්නේ ඇයි?

//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 . "!";
}

ප්‍රතිදානය:

Valuehaystack ආරම්භයේදී හමු වූ අගය!

මතක තබා ගන්න, strposපිදුරු මඩුවේ ඉඳිකටුවක් හමු නොවුනහොත් ව්‍යාජ ලෙස නැවත පැමිණෙනු ඇති අතර, 0 දර්ශකය 0 (AKA ආරම්භය) හි දී ඉඳිකටුවක් හමු වූයේ නම් පමණක් 0 ලබා දෙනු ඇත.

මෙන්න අවසානය සමඟ:

$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 . "!";
}

මෙම තත්වය තුළ ආරම්භය () ලෙස ශ්‍රිතයක් අවශ්‍ය නොවේ

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

සත්‍ය හෝ අසත්‍යය නිවැරදිව නැවත ලබා දෙනු ඇත.

මෙහි අමුතු බවක් පෙනේ, මෙහි ඇති සියලුම වල් ක්‍රියාකාරිත්වයන් ඉතා වේගයෙන් ක්‍රියාත්මක වේ.

පෙර පිළිතුරු බොහොමයක් එසේම ක්‍රියාත්මක වේ. කෙසේ වෙතත්, මෙය ඔබට සෑදිය හැකි තරම් කෙටි වන අතර එය ඔබ කැමති දෙයක් කරන්න. ඔබ කියන්නේ එය 'සත්‍ය බවට පත්වීමට' ඔබ කැමති බවයි. ඒ නිසා මම බූලියන් සත්‍ය / අසත්‍යය සහ සත්‍ය සත්‍යය / අසත්‍යය යන විසඳුම් ඇතුළත් කර ඇත්තෙමි.

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

ඔබට නිත්‍ය ප්‍රකාශන භාවිතා කළ හැකිය:

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

පිටපතක් නැත සහ සීමාවාසික ලූපයක් නැත:

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

මෙන්න PHP 4 සඳහා කාර්යක්ෂම විසඳුමක්. PHP 5 substr_compareවෙනුවට ඒ වෙනුවට භාවිතා කිරීමෙන් ඔබට වේගවත් ප්‍රති results ල ලබා ගත 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;
}