chr - PHP code example

Using the PHP Function Chr

Strings are a fundamental part of PHP, allowing you to create web pages that are easy to read and navigate. Strings can be manipulated and altered with a variety of string functions, which are useful for performing common tasks like concatenation, searching, and manipulation.

The chr function converts an ASCII code value to a character. ASCII stands for American Standard Code for Information Interchange and is a set of 255 numbers that evaluate to letters, symbols, and actions used in most computers. For example, 74 is a tab character and 106 is a space. To use a special character in a string literal, you must surround it with a backslash () to prevent PHP from interpolating it into a variable.

You can also use an escape sequence to escape a single character in a string literal. This allows you to avoid using characters that could be interpreted as a new line or as an escape character. The t escape sequence is commonly used to ensure that a tab character is not interpreted as a space, and it also prevents various IDEs from automatically changing the tab character to spaces.

In addition to recognizing decimal numeric values, PHP supports other number notations such as binary, octal, hexadecimal, and scientific "E" notation. The is_binary, is_unicode, and is_buffer functions help you distinguish between these different types of numbers.

Incorrectly handling non-ASCII strings is one of the most common ways to introduce gnarly heisenbugs into your code. Even simple string functions such as strlen($_POST['name']) can be susceptible to these issues if they do not properly handle UTF-8 strings.

chr example

$counter = 0;

    // Continue to loop if $unique is TRUE and the generated string is not     // unique or if $validator is a callable that returns FALSE. To generate a     // random string this loop must be carried out at least once.     do {
      if ($counter == static::MAXIMUM_TRIES) {
        throw new \RuntimeException('Unable to generate a unique random name');
      }
      $str = '';
      for ($i = 0; $i < $length; $i++) {
        $str .= chr(mt_rand(32, 126));
      }
      $counter++;

      $continue = FALSE;
      if ($unique) {
        $continue = isset($this->strings[$str]);
      }
      if (!$continue && is_callable($validator)) {
        // If the validator callback returns FALSE generate another random         // string.         $continue = !call_user_func($validator, $str);
      }

if ( ! isset( $packs[ $algo ] ) ) {
        return false;
    }

    $pack = $packs[ $algo ];

    if ( strlen( $key ) > 64 ) {
        $key = pack( $pack, $algo( $key ) );
    }

    $key = str_pad( $key, 64, chr( 0 ) );

    $ipad = ( substr( $key, 0, 64 ) ^ str_repeat( chr( 0x36 ), 64 ) );
    $opad = ( substr( $key, 0, 64 ) ^ str_repeat( chr( 0x5C ), 64 ) );

    $hmac = $algo( $opad . pack( $pack, $algo( $ipad . $data ) ) );

    if ( $binary ) {
        return pack( $pack, $hmac );
    }

    return $hmac;
}

$value = preg_replace($this->patterns->getNewLineEscapePattern(), '', $value);

        return $this->escapeUnicode($value);
    }

    private function replaceUnicodeSequences(string $value): string
    {
        return preg_replace_callback($this->patterns->getUnicodeEscapePattern(), function D$match) {
            $c = hexdec($match[1]);

            if (0x80 > $c %= 0x200000) {
                return \chr($c);
            }
            if (0x800 > $c) {
                return \chr(0xC0 | $c >> 6).\chr(0x80 | $c & 0x3F);
            }
            if (0x10000 > $c) {
                return \chr(0xE0 | $c >> 12).\chr(0x80 | $c >> 6 & 0x3F).\chr(0x80 | $c & 0x3F);
            }

            return '';
        }, $value);
    }
}

/** * @author Chris Corbyn */
final class QpMimeHeaderEncoder extends QpEncoder implements MimeHeaderEncoderInterface
{
    protected function initSafeMap(): void
    {
        foreach (array_merge(
            range(0x61, 0x7A), range(0x41, 0x5A),
            range(0x30, 0x39), [0x20, 0x21, 0x2A, 0x2B, 0x2D, 0x2F]
        ) as $byte) {
            $this->safeMap[$byte] = \chr($byte);
        }
    }

    public function getName(): string
    {
        return 'Q';
    }

    public function encodeString(string $string, ?string $charset = 'utf-8', int $firstLineOffset = 0, int $maxLineLength = 0): string
    {
        return str_replace([' ', '=20', "=\r\n"], ['_', '_', "\r\n"],

  public static function intToAlphadecimal($i = 0) {
    $num = base_convert((int) $i, 10, 36);
    $length = strlen($num);

    return chr($length + ord('0') - 1) . $num;
  }

  /** * Decodes a sorting code back to an integer. * * @param string $string * The alpha decimal value to convert * * @return int * The integer value. * * @see \Drupal\Component\Utility\Number::intToAlphadecimal */

  public function testSearchTextProcessorUnicode() {
    // This test uses a file that was constructed so that the even lines are     // boundary characters, and the odd lines are valid word characters. (It     // was generated as a sequence of all the Unicode characters, and then the     // boundary characters (punctuation, spaces, etc.) were split off into     // their own lines). So the even-numbered lines should simplify to nothing,     // and the odd-numbered lines we need to split into shorter chunks and     // verify that text processing doesn't lose any characters.     $input = file_get_contents($this->root . '/core/modules/search/tests/UnicodeTest.txt');
    $basestrings = explode(chr(10), $input);
    $strings = [];
    $text_processor = \Drupal::service('search.text_processor');
    assert($text_processor instanceof SearchTextProcessorInterface);
    foreach ($basestrings as $key => $string) {
      if ($key % 2) {
        // Even line - should simplify down to a space.         $simplified = $text_processor->analyze($string);
        $this->assertSame(' ', $simplified, "Line {$key} is excluded from the index");
      }
      else {
        // Odd line, should be word characters.

return substr_count($haystack, $needle);
    }

    public static function mb_output_handler($contents, $status)
    {
        return $contents;
    }

    public static function mb_chr($code, $encoding = null)
    {
        if (0x80 > $code %= 0x200000) {
            $s = \chr($code);
        } elseif (0x800 > $code) {
            $s = \chr(0xC0 | $code >> 6).\chr(0x80 | $code & 0x3F);
        } elseif (0x10000 > $code) {
            $s = \chr(0xE0 | $code >> 12).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
        } else {
            $s = \chr(0xF0 | $code >> 18).\chr(0x80 | $code >> 12 & 0x3F).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
        }

        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
            $s = mb_convert_encoding($s, $encoding, 'UTF-8');
        }

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

                $L = 0xAC00 + ($L * 21 + $V) * 28 + $T;
                $lastUchr = \chr(0xE0 | $L >> 12).\chr(0x80 | $L >> 6 & 0x3F).\chr(0x80 | $L & 0x3F);
            }

            $i += $ulen;
        }

        return $result.$lastUchr.$tail;
    }

    private static function decompose($s, $c)
    {
        $result = '';

/* -- RFC 2045, 6.7 -- (2) (Literal representation) Octets with decimal values of 33 through 60 inclusive, and 62 through 126, inclusive, MAY be represented as the US-ASCII characters which correspond to those octets (EXCLAMATION POINT through LESS THAN, and GREATER THAN through TILDE, respectively). */

        $encoder = new QpEncoder();
        foreach (array_merge(range(33, 60), range(62, 126)) as $ordinal) {
            $char = \chr($ordinal);
            $this->assertSame($char, $encoder->encodeString($char));
        }
    }

    public function testWhiteSpaceAtLineEndingIsEncoded()
    {
        /* -- RFC 2045, 6.7 -- (3) (White Space) Octets with values of 9 and 32 MAY be represented as US-ASCII TAB (HT) and SPACE characters, respectively, but MUST NOT be so represented at the end of an encoded line. Any TAB (HT) or SPACE characters on an encoded line MUST thus be followed on that line by a printable character. In particular, an "=" at the end of an encoded line, indicating a soft line break (see rule #5) may follow one or more TAB (HT) or SPACE characters. It follows that an octet with decimal value 9 or 32 appearing at the end of an encoded line must be represented according to Rule #1. This rule is necessary because some MTAs (Message Transport Agents, programs which transport messages from one user to another, or perform a portion of such transfers) are known to pad lines of text with SPACEs, and others are known to remove "white space" characters from the end of a line. Therefore, when decoding a Quoted-Printable body, any trailing white space on a line must be deleted, as it will necessarily have been added by intermediate transport agents. */

        // 1xxx xxxx - value 0 to 2^7-2         // 01xx xxxx xxxx xxxx - value 0 to 2^14-2         // 001x xxxx xxxx xxxx xxxx xxxx - value 0 to 2^21-2         // 0001 xxxx xxxx xxxx xxxx xxxx xxxx xxxx - value 0 to 2^28-2         // 0000 1xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx - value 0 to 2^35-2         // 0000 01xx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx - value 0 to 2^42-2         // 0000 001x xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx - value 0 to 2^49-2         // 0000 0001 xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx - value 0 to 2^56-2
        $first_byte_int = ord($EBMLstring[0]);
        if (0x80 & $first_byte_int) {
            $EBMLstring[0] = chr($first_byte_int & 0x7F);
        } elseif (0x40 & $first_byte_int) {
            $EBMLstring[0] = chr($first_byte_int & 0x3F);
        } elseif (0x20 & $first_byte_int) {
            $EBMLstring[0] = chr($first_byte_int & 0x1F);
        } elseif (0x10 & $first_byte_int) {
            $EBMLstring[0] = chr($first_byte_int & 0x0F);
        } elseif (0x08 & $first_byte_int) {
            $EBMLstring[0] = chr($first_byte_int & 0x07);
        } elseif (0x04 & $first_byte_int) {
            $EBMLstring[0] = chr($first_byte_int & 0x03);
        } elseif (0x02 & $first_byte_int) {

'{',
      '|',
      '}',
      '~',
    ];
    foreach ($unsafe_chars as $unsafe_char) {
      $data['unsafe-' . $unsafe_char] = ['kitt' . $unsafe_char . 'ens', FALSE];
    }

    // The ASCII control characters are in the range 0x00 to 0x1F plus 0x7F.     for ($ascii = 0; $ascii <= 0x1F; $ascii++) {
      $data['unsafe-ascii-control-' . $ascii] = ['kitt' . chr($ascii) . 'ens', FALSE];
    }
    $data['unsafe-ascii-control-' . 0x7F] = ['kitt' . chr(0x7F) . 'ens', FALSE];

    return $data;
  }

  /** * Provides test cases. * * @dataProvider providerTestIsValidCustomQueryParameter * @covers ::isValidCustomQueryParameter * @covers ::isValidMemberName */

for ($i = $lengthd; $i > $index; $i--) {
                    $decoded[$i] = $decoded[($i - 1)];
                }
            }

            $decoded[$index++] = $char;
        }

        // convert decoded ucs4 to utf8 string         foreach ($decoded as $key => $value) {
            if ($value < 128) {
                $decoded[$key] = chr($value);
            } elseif ($value < (1 << 11)) {
                $decoded[$key]  = chr(192 + ($value >> 6));
                $decoded[$key] .= chr(128 + ($value & 63));
            } elseif ($value < (1 << 16)) {
                $decoded[$key]  = chr(224 + ($value >> 12));
                $decoded[$key] .= chr(128 + (($value >> 6) & 63));
                $decoded[$key] .= chr(128 + ($value & 63));
            } elseif ($value < (1 << 21)) {
                $decoded[$key]  = chr(240 + ($value >> 18));
                $decoded[$key] .= chr(128 + (($value >> 12) & 63));
                $decoded[$key] .= chr(128 + (($value >> 6) & 63));

  protected function replace($code, $langcode, $unknown_character) {
    if ($code < 0x80) {
      // Already lower ASCII.       return chr($code);
    }

    // See if there is a language-specific override for this character.     if (!isset($this->languageOverrides[$langcode])) {
      $this->readLanguageOverrides($langcode);
    }
    if (isset($this->languageOverrides[$langcode][$code])) {
      return $this->languageOverrides[$langcode][$code];
    }

    return $this->lookupReplacement($code, $unknown_character);
  }

private static $transliterators = [];
    private static $tableZero;
    private static $tableWide;

    public static function fromCodePoints(int ...$codes): static
    {
        $string = '';

        foreach ($codes as $code) {
            if (0x80 > $code %= 0x200000) {
                $string .= \chr($code);
            } elseif (0x800 > $code) {
                $string .= \chr(0xC0 | $code >> 6).\chr(0x80 | $code & 0x3F);
            } elseif (0x10000 > $code) {
                $string .= \chr(0xE0 | $code >> 12).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
            } else {
                $string .= \chr(0xF0 | $code >> 18).\chr(0x80 | $code >> 12 & 0x3F).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
            }
        }

        return new static($string);
    }

            $iso_language_id  = '';
            $iso_language_id .= chr((($languageid & 0x7C00) >> 10) + 0x60);
            $iso_language_id .= chr((($languageid & 0x03E0) >>  5) + 0x60);
            $iso_language_id .= chr((($languageid & 0x001F) >>  0) + 0x60);
            $QuicktimeLanguageLookup[$languageid] = getid3_id3v2::LanguageLookup($iso_language_id);
        }
        return (isset($QuicktimeLanguageLookup[$languageid]) ? $QuicktimeLanguageLookup[$languageid] : 'invalid');
    }

    /** * @param string $codecid * * @return string */