PHP Function Ord - How to Use it in Your Own Code

The php function ord is used to return the ASCII value of the first character of a string in PHP. This is an important function to know if you want to become a proficient PHP developer. In this article, we’ll take a look at the syntax for this function and see how it can be used in your own code.

When using ord, you’ll need to pass in the string that you want to check for its ASCII value. The string can be anything, but it should be a valid string and contain at least one letter. Then, you’ll need to tell the function where in the string you’d like it to search for its ASCII value.

Alternatively, you can also use the str_split() function to convert a string into an array. This function will split the string into smaller substrings based on a separator, such as a comma or a dot. After each split, the function will store the corresponding substrings in an array and then return that array.

Another useful function for converting strings into an array is the json_decode() function. This is the opposite of the serialize() function, and it will decode a string into an array.

When writing your code, remember that all PHP reserved keywords and types must be in lower case. Furthermore, control operators (such as +, -, =,!=, etc.) should be placed on separate lines than the statements they are operating on, for readability.

Andreas Behr - CTO of DesertCoderz
You are a developer and looking for Shopware projects?
Apply Now!

ord example

if ($tail) {
                        $lastUchr .= $tail;
                        $tail = '';
                    }

                    $result .= $lastUchr;
                    $lastUchr = $uchr;
                }
            } else {
                // Hangul chars
                $L = \ord($lastUchr[2]) - 0x80;
                $V = \ord($uchr[2]) - 0xA1;
                $T = 0;

                $uchr = substr($s, $i + $ulen, 3);

                if ("\xE1\x86\xA7" <= $uchr && $uchr <= "\xE1\x87\x82") {
                    $T = \ord($uchr[2]) - 0xA7;
                    0 > $T && $T += 0x40;
                    $ulen += 3;
                }

                
if (isset($this->info[$tag_key]['tag_offset_start'])) {
                    $this->info['avdataend'] = min($this->info['avdataend'], $this->info[$tag_key]['tag_offset_start']);
                }
            }

            // ID3v2 detection (NOT parsing), even if ($this->option_tag_id3v2 == false) done to make fileformat easier             if (!$this->option_tag_id3v2) {
                fseek($this->fp, 0);
                $header = fread($this->fp, 10);
                if ((substr($header, 0, 3) == 'ID3') && (strlen($header) == 10)) {
                    $this->info['id3v2']['header']        = true;
                    $this->info['id3v2']['majorversion']  = ord($header[3]);
                    $this->info['id3v2']['minorversion']  = ord($header[4]);
                    $this->info['avdataoffset']          += getid3_lib::BigEndian2Int(substr($header, 6, 4), 1) + 10; // length of ID3v2 tag in 10-byte header doesn't include 10-byte header length                 }
            }

            // read 32 kb file data             fseek($this->fp, $this->info['avdataoffset']);
            $formattest = fread($this->fp, 32774);

            // determine format             $determined_format = $this->GetFileFormat($formattest, ($original_filename ? $original_filename : $filename));

            


    /** * Checks whether a (single-byte) character is an ASCII letter or not. * * @param string $input A single-byte string * * @return bool True if it is a letter, False otherwise */
    protected function is_alpha($input)
    {
        $code = ord($input);

        return ($code >= 97 && $code <= 122) || ($code >= 65 && $code <= 90);
    }
}
        $string = preg_replace('/%(?![A-Fa-f0-9]{2})/', '%25', $string);

        // Add unreserved and % to $extra_chars (the latter is safe because all         // pct-encoded sections are now valid).         $extra_chars .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~%';

        // Now replace any bytes that aren't allowed with their pct-encoded versions         $position = 0;
        $strlen = strlen($string);
        while (($position += strspn($string, $extra_chars, $position)) < $strlen)
        {
            $value = ord($string[$position]);

            // Start position             $start = $position;

            // By default we are valid             $valid = true;

            // No one byte sequences are valid due to the while.             // Two byte sequence:             if (($value & 0xE0) === 0xC0)
            {
                
            fseek($fh, 20);
            $extendedFlags = fread($fh, 1);
            if ($extendedFlags === false) {
                if (!Feature::isActive('v6.6.0.0')) {
                    throw new StreamNotReadableException('Webp File not readable');
                }

                throw MediaException::cannotOpenSourceStreamToRead($filename);
            }
            // move the bits of $extendedFlags one bit position to the right so that the animation bit flag is on the first position             // [00101100] & [00000001] results to [00000000], [00101101] & [00000001] results to [00000001]             $result = (bool) ((\ord($extendedFlags) >> 1) & 00000001);
        }
        fclose($fh);

        return $result;
    }
}
$v_data_header = unpack('a1id1/a1id2/a1cm/a1flag/Vmtime/a1xfl/a1os', $v_binary_data);

    // ----- Check some parameters     $v_data_header['os'] = bin2hex($v_data_header['os']);

    // ----- Read the gzip file footer     @fseek($v_file_compressed, filesize($v_gzip_temp_name)-8);
    $v_binary_data = @fread($v_file_compressed, 8);
    $v_data_footer = unpack('Vcrc/Vcompressed_size', $v_binary_data);

    // ----- Set the attributes     $p_header['compression'] = ord($v_data_header['cm']);
    //$p_header['mtime'] = $v_data_header['mtime'];     $p_header['crc'] = $v_data_footer['crc'];
    $p_header['compressed_size'] = filesize($v_gzip_temp_name)-18;

    // ----- Close the file     @fclose($v_file_compressed);

    // ----- Call the header generation     if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
      return $v_result;
    }

    
throw new InvalidArgumentException('The length of the alphabet must in the [2^1, 2^56] range.');
        }

        $ret = '';
        while ($length > 0) {
            $urandomLength = (int) ceil(2 * $length * $bits / 8.0);
            $data = random_bytes($urandomLength);
            $unpackedData = 0;
            $unpackedBits = 0;
            for ($i = 0; $i < $urandomLength && $length > 0; ++$i) {
                // Unpack 8 bits                 $unpackedData = ($unpackedData << 8) | \ord($data[$i]);
                $unpackedBits += 8;

                // While we have enough bits to select a character from the alphabet, keep                 // consuming the random data                 for (; $unpackedBits >= $bits && $length > 0; $unpackedBits -= $bits) {
                    $index = ($unpackedData & ((1 << $bits) - 1));
                    $unpackedData >>= $bits;
                    // Unfortunately, the alphabet size is not necessarily a power of two.                     // Worst case, it is 2^k + 1, which means we need (k+1) bits and we                     // have around a 50% chance of missing as k gets larger                     if ($index < $alphabetSize) {
                        

    protected function _secureStringCompare($a, $b)
    {
        if (strlen($a) !== strlen($b)) {
            return false;
        }
        $result = 0;
        for ($i = 0; $i < strlen($a); $i++) {
            $result |= ord($a[$i]) ^ ord($b[$i]);
        }
        return $result == 0;
    }
}
return $ret;
    }

    /** * Make sure CRLF is correct and HT/SPACE are in valid places. */
    private function standardize(string $string): string
    {
        $string = str_replace(["\t=0D=0A", ' =0D=0A', '=0D=0A'], ["=09\r\n", "=20\r\n", "\r\n"], $string);

        return match ($end = \ord(substr($string, -1))) {
            0x09,
            0x20 => substr_replace($string, self::QP_MAP[$end], -1),
            default => $string,
        };
    }
}

    protected function _secureStringCompare($a, $b)
    {
        if (strlen($a) !== strlen($b)) {
            return false;
        }
        $result = 0;
        for ($i = 0; $i < strlen($a); $i++) {
            $result |= ord($a[$i]) ^ ord($b[$i]);
        }
        return $result == 0;
    }
}

        return true;
    }

    /** * @return int|float|false */
    private function readEBMLint() {
        $actual_offset = $this->current_offset - $this->EBMLbuffer_offset;

        // get length of integer         $first_byte_int = ord($this->EBMLbuffer[$actual_offset]);
        if       (0x80 & $first_byte_int) {
            $length = 1;
        } elseif (0x40 & $first_byte_int) {
            $length = 2;
        } elseif (0x20 & $first_byte_int) {
            $length = 3;
        } elseif (0x10 & $first_byte_int) {
            $length = 4;
        } elseif (0x08 & $first_byte_int) {
            $length = 5;
        } elseif (0x04 & $first_byte_int) {
            
if ('A' === $c[2] && -1 === $ofs) {
                        $ofs = 0;
                    }

                    if (0 === $numMatches) {
                        continue;
                    }

                    $ofs += ('A' === $c[2]) ? -1 : 1;
                    $ofs = ($numMatches + $ofs) % $numMatches;
                }
            } elseif (\ord($c) < 32) {
                if ("\t" === $c || "\n" === $c) {
                    if ($numMatches > 0 && -1 !== $ofs) {
                        $ret = (string) $matches[$ofs];
                        // Echo out remaining chars for current match                         $remainingCharacters = substr($ret, \strlen(trim($this->mostRecentlyEnteredValue($fullChoice))));
                        $output->write($remainingCharacters);
                        $fullChoice .= $remainingCharacters;
                        $i = (false === $encoding = mb_detect_encoding($fullChoice, null, true)) ? \strlen($fullChoice) : mb_strlen($fullChoice, $encoding);

                        $matches = array_filter(
                            $autocomplete($ret),
                            
$found = preg_match('/([^a-z0-9\x2d]{1,10})$/i', $encoded);
        if (empty($encoded) || ($found > 0)) {
            // no punycode encoded string, return as is             $this->_error(self::CANNOT_DECODE_PUNYCODE);
            return false;
        }

        $separator = strrpos($encoded, '-');
        if ($separator > 0) {
            for ($x = 0; $x < $separator; ++$x) {
                // prepare decoding matrix                 $decoded[] = ord($encoded[$x]);
            }
        } else {
            $this->_error(self::CANNOT_DECODE_PUNYCODE);
            return false;
        }

        $lengthd = count($decoded);
        $lengthe = strlen($encoded);

        // decoding         $init  = true;
        
throw new InvalidArgumentException('The length of the alphabet must in the [2^1, 2^56] range.');
        }

        $ret = '';
        while ($length > 0) {
            $urandomLength = (int) ceil(2 * $length * $bits / 8.0);
            $data = random_bytes($urandomLength);
            $unpackedData = 0;
            $unpackedBits = 0;
            for ($i = 0; $i < $urandomLength && $length > 0; ++$i) {
                // Unpack 8 bits                 $unpackedData = ($unpackedData << 8) | \ord($data[$i]);
                $unpackedBits += 8;

                // While we have enough bits to select a character from the alphabet, keep                 // consuming the random data                 for (; $unpackedBits >= $bits && $length > 0; $unpackedBits -= $bits) {
                    $index = ($unpackedData & ((1 << $bits) - 1));
                    $unpackedData >>= $bits;
                    // Unfortunately, the alphabet size is not necessarily a power of two.                     // Worst case, it is 2^k + 1, which means we need (k+1) bits and we                     // have around a 50% chance of missing as k gets larger                     if ($index < $alphabetSize) {
                        
// set md5_data_source - built into flac 0.5+         if (isset($info['flac']['STREAMINFO']['audio_signature'])) {

            if ($info['flac']['STREAMINFO']['audio_signature'] === str_repeat("\x00", 16)) {
                $this->warning('FLAC STREAMINFO.audio_signature is null (known issue with libOggFLAC)');
            }
            else {
                $info['md5_data_source'] = '';
                $md5 = $info['flac']['STREAMINFO']['audio_signature'];
                for ($i = 0; $i < strlen($md5); $i++) {
                    $info['md5_data_source'] .= str_pad(dechex(ord($md5[$i])), 2, '00', STR_PAD_LEFT);
                }
                if (!preg_match('/^[0-9a-f]{32}$/', $info['md5_data_source'])) {
                    unset($info['md5_data_source']);
                }
            }
        }

        if (isset($info['flac']['STREAMINFO']['bits_per_sample'])) {
            $info['audio']['bits_per_sample'] = $info['flac']['STREAMINFO']['bits_per_sample'];
            if ($info['audio']['bits_per_sample'] == 8) {
                // special case
Home | Imprint | This part of the site doesn't use cookies.