Làm thế nào tôi có thể viết hai hàm sẽ lấy một chuỗi và trả về nếu nó bắt đầu bằng ký tự / chuỗi được chỉ định hoặc kết thúc bằng nó?

Ví dụ:

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

Sử dụng cái này nếu bạn không muốn sử dụng regex.

Bạn có thể sử dụng substr_comparechức năng để kiểm tra bắt đầu và kết thúc bằng:

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

^{Đây phải là một trong những giải pháp nhanh nhất trên PHP 7 ( tập lệnh chuẩn ). Đã thử nghiệm với đống cỏ 8KB, kim dài khác nhau và các trường hợp đầy đủ, một phần và không khớp. strncmplà một liên lạc nhanh hơn để bắt đầu với nhưng nó không thể kiểm tra kết thúc với.}

Cập nhật ngày 23 tháng 8 năm 2016

Chức năng

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

Xét nghiệm

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

Kết quả (PHP 7.0.9)

(Sắp xếp nhanh nhất đến chậm nhất)

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

Kết quả (PHP 5.3,29)

(Sắp xếp nhanh nhất đến chậm nhất)

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

startedwith_benchmark.php

Tất cả các câu trả lời dường như cho đến nay để làm vô số việc không cần thiết, strlen calculations, string allocations (substr), vv 'strpos'và 'stripos'chức năng trả lại chỉ số của sự xuất hiện đầu tiên của $needlenăm $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);
}

Tín dụng vào :

Kiểm tra xem một chuỗi kết thúc bằng một chuỗi khác

Kiểm tra nếu một chuỗi bắt đầu bằng một chuỗi khác

Các hàm regex ở trên, nhưng với các chỉnh sửa khác cũng được đề xuất ở trên:

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

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

Câu hỏi này đã có nhiều câu trả lời, nhưng trong một số trường hợp, bạn có thể giải quyết cho một cái gì đó đơn giản hơn tất cả chúng. Nếu chuỗi bạn đang tìm kiếm được biết đến (mã hóa cứng), bạn có thể sử dụng các biểu thức thông thường mà không cần trích dẫn, v.v.

Kiểm tra xem một chuỗi bắt đầu bằng 'ABC':

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

kết thúc bằng 'ABC':

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

Trong trường hợp đơn giản của tôi, tôi muốn kiểm tra xem một chuỗi kết thúc bằng dấu gạch chéo:

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

Ưu điểm: vì nó rất ngắn và đơn giản, bạn không phải xác định hàm (chẳng hạn như endsWith()) như được hiển thị ở trên.

Nhưng một lần nữa - đây không phải là một giải pháp cho mọi trường hợp, chỉ là điều này rất cụ thể.

Nếu tốc độ là quan trọng đối với bạn, hãy thử điều này. (Tôi tin rằng đó là phương pháp nhanh nhất)

Chỉ hoạt động cho chuỗi và nếu $ haystack chỉ có 1 ký tự

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

Đây là hai hàm không giới thiệu một chuỗi tạm thời, có thể hữu ích khi kim rất lớn:

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

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

Kết thúc nhanh nhất với giải pháp With ():

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

Điểm chuẩn:

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

Kết quả điểm chuẩn:

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

Tôi nhận ra điều này đã được hoàn thành, nhưng bạn có thể muốn xem strncmp vì nó cho phép bạn đặt độ dài của chuỗi để so sánh với, vì vậy:

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

Bạn có thể sử dụng strposvàstrrpos

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

Đây là phiên bản an toàn nhiều byte của câu trả lời được chấp nhận, nó hoạt động tốt cho các chuỗi 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);
}

Ngắn và dễ hiểu một lớp lót mà không cần biểu thức thông thường.

startedWith () là thẳng về phía trước.

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

endWith () sử dụng strrev () hơi lạ mắt và chậm:

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

Tập trung vào startwith, nếu bạn chắc chắn các chuỗi không trống, hãy thêm một bài kiểm tra vào char đầu tiên, trước khi so sánh, strlen, v.v., tăng tốc mọi thứ lên một chút:

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

Đó là bằng cách nào đó (20% -30%) nhanh hơn. Thêm một thử nghiệm char khác, như $ haystack {1} === $ kim {1} dường như không tăng tốc mọi thứ nhiều, thậm chí có thể chậm lại.

===có vẻ nhanh hơn == toán tử (a)?b:ccó điều kiện dường như nhanh hơnif(a) b; else c;

Đối với những người hỏi "tại sao không sử dụng strpose?" gọi các giải pháp khác là "công việc không cần thiết"

strpose là nhanh, nhưng nó không phải là công cụ phù hợp cho công việc này.

Để hiểu, đây là một mô phỏng nhỏ làm ví dụ:

Search a12345678c inside bcdefga12345678xbbbbb.....bbbbba12345678c

Những gì máy tính làm "bên trong"?

    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

Giả sử strlen không lặp lại toàn bộ chuỗi (nhưng ngay cả trong trường hợp đó) thì điều này không thuận tiện chút nào.

Tôi hy vọng rằng câu trả lời dưới đây có thể hiệu quả và cũng đơn giản:

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

Tôi thường kết thúc với một thư viện như undererscore-php ngày nay.

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   

Thư viện có đầy đủ các chức năng tiện dụng khác.

Câu trả lời của mpen là vô cùng kỹ lưỡng, nhưng, thật không may, điểm chuẩn được cung cấp có một sự giám sát rất quan trọng và bất lợi.

Bởi vì mỗi byte trong kim và đống cỏ là hoàn toàn ngẫu nhiên, xác suất một cặp kim-haystack sẽ khác nhau trên byte đầu tiên là 99,609375%, có nghĩa là, trung bình, khoảng 99609 trong số 100000 cặp sẽ khác nhau ở byte đầu tiên . Nói cách khác, điểm chuẩn rất thiên về các startswithtriển khai kiểm tra byte đầu tiên một cách rõ ràng, nhưstrncmp_startswith2 .

Nếu vòng lặp tạo thử nghiệm được thực hiện như sau:

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ết quả điểm chuẩn cho một câu chuyện hơi khác:

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

Tất nhiên, điểm chuẩn này có thể vẫn không hoàn toàn thiên vị, nhưng nó cũng kiểm tra hiệu quả của các thuật toán khi được cung cấp một phần kim phù hợp.

Nói ngắn gọn:

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

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

Chỉ là một đề nghị:

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

Dòng bổ sung đó, so sánh ký tự đầu tiên của chuỗi, có thể khiến trường hợp sai trở lại ngay lập tức , do đó làm cho nhiều so sánh của bạn nhanh hơn rất nhiều (nhanh hơn 7 lần khi tôi đo). Trong trường hợp thực tế, bạn hầu như không phải trả giá về hiệu suất cho dòng đơn đó vì vậy tôi nghĩ rằng nó đáng để bao gồm. (Ngoài ra, trong thực tế, khi bạn kiểm tra nhiều chuỗi cho một đoạn bắt đầu cụ thể, hầu hết các so sánh sẽ thất bại vì trong trường hợp điển hình là bạn đang tìm kiếm thứ gì đó.)

Các substrchức năng có thể trở lại falsetrong nhiều trường hợp đặc biệt, vì vậy đây là phiên bản của tôi, trong đó giao dịch với những vấn đề này:

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
}

Các xét nghiệm ( truecó nghĩa là tốt):

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

Ngoài ra, substr_comparechức năng cũng đáng tìm kiếm. http://www.php.net/manual/en/feft.substr-compare.php

Điều này có thể làm việc

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

Nguồn: https://stackoverflow.com/a/4419658

Tôi sẽ làm nó như thế này

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

Dựa trên câu trả lời của James Black, đây là phiên bản kết thúc của nó:

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

}

Lưu ý: Tôi đã hoán đổi phần if-other cho hàm startWith của James Black, bởi vì strncasecmp thực sự là phiên bản không phân biệt chữ hoa chữ thường của strncmp.

Tại sao không phải là sau đây?

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

Đầu ra:

Tìm thấy giá trị khi bắt đầu valuehaystack!

Hãy ghi nhớ, strpossẽ trả về false nếu không tìm thấy kim trong đống cỏ khô và sẽ trả về 0 nếu và chỉ khi tìm thấy kim ở chỉ số 0 (AKA bắt đầu).

Và đây là kết thúc với:

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

Trong kịch bản này, không cần hàm startWith () như

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

sẽ trả lại đúng hoặc sai chính xác.

Có vẻ kỳ lạ, nó đơn giản với tất cả các chức năng hoang dã đang lan tràn ở đây.

Nhiều câu trả lời trước cũng sẽ hoạt động tốt. Tuy nhiên, điều này có thể ngắn như bạn có thể làm cho nó và để nó làm những gì bạn mong muốn. Bạn chỉ cần nói rằng bạn muốn nó 'trở về đúng'. Vì vậy, tôi đã bao gồm các giải pháp trả về boolean đúng / sai và văn bản đúng / sai.

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

Bạn cũng có thể sử dụng các biểu thức thông thường:

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

Không sao chép và không thực hiện vòng lặp:

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

Đây là một giải pháp hiệu quả cho PHP 4. Bạn có thể nhận được kết quả nhanh hơn nếu trên PHP 5 bằng cách sử dụng substr_comparethay vì 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;
}

Bạn có thể sử dụng chức năng fnmatch cho việc này.

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