Як я можу записати дві функції, які братимуть рядок і повертатимуться, якщо він починається із зазначеного символу / рядка або закінчується ним?

Наприклад:

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

Використовуйте це, якщо ви не хочете використовувати регулярний вираз.

Ви можете використовувати 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 ( тест-сценарій ). Тестували на стогах сіна 8КБ, голках різної довжини та повних, часткових і невідповідних випадках. 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";
}

Результати (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

Результати (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);
 }

На це запитання вже є багато відповідей, але в деяких випадках можна погодитися на щось простіше, ніж на всі вони. Якщо рядок, яку ви шукаєте, відомий (твердо кодований), ви можете використовувати регулярні вирази без жодного цитування тощо.

Перевірте, чи починається рядок з "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();

Результати порівняння:

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

Якщо зосередитись на startwith, якщо ви впевнені, що рядки не порожні, додавання тесту на перший знак, перед порівнянням, strlen тощо, трохи прискорює:

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

Це якось (на 20% -30%) швидше. Якщо додати ще один тест, наприклад, $ стог сіна {1} === $ голка {1}, схоже, не дуже прискорить справи, може навіть сповільнити.

===здається швидше, ніж == умовний оператор (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

Якщо припустити, що strlen не повторює весь рядок (але навіть у цьому випадку), це зовсім не зручно.

Я сподіваюся, що наведена нижче відповідь може бути ефективною, а також простою:

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

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%, це означає, що в середньому приблизно 99609 із 100000 пар будуть відрізнятися на першому байті . Іншими словами, орієнтир сильно упереджений до 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 />";

результати еталону розповідають дещо іншу історію:

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

Цей додатковий рядок, порівнюючи перший символ рядків, може змусити помилковий випадок повернутися негайно , тому зробить багато ваших порівнянь набагато швидшими (7 разів швидше, коли я вимірював). У справжньому випадку ви платите практично не за ціну за цей єдиний рядок, тому я думаю, що це варто включити. (Крім того, на практиці, коли ви тестуєте багато рядків для конкретного початкового фрагменту, більшість порівнянь не вдасться, оскільки в типовому випадку ви щось шукаєте.)

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 на функцію beginWith Джеймса Блека, оскільки 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 початок).

І ось що закінчується:

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

У цьому сценарії немає необхідності у запуску функціїWith () як

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

повернеться справжньою чи хибною точно.

Здається дивним, що це все просто, коли всі дикі функції працюють тут.

Багато попередніх відповідей спрацюють так само добре. Однак це, можливо, так коротко, як ви можете зробити це і змусити його робити те, що ви хочете. Ви просто заявляєте, що хочете, щоб він повернувся до істини. Тому я включив рішення, що повертають булеві значення true / false та текстові true / false.

// 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замість, ніж 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;
}

Ви можете використовувати для цього функцію fnmatch .

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