str_split - PHP code example

The PHP Function Str_Split

The php function str_split is used to convert a string into an array of chunks. It accepts two parameters, a string and an integer defining each array element's length. It returns an array with the split string as its individual elements.

This function has some advantages over the deprecated "split" function, including better performance and code compatibility. However, it also has some drawbacks when compared to other splitting functions or alternative techniques, such as pattern matching.

Technical Details

The str_split function is a predefined PHP function used to convert a string into an array by splitting it into chunks of a specified size. The string to be split must contain a delimiter character, which defines the critical points or points at which the strings will be broken into separate elements of the array. The optional length parameter is used to define the maximum number of characters that each chunk will have; if this value is not provided, each chunk will be one string.

Moreover, the str_split function can also be used to split into bytes instead of characters when dealing with multi-byte encoded strings. This functionality is useful for reverse translating amino acid sequences, for example.

Another downside of the str_split function is that it does not allow for much control over the splitting process, such as specifying whether or not to preserve the delimiter in the resulting array. For this reason, it is not a good choice for complex or large strings where fine-grained control is needed.

str_split example

$v_header['filename'] = '';
            $this->_error('Invalid block size : ' . strlen($v_binary_data));
            return false;
        }

        if (!is_array($v_header)) {
            $v_header = array();
        }
        // ----- Calculate the checksum         $v_checksum = 0;
        // ..... First part of the header         $v_binary_split = str_split($v_binary_data);
        $v_checksum += array_sum(array_map('ord', array_slice($v_binary_split, 0, 148)));
        $v_checksum += array_sum(array_map('ord', array(' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',)));
        $v_checksum += array_sum(array_map('ord', array_slice($v_binary_split, 156, 512)));

        $v_data = unpack($this->_fmt, $v_binary_data);

        if (strlen($v_data["prefix"]) > 0) {
            $v_data["filename"] = "$v_data[prefix]/$v_data[filename]";
        }

'gps_count'      => 0,       // ID 5                                     'gps_data'       => array(),
                                    'rotation_count' => 0,       // ID 6                                     'rotation_data'  => array(),
                                    'unknown_count'  => 0,       // ID ??                                     'unknown_data'   => array(),
                                    'debug_list'     => '',      // Used to debug variables stored as comma delimited strings                             );
                            $debug_structure = array();
                            $debug_structure['debug_items'] = array();
                            // Can start loop here to decode all sensor data in 32 Byte chunks:                             foreach (str_split($atom_SENSOR_data, 32) as $sensor_key => $sensor_data) {
                                // This gets me a data_type code to work out what data is in the next 31 bytes.                                 $sensor_data_type = substr($sensor_data, 0, 1);
                                $sensor_data_content = substr($sensor_data, 1);
                                $uuid_bytes_read = unpack('C*', $sensor_data_type);
                                $sensor_data_array = array();
                                switch ($uuid_bytes_read[1]) {
                                    case 250:
                                        $atom_structure['sensor_data']['data_type']['fusion_count']++;
                                        $uuid_bytes_read = unpack('cmode/Jtimestamp/Gyaw/Gpitch/Groll/x*', $sensor_data_content);
                                        $sensor_data_array['mode']      = $uuid_bytes_read['mode'];
                                        $sensor_data_array['timestamp'] = $uuid_bytes_read['timestamp'];

$type_attr = current_theme_supports( 'html5', 'script' ) ? '' : " type='text/javascript'";

    if ( $concat ) {
        if ( ! empty( $wp_scripts->print_code ) ) {
            echo "\n<script{$type_attr}>\n";
            echo "/* <![CDATA[ */\n"; // Not needed in HTML 5.             echo $wp_scripts->print_code;
            echo "/* ]]> */\n";
            echo "</script>\n";
        }

        $concat       = str_split( $concat, 128 );
        $concatenated = '';

        foreach ( $concat as $key => $chunk ) {
            $concatenated .= "&load%5Bchunk_{$key}%5D={$chunk}";
        }

        $src = $wp_scripts->base_url . "/wp-admin/load-scripts.php?c={$zip}" . $concatenated . '&ver=' . $wp_scripts->default_version;
        echo "<script{$type_attr} src='" . esc_attr( $src ) . "'></script>\n";
    }

    if ( ! empty( $wp_scripts->print_html ) ) {

  protected static function emojiForString(string $input): string {
    // Compute a cheap and reproducible float between 0 and 1 for based on the     // component ID.     $max_length = 40;
    $input = strtolower($input);
    $input = strtr($input, '-_:', '000');
    $input = substr($input, 0, $max_length);
    $chars = str_split($input);
    $chars = array_pad($chars, 20, '0');
    $sum = array_reduce($chars, static fn(int $total, string $char) => $total + ord($char), 0);
    $num = $sum / 4880;

    // Compute an int between 129338 and 129431, which is the sequential emoji     // range we are interested in. We chose this range because all integers in     // between correspond to an emoji. These emojis depict sports, food, and     // animals.     $html_entity = floor(129338 + $num * (129431 - 129338));
    $emoji = mb_convert_encoding("&#$html_entity;", 'UTF-8', 'HTML-ENTITIES');
    return is_string($emoji) ? $emoji : '';
  }

            }
            $ret .= substr($this->data, $start, $to - $start);
        }

        return $ret;
    }

    public function readBytes(int $length): ?array
    {
        if (null !== $read = $this->read($length)) {
            return array_map('ord', str_split($read, 1));
        }

        return null;
    }

    public function setPointer(int $charOffset): void
    {
        if ($this->charCount < $charOffset) {
            $charOffset = $this->charCount;
        }
        $this->currentPos = $charOffset;
    }

$path = $this->normalize($path);

        $path = ltrim($path, '/');
        $pathElements = explode('/', $path);
        $pathInfo = pathinfo($path);
        $md5hash = md5($path);

        if (empty($pathInfo['extension'])) {
            return '';
        }

        $realPath = \array_slice(str_split($md5hash, 2), 0, 3);
        $realPath = $pathElements[0] . '/' . $pathElements[1] . '/' . implode('/', $realPath) . '/' . $pathInfo['basename'];

        if (!$this->hasBlacklistParts($realPath)) {
            return $realPath;
        }

        foreach ($this->blacklist as $key => $value) {
            // must be called 2 times, because the second level won't be matched in the first call             $realPath = str_replace($key, $value, $realPath);
            $realPath = str_replace($key, $value, $realPath);
        }

    public function getClassPath($class)
    {
        foreach ($this->namespaces as $namespace) {
            if (!str_starts_with($class, $namespace['namespace'])) {
                continue;
            }
            $path = substr($class, \strlen($namespace['namespace']) + 1);
            $path = str_replace(str_split($namespace['separator']), DIRECTORY_SEPARATOR, $path);
            $path = $namespace['path'] . $path . $namespace['extension'];
            $path = self::isReadable($path);
            if (\is_string($path)) {
                return $path;
            }
        }

        return null;
    }

    /** * Checks if the given class is loaded. * * @param string $class * * @return bool */

if ($start === false) {
                    $regex .= '|';
                }

                $start  = false;
                $regex .= '(';
                $one    = null;
                if (strlen($row) > 2) {
                    $one = true;
                }

                foreach (str_split($row, 1) as $char) {
                    $regex .= '[' . $char;
                    $regex .= strtoupper($char) . ']';
                    if ($one === true) {
                        $one    = false;
                        $regex .= '(';
                    }
                }

                if ($one === false) {
                    $regex .= ')';
                }

throw new RuntimeException('Could not create captcha image');
        }

        if (!empty($this->config->get('CaptchaColor'))) {
            $colors = explode(',', $this->config->get('CaptchaColor'));
        } else {
            $colors = explode(',', '255,0,0');
        }

        $black = (int) imagecolorallocate($im, (int) $colors[0], (int) $colors[1], (int) $colors[2]);

        $string = implode(' ', str_split($string));

        if (!empty($font)) {
            for ($i = 0, $iMax = \strlen($string); $i < $iMax; ++$i) {
                $rand1 = Random::getInteger(35, 40);
                $rand2 = Random::getInteger(15, 20);
                $rand3 = Random::getInteger(60, 70);
                imagettftext($im, $rand1, $rand2, ($i + 1) * 15, $rand3, $black, $font, $string[$i]);
                imagettftext($im, $rand1, $rand2, (($i + 1) * 15) + 2, $rand3 + 2, $black, $font, $string[$i]);
            }
            for ($i = 0; $i < 8; ++$i) {
                imageline($im, Random::getInteger(30, 70), Random::getInteger(0, 50), Random::getInteger(100, 150),

protected $_checksum = '_royalmail';

    /** * Validates the checksum () * * @param string $value The barcode to validate * @return boolean */
    protected function _royalmail($value)
    {
        $checksum = substr($value, -1, 1);
        $values   = str_split(substr($value, 0, -1));
        $rowvalue = 0;
        $colvalue = 0;
        foreach($values as $row) {
            $rowvalue += $this->_rows[$row];
            $colvalue += $this->_columns[$row];
        }

        $rowvalue %= 6;
        $colvalue %= 6;

        $rowchkvalue = array_keys($this->_rows, $rowvalue);

    private static function punycodeDecode($input)
    {
        $n = self::INITIAL_N;
        $out = 0;
        $i = 0;
        $bias = self::INITIAL_BIAS;
        $lastDelimIndex = strrpos($input, self::DELIMITER);
        $b = false === $lastDelimIndex ? 0 : $lastDelimIndex;
        $inputLength = \strlen($input);
        $output = [];
        $bytes = array_map('ord', str_split($input));

        for ($j = 0; $j < $b; ++$j) {
            if ($bytes[$j] > 0x7F) {
                throw new Exception('Invalid input');
            }

            $output[$out++] = $input[$j];
        }

        if ($b > 0) {
            ++$b;
        }

$_SERVER['HTTP_'.$key] = implode(', ', $value);
            }
        }

        $request = ['g' => $_GET, 'p' => $_POST, 'c' => $_COOKIE];

        $requestOrder = \ini_get('request_order') ?: \ini_get('variables_order');
        $requestOrder = preg_replace('#[^cgp]#', '', strtolower($requestOrder)) ?: 'gp';

        $_REQUEST = [[]];

        foreach (str_split($requestOrder) as $order) {
            $_REQUEST[] = $request[$order];
        }

        $_REQUEST = array_merge(...$_REQUEST);
    }

    /** * Sets a list of trusted proxies. * * You should only list the reverse proxies that you manage directly. * * @param array $proxies A list of trusted proxies, the string 'REMOTE_ADDR' will be replaced with $_SERVER['REMOTE_ADDR'] * @param int $trustedHeaderSet A bit field of Request::HEADER_*, to set which headers to trust from your proxies * * @return void */

    function safe_mailto(string $email, string $title = '', $attributes = ''): string
    {
        $count = 0;
        if (trim($title) === '') {
            $title = $email;
        }

        $x = str_split('<a href="mailto:', 1);

        for ($i = 0, $l = strlen($email); $i < $l; $i++) {
            $x[] = '|' . ord($email[$i]);
        }

        $x[] = '"';

        if ($attributes !== '') {
            if (is_array($attributes)) {
                foreach ($attributes as $key => $val) {
                    $x[] = ' ' . $key . '="';

        $opacity = (int) ($options['opacity'] * 127);

        // Allow opacity to be applied to the text         imagealphablending($src, true);

        $color = $isShadow ? $options['shadowColor'] : $options['color'];

        // shorthand hex, #f00         if (strlen($color) === 3) {
            $color = implode('', array_map('str_repeat', str_split($color), [2, 2, 2]));
        }

        $color = str_split(substr($color, 0, 6), 2);
        $color = imagecolorclosestalpha($src, hexdec($color[0]), hexdec($color[1]), hexdec($color[2]), $opacity);

        $xAxis = $isShadow ? $options['xShadow'] : $options['xAxis'];
        $yAxis = $isShadow ? $options['yShadow'] : $options['yAxis'];

        // Add the shadow to the source image         if (! empty($options['fontPath'])) {
            // We have to add fontheight because imagettftext locates the bottom left corner, not top-left corner.

/** @psalm-var positive-int */
    public static $chunk_length = 0x4;

    public function renderTab(Representation $r): ?string
    {
        if (!\is_string($r->contents)) {
            return null;
        }

        $out = '<pre>';

        $lines = \str_split($r->contents, self::$line_length);

        foreach ($lines as $index => $line) {
            $out .= \sprintf('%08X', $index * self::$line_length).":\t";

            $chunks = \str_split(\str_pad(\bin2hex($line), 2 * self::$line_length, ' '), self::$chunk_length);

            $out .= \implode(' ', $chunks);
            $out .= "\t".\preg_replace('/[^\\x20-\\x7E]/', '.', $line)."\n";
        }

        $out .= '</pre>';