Edit Report a Bug

    preg_split

    (PHP 4, PHP 5, PHP 7, PHP 8)

    preg_split — Dizgeyi düzenli ifadeye göre böler

    Açıklama

    preg_split(
        string $şablon,
        string $konu,
        int $sınır = -1,
        int $seçenekler = 0
    ): array|false

    Belirtilen dizgeyi belirtilen düzenli ifadeye göre parçalara ayırır.

    Bağımsız Değişkenler

    şablon

    Bir dizge olarak aranacak şablon.

    konu

    Parçalara ayrılacak dizge.

    sınır

    Belirtildiği takdirde sadece sınır sayıda alt dizge döner. sınır olarak -1 veya null belirtilmişse herhangi bir sayı sınırlaması yok demektir.

    seçenekler

    seçenekler olarak, bit seviyesinde VEYA ( | ) işleci ile birleştirilerek şunlar belirtilebilir:

    PREG_SPLIT_NO_EMPTY
    Etkin olduğunda işlev tarafından sadece boş olmayan parçalar döndürülür.
    PREG_SPLIT_DELIM_CAPTURE
    Etkin olduğunda şablon içindeki yaylı ayraçlı ifade yakalanıp döndürülür.
    PREG_SPLIT_OFFSET_CAPTURE

    Etkin olduğunda, eşleşmenin olduğu son dizgenin başlangıç konumu da döndürülür. Bu seçenek dönen dizideki değeri değiştirir. Dizideki her eleman, 0 indisinde eşleşen alt dizge, 1 indisinde ise alt dizgenin konu içindeki başlangıcını içeren bir diziden oluşur.

    Dönen Değerler

    konu dizgesinin şablon ile eşleşen parçalarını içeren bir dizi, başarısızlık durumunda false döner.

    Hatalar/İstisnalar

    Düzenli ifade şablonu derlendiğinde geçerli bir düzenli ifade haline gelmezse bir E_WARNING çıktılanır.

    Örnekler

    Örnek 1 - preg_split() örneği

    <?php
    // Cümleyi virgül ve boşluk (" ", \r, \t, \n ve \f)
    // karakterlerine göre parçalar.
    $keywords = preg_split("/[\s,]+/", "hypertext language, programming");
    print_r($keywords);
    ?>

    Yukarıdaki örneğin çıktısı:

    Array
(
    [0] => hypertext
    [1] => language
    [2] => programming
)

    Örnek 2 - Bir dizgeyi karakterlerine bölmek

    <?php
    $str     = 'string';
    $chars = preg_split('//', $str, -1, PREG_SPLIT_NO_EMPTY);
    print_r($chars);
    ?>

    Yukarıdaki örneğin çıktısı:

    Array
(
    [0] => s
    [1] => t
    [2] => r
    [3] => i
    [4] => n
    [5] => g
)

    Örnek 3 - Bir dizgeyi sözcüklerine ayırıp başlangıçlarıyla döndürmek

    <?php
    $str     = 'hypertext language programming';
    $chars = preg_split('/ /', $str, -1, PREG_SPLIT_OFFSET_CAPTURE);
    print_r($chars);
    ?>

    Yukarıdaki örneğin çıktısı:

    Array
(
    [0] => Array
        (
            [0] => hypertext
            [1] => 0
        )

    [1] => Array
        (
            [0] => language
            [1] => 10
        )

    [2] => Array
        (
            [0] => programming
            [1] => 19
        )

)

    Notlar

    İpucu

    Düzenli ifadelerin gücünün gerekli olmadığı durumlar için explode(), str_split() işlevleri daha kullanışlı olabilir.

    İpucu

    Eşleşme başarısız olursa girdi dizgesini içeren tek öğeli bir dizi döner.

    Ayrıca Bakınız

    add a note add a note

    User Contributed Notes 18 notes

    up
    42
    jan dot sochor at icebolt dot info
    15 years ago
    Sometimes PREG_SPLIT_DELIM_CAPTURE does strange results.

    <?php
    $content     = '<strong>Lorem ipsum dolor</strong> sit <img src="test.png" />amet <span class="test" style="color:red">consec<i>tet</i>uer</span>.';
    $chars = preg_split('/<[^>]*[^\/]>/i', $content, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
    print_r($chars);
    ?>
    Produces:
    Array
    (
        [0] => Lorem ipsum dolor
        [1] =>  sit <img src="test.png" />amet
        [2] => consec
        [3] => tet
        [4] => uer
    )

    So that the delimiter patterns are missing. If you wanna get these patters remember to use parentheses.

    <?php
    $chars     = preg_split('/(<[^>]*[^\/]>)/i', $content, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
    print_r($chars); //parentheses added
    ?>
    Produces:
    Array
    (
        [0] => <strong>
        [1] => Lorem ipsum dolor
        [2] => </strong>
        [3] =>  sit <img src="test.png" />amet
        [4] => <span class="test" style="color:red">
        [5] => consec
        [6] => <i>
        [7] => tet
        [8] => </i>
        [9] => uer
        [10] => </span>
        [11] => .
    )
    up
    19
    buzoganylaszlo at yahoo dot com
    15 years ago
    Extending m.timmermans's solution, you can use the following code as a search expression parser:

    <?php
    $search_expression     = "apple bear \"Tom Cruise\" or 'Mickey Mouse' another word";
    $words = preg_split("/[\s,]*\\\"([^\\\"]+)\\\"[\s,]*|" . "[\s,]*'([^']+)'[\s,]*|" . "[\s,]+/", $search_expression, 0, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
    print_r($words);
    ?>

    The result will be:
    Array
    (
        [0] => apple
        [1] => bear
        [2] => Tom Cruise
        [3] => or
        [4] => Mickey Mouse
        [5] => another
        [6] => word
    )

    1. Accepted delimiters: white spaces (space, tab, new line etc.) and commas.

    2. You can use either simple (') or double (") quotes for expressions which contains more than one word.
    up
    10
    canadian dot in dot exile at gmail dot com
    9 years ago
    This regular expression will split a long string of words into an array of sub-strings, of some maximum length, but only on word-boundries.

    I use the reg-ex with preg_match_all(); but, I'm posting this example here (on the page for preg_split()) because that's where I looked when I wanted to find a way to do this.

    Hope it saves someone some time.

    <?php
    // example of a long string of words
    $long_string = 'Your IP Address will be logged with the submitted note and made public on the PHP manual user notes mailing list. The IP address is logged as part of the notes moderation process, and won\'t be shown within the PHP manual itself.';

    // "word-wrap" at, for example, 60 characters or less
    $max_len = 60;

    // this regular expression will split $long_string on any sub-string of
    // 1-or-more non-word characters (spaces or punctuation)
    if(preg_match_all("/.{1,{$max_len}}(?=\W+)/", $long_string, $lines) !== False) {

            // $lines now contains an array of sub-strings, each will be approx.
        // $max_len characters - depending on where the last word ended and
        // the number of 'non-word' characters found after the last word
            for ($i=0; $i < count($lines[0]); $i++) {
            echo     "[$i] {$lines[0][$i]}\n";
        }
    }
    ?>
    up
    8
    Hayley Watson
    5 years ago
    Assuming you're using UTF-8, this function can be used to separate Unicode text into individual codepoints without the need for the multibyte extension.

    <?php

    preg_split    ('//u', $text, -1, PREG_SPLIT_NO_EMPTY);

    ?>

    The words "English", "Español", and "Русский" are all seven letters long. But strlen would report string lengths 7, 8 and 14, respectively. The preg_split above would return a seven-element array in all three cases.

    It splits '한국어' into the array ['한', '국', '어'] instead of the 9-character array that str_split($text) would produce.
    up
    13
    eric at clarinova dot com
    13 years ago
    Here is another way to split a CamelCase string, which is a simpler expression than the one using lookaheads and lookbehinds:

    preg_split('/([[:upper:]][[:lower:]]+)/', $last, null, PREG_SPLIT_DELIM_CAPTURE|PREG_SPLIT_NO_EMPTY)

    It makes the entire CamelCased word the delimiter, then returns the delimiters (PREG_SPLIT_DELIM_CAPTURE) and omits the empty values between the delimiters (PREG_SPLIT_NO_EMPTY)
    up
    11
    Daniel Schroeder
    14 years ago
    If you want to split by a char, but want to ignore that char in case it is escaped, use a lookbehind assertion.

    In this example a string will be split by ":" but "\:" will be ignored:

    <?php
    $string    ='a:b:c\:d';
    $array=preg_split('#(?<!\\\)\:#',$string);
    print_r($array);
    ?>

    Results into:

    Array
    (
        [0] => a
        [1] => b
        [2] => c\:d
    )
    up
    11
    jetsoft at iinet.net.au
    20 years ago
    To clarify the "limit" parameter and the PREG_SPLIT_DELIM_CAPTURE option,

    <?php
    $preg_split    ('(/ /)', '1 2 3 4 5 6 7 8', 4 ,PREG_SPLIT_DELIM_CAPTURE );
    ?>

    returns:

    ('1', ' ', '2', ' ' , '3', ' ', '4 5 6 7 8')

    So you actually get 7 array items not 4
    up
    5
    Steve
    19 years ago
    preg_split() behaves differently from perl's split() if the string ends with a delimiter. This perl snippet will print 5:

    my @a = split(/ /, "a b c d e ");
    print scalar @a;

    The corresponding php code prints 6:

    <?php print count(preg_split("/ /", "a b c d e ")); ?>

    This is not necessarily a bug (nowhere does the documentation say that preg_split() behaves the same as perl's split()) but it might surprise perl programmers.
    up
    7
    PhoneixSegovia at gmail dot com
    13 years ago
    You must be caution when using lookbehind to a variable match.
    For example:
    '/(?<!\\\)\r?\n)/'
    to match a new line when not \ is before it don't go as spected as it match \r as the lookbehind (becouse isn't a \) and is optional before \n.

    You must use this for example:
    '/((?<!\\\|\r)\n)|((?<!\\\)\r\n)/'
    That match a alone \n (not preceded by \r or \) or a \r\n not preceded by a \.
    up
    1
    dewi at dewimorgan dot com
    3 years ago
    Beware that it is not safe to assume there are no empty values returned by PREG_SPLIT_NO_EMPTY, nor that you will see no delimiters if you use PREG_SPLIT_DELIM_CAPTURE, as there are some edge cases where these are not true.

    <?php
    # As expected, splitting a string by itself returns two empty strings:
    var_export(preg_split("/x/", "x"));

    array (
          0 => '',
          1 => '',
    )

    # But if we add PREG_SPLIT_NO_EMPTY, then instead of an empty array, we get the delimiter.
    var_export(preg_split("/x/", "x", PREG_SPLIT_NO_EMPTY));

    array (
          0 => 'x',
    )

    And if     we try to split an empty string, then instead of an empty array, we get an empty string even with PREG_SPLIT_NO_EMPTY.
    var_export(preg_split("/x/", "", PREG_SPLIT_NO_EMPTY));

    array (
          0 => '',
    )
    ?>
    up
    2
    Miller
    10 years ago
    This is a function to truncate a string of text while preserving the whitespace (for instance, getting an excerpt from an article while maintaining newlines). It will not jive well with HTML, of course.

    <?php
    /**
    * Truncates a string of text by word count
    * @param string $text The text to truncate
    * @param int $max_words The maximum number of words
    * @return string The truncated text
    */
    function limit_words ($text, $max_words) {
            $split = preg_split('/(\s+)/', $text, -1, PREG_SPLIT_DELIM_CAPTURE);
            $truncated = '';
        for (    $i = 0; $i < min(count($split), $max_words*2); $i += 2) {
                $truncated .= $split[$i].$split[$i+1];
        }
        return     trim($truncated);
    }
    ?>
    up
    4
    php at dmi dot me dot uk
    15 years ago
    To split a camel-cased string using preg_split() with lookaheads and lookbehinds:

    <?php
    function splitCamelCase($str) {
      return     preg_split('/(?<=\\w)(?=[A-Z])/', $str);
    }
    ?>
    up
    3
    csaba at alum dot mit dot edu
    15 years ago
    If the task is too complicated for preg_split, preg_match_all might come in handy, since preg_split is essentially a special case.

    I wanted to split a string on a certain character (asterisk), but only if it wasn't escaped (by a preceding backslash).  Thus, I should ensure an even number of backslashes before any asterisk meant as a splitter.  Look-behind in a regular expression wouldn't work since the length of the preceding backslash sequence can't be fixed.  So I turned to preg_match_all:

    <?php
    // split a string at unescaped asterisks
    // where backslash is the escape character
    $splitter = "/\\*((?:[^\\\\*]|\\\\.)*)/";
    preg_match_all($splitter, "*$string", $aPieces, PREG_PATTERN_ORDER);
    $aPieces = $aPieces[1];

    // $aPieces now contains the exploded string
    // and unescaping can be safely done on each piece
    foreach ($aPieces as $idx=>$piece)
          $aPieces[$idx] = preg_replace("/\\\\(.)/s", "$1", $piece);
    ?>
    up
    4
    david dot binovec at gmail dot com
    13 years ago
    Limit = 1 may be confusing. The important thing is that in case of limit equals to 1 will produce only ONE substring. Ergo the only one substring will be the first one as well as the last one. Tnat the rest of the string (after the first delimiter) will be placed to the last substring. But last is the first and only one.

    <?php

    $output     = $preg_split('(/ /)', '1 2 3 4 5 6 7 8', 1);

    echo     $output[0] //will return whole string!;

    $output = $preg_split('(/ /)', '1 2 3 4 5 6 7 8', 2);

    echo     $output[0] //will return 1;
    echo $output[1] //will return '2 3 4 5 6 7 8';

    ?>
    up
    1
    kenorb at gmail dot com
    15 years ago
    If you need convert function arguments without default default values and references, you can try this code:

    <?php
        $func_args     = '$node, $op, $a3 = NULL, $form = array(), $a4 = NULL'
            $call_arg = preg_match_all('@(?<func_arg>\$[^,= ]+)@i', $func_args, $matches);
            $call_arg = implode(',', $matches['func_arg']);
    ?>
    Result: string = "$node,$op,$a3,$form,$a4"
    up
    1
    Walf
    2 years ago
    Using PREG_SPLIT_DELIM_CAPTURE without PREG_SPLIT_NO_EMPTY guarantees that all the odd-numbered keys in the result will contain the delimiters. This makes further processing more predictable, and empty strings can always be filtered out at the end.
    up
    -1
    markac
    9 years ago
    Split string into words.

    <?php
    $string     = 'This - is a, very dirty "string" :-)';

    // split into words
    $wordlist = preg_split('/\W/', $string, 0, PREG_SPLIT_NO_EMPTY);

    // returns only words that have minimum 2 chars
    $wordlist = array_filter($wordlist, function($val) {
      return     strlen($val) >= 2;
    });

    // print
    var_dump($wordlist);
    ?>

    Result:

    array (size=5)
      0 => string 'This' (length=4)
      1 => string 'is' (length=2)
      3 => string 'very' (length=4)
      4 => string 'dirty' (length=5)
      5 => string 'string' (length=6)
    up
    -3
    php at haravikk dot me
    8 years ago
    When using the PREG_SPLIT_OFFSET_CAPTURE option you will end up with all results in a single array, which is often undesirable as it means you then have to filter out any delimiters you wanted to check for but not keep.

    To get around this you can instead use preg_match_all() to perform the split. For comparison, here are two examples, both splitting around colon and semi-colon characters:

    <?php $pieces_with_delimiters = preg_split('/[;:]/', $input, -1, PREG_SPLIT_OFFSET_CAPTURE); ?>

    <?php preg_match_all('/([^;:]*)([;:]|$)/', $input, $matches);
    list(,     $pieces, $delimiters) = $matches ?>

    The latter requires a more complex pattern, but produces a much more convenient set of results to work with, depending upon what you want to do with them.
    add a note add a note
    To Top