문자열을 가져 와서 지정된 문자 / 문자열로 시작하거나 끝나는 경우 반환하는 두 가지 함수를 작성하는 방법은 무엇입니까?

예를 들면 다음과 같습니다.

$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에서 가장 빠른 솔루션 중 하나 여야합니다 ( 벤치 마크 스크립트 ). 8KB 건초 더미, 다양한 길이의 바늘 및 전체, 부분 및 일치 사례에 대해 테스트되었습니다. strncmp로 시작하는 것이 더 빠르지 만 종료를 확인할 수는 없습니다.}

2016 년 8 월 23 일 업데이트

기능

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

startswith_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()하므로 위에 표시된 대로 함수 (예 :)를 정의 할 필요가 없습니다 .

그러나 다시 말하지만 이것은 모든 경우에 대한 해결책이 아니라 매우 구체적인 것입니다.

속도가 중요한 경우 시도해보십시오. (가장 빠른 방법이라고 생각합니다)

문자열에 대해서만 작동하며 $ haystack이 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;
}

가장 빠른 endsWith () 솔루션 :

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

정규식이없는 짧고 이해하기 쉬운 라이너.

startsWith ()는 간단합니다.

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

endsWith ()는 약간 공상적이고 느린 strrev ()를 사용합니다.

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

시작에 초점을 맞추고 문자열이 비어 있지 않은 경우 첫 번째 문자에 테스트를 추가하고 비교하기 전에 strlen 등을 사용하면 속도가 약간 빨라집니다.

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

어떻게 든 (20 % -30 %) 빠릅니다. $ haystack {1} === $ needle {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';

나는 일반적으로 요즘 underscore-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 %입니다. 즉, 평균적으로 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 />";

벤치 마크 결과는 약간 다른 이야기를합니다.

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

James Black의 답변을 바탕으로 끝은 다음과 같습니다.

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

}

참고 : strncasecmp는 실제로 대소 문자를 구분하지 않는 strncmp 버전이므로 James Black의 startsWith 함수에 if-else 부분을 바꿨습니다.

왜 다음과 같은가요?

//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바늘이 건초 더미에서 발견되지 않은 경우 false를 반환하며, 경우는 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 . "!";
}

이 시나리오에서는 startsWith () 함수가 필요하지 않습니다.

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

true 또는 false를 정확하게 반환합니다.

여기서 모든 야생 기능이 만연해있는 것이 이상하지 않은 것 같습니다.

이전 답변 중 많은 부분이 잘 작동합니다. 그러나 이것은 가능한 한 짧고 원하는대로 수행 할 수 있습니다. 당신은 단지 당신이 '참으로 돌아가고 싶다'고 말하고 있습니다. 그래서 부울 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를위한 효율적인 솔루션 substr_compare입니다 strcasecmp(substr(...)). PHP 5를 사용하는 경우 대신을 사용하여 더 빠른 결과를 얻을 수 있습니다.

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