Character codes: Difference between revisions

Line 1:

[[Category:Basic language learning]]

[[Category:String manipulation]]

[[Category:Simple]]

Line 14:

Conversely, given a code, print out the corresponding character.

=={{header|11l}}==

<syntaxhighlight lang=11l>print(‘a’.code) // prints "97"

<syntaxhighlight lang="11l">print(‘a’.code) // prints "97"

print(Char(code' 97)) // prints "a"</syntaxhighlight>

=={{header|360 Assembly}}==

S/360 architecture and EBCDIC was born together.

In EBCDIC, the character 'a' (lowercase letter A) has a code of 129 in decimal and '81'x in hexadecimal.

To perform conversion, we use IC (insert character) and STC (store character) opcodes.

<syntaxhighlight lang=360asm>* Character codes EBCDIC 15/02/2017

<syntaxhighlight lang="360asm">* Character codes EBCDIC 15/02/2017

CHARCODE CSECT

USING CHARCODE,R13 base register

Line 66:

Line 64:

The printing routine only understands ASCII characters as codes anyway, so the "given a code produce its character" part is trivial.

The <code>PrintChar</code> routine is omitted for brevity. It converts the two cursor variables to a FIX layer address and outputs the character using the NEOGEO's FIX layer (the layer where text is displayed). Characters are stored in ROM and arranged in ASCII order.

<syntaxhighlight lang=68000devpac> JSR ResetCoords ;RESET TYPING CURSOR

<syntaxhighlight lang="68000devpac"> JSR ResetCoords ;RESET TYPING CURSOR

MOVE.B #'A',D1

Line 141:

Line 139:

rts</syntaxhighlight>

Output can be seen [https://ibb.co/ngtDXpq here.]

=={{header|AArch64 Assembly}}==

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program character64.s */

Line 205:

Line 202:

.include "../includeARM64.inc"

</syntaxhighlight>

=={{header|ABAP}}==

In ABAP you must first cast the character to a byte field and back to a number in order to get its ASCII value.

<syntaxhighlight lang=~~ABAP~~>report zcharcode

<syntaxhighlight lang="abap">report zcharcode

data: c value 'A', n type i.

field-symbols <n> type x.

Line 216:

Line 212:

write: c, '=', n left-justified.</syntaxhighlight>

{{Out}}<pre>A = 65</pre>

=={{header|ACL2}}==

Similar to Common Lisp:

<syntaxhighlight lang=~~Lisp~~>(cw "~x0" (char-code #\a))

<syntaxhighlight lang="lisp">(cw "~x0" (char-code #\a))

(cw "~x0" (code-char 97))</syntaxhighlight>

=={{header|Action!}}==

<syntaxhighlight lang=~~Action~~!>PROC Main()

<syntaxhighlight lang="action!">PROC Main()

CHAR c=['a]

BYTE b=[97]

Line 236:

Line 230:

97=a

</pre>

=={{header|ActionScript}}==

In ActionScript, you cannot take the character code of a character directly. Instead you must create a string and call charCodeAt with the character's position in the string as a parameter.

<syntaxhighlight lang=~~ActionScipt~~>trace(String.fromCharCode(97)); //prints 'a'

<syntaxhighlight lang="actionscipt">trace(String.fromCharCode(97)); //prints 'a'

trace("a".charCodeAt(0));//prints '97'</syntaxhighlight>

=={{header|Ada}}==

<syntaxhighlight lang=ada>with Ada.Text_IO; use Ada.Text_IO;

<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;

procedure Char_Code is

Line 252:

Line 244:

=={{header|Aime}}==

<syntaxhighlight lang=aime># prints "97"

<syntaxhighlight lang="aime"># prints "97"

o_integer('a');

o_byte('\n');

Line 260:

Line 251:

o_byte(97);

o_byte('\n');</syntaxhighlight>

=={{header|ALGOL 68}}==

In ALGOL 68 the '''format''' $g$ is type aware, hence the type conversion operators '''abs''' & '''repr''' are used to set the type.

<syntaxhighlight lang=algol68>main:(

<syntaxhighlight lang="algol68">main:(

printf(($gl$, ABS "a")); # for ASCII this prints "+97" EBCDIC prints "+129" #

printf(($gl$, REPR 97)) # for ASCII this prints "a"; EBCDIC prints "/" #

Line 270:

Line 260:

a foreign tape is mounted, the characters will be converted transparently as the tape's

records are read.

<syntaxhighlight lang=algol68>FILE tape;

<syntaxhighlight lang="algol68">FILE tape;

INT errno = open(tape, "/dev/tape1", stand out channel)

make conv(tape, ebcdic conv);

Line 277:

Line 267:

using the ''stand conv'' query routine and then the conversion applied to a particular

file/tape. eg.

<syntaxhighlight lang=algol68> make conv(tape, stand conv(stand out channel))</syntaxhighlight>

<syntaxhighlight lang="algol68"> make conv(tape, stand conv(stand out channel))</syntaxhighlight>

=={{header|ALGOL W}}==

<syntaxhighlight lang=algolw>begin

<syntaxhighlight lang="algolw">begin

% display the character code of "a" (97 in ASCII) %

write( decode( "a" ) );

Line 286:

Line 275:

write( code( 97 ) );

end.</syntaxhighlight>

=={{header|APL}}==

In GNU APL and Dyalog, <tt>⎕UCS</tt> with an integer returns the corresponding Unicode character:

<syntaxhighlight lang=apl> ⎕UCS 97

<syntaxhighlight lang="apl"> ⎕UCS 97

a</syntaxhighlight>

and <tt>⎕UCS</tt> with a character returns the corresponding code:

<syntaxhighlight lang=apl> ⎕UCS 'a'

<syntaxhighlight lang="apl"> ⎕UCS 'a'

97</syntaxhighlight>

Like most things in APL, <tt>⎕UCS</tt> can also be used with an array or with a string (which is an array of characters):

<syntaxhighlight lang=apl> ⎕UCS 65 80 76

<syntaxhighlight lang="apl"> ⎕UCS 65 80 76

APL

⎕UCS 'Hello, world!'

72 101 108 108 111 44 32 119 111 114 108 100 33</syntaxhighlight>

=={{header|AppleScript}}==

<syntaxhighlight lang=~~AppleScript~~>log(id of "a")

<syntaxhighlight lang="applescript">log(id of "a")

log(id of "aA")</syntaxhighlight>

Line 311:

Line 298:

The converse instruction is <tt>character id</tt> — or either of its synonyms <tt>string id</tt> and <tt>Unicode text id</tt>. Because of a bug admitted to in Apple's AppleScript Language Guide, the expression <tt>text id</tt>, which one might expect to work, can't be used.

<syntaxhighlight lang=applescript>character id 97

<syntaxhighlight lang="applescript">character id 97

--> "a"

Line 322:

Line 309:

Unicode text id {72, 101, 108, 108, 111, 33}

--> "Hello!"</syntaxhighlight>

=={{header|ARM Assembly}}==

/* ARM assembly Raspberry PI */

/* program character.s */

Line 453:

Line 439:

</syntaxhighlight>

=={{header|Arturo}}==

<syntaxhighlight lang=rebol>print to :integer first "a"

<syntaxhighlight lang="rebol">print to :integer first "a"

print to :integer `a`

print to :char 97</syntaxhighlight>

Line 465:

Line 450:

97

a</pre>

=={{header|AutoHotkey}}==

<syntaxhighlight lang=~~AutoHotkey~~>MsgBox % Chr(97)

<syntaxhighlight lang="autohotkey">MsgBox % Chr(97)

MsgBox % Asc("a")</syntaxhighlight>

=={{header|AWK}}==

AWK has no built-in way to convert a character into ASCII (or whatever) code;

but a function that does so can be easily built using an associative array (where the keys are the characters).

The opposite can be done using <tt>printf</tt> (or <tt>sprintf</tt>) with <tt>%c</tt>

<syntaxhighlight lang=awk>function ord(c)

<syntaxhighlight lang="awk">function ord(c)

{

return chmap[c]

Line 487:

Line 470:

print s

}</syntaxhighlight>

=={{header|Axe}}==

<syntaxhighlight lang=axe>Disp 'a'▶Dec,i

<syntaxhighlight lang="axe">Disp 'a'▶Dec,i

Disp 97▶Char,i</syntaxhighlight>

=={{header|Babel}}==

<syntaxhighlight lang=babel>'abcdefg' str2ar

<syntaxhighlight lang="babel">'abcdefg' str2ar

{%d nl <<} eachar</syntaxhighlight>

Line 507:

Line 488:

</pre>

<syntaxhighlight lang=babel>(98 97 98 101 108) ls2lf ar2str nl <<

<syntaxhighlight lang="babel">(98 97 98 101 108) ls2lf ar2str nl <<

</syntaxhighlight>

babel

=={{header|BASIC}}==

<syntaxhighlight lang=qbasic>charCode = 97

<syntaxhighlight lang="qbasic">charCode = 97

char = "a"

PRINT CHR$(charCode) 'prints a

Line 521:

Line 501:

On the ZX Spectrum string variable names must be a single letter but numeric variables can be multiple characters:

<syntaxhighlight lang=zxbasic>10 LET c = 97: REM c is a character code

<syntaxhighlight lang="zxbasic">10 LET c = 97: REM c is a character code

20 LET d$ = "b": REM d$ holds the character

30 PRINT CHR$(c): REM this prints a

Line 528:

Line 508:

==={{header|Applesoft BASIC}}===

CHR$(97) is used in place of "a" because on the older model Apple II, lower case is difficult to input.

{{Out}}<pre>a=97</pre>

Line 535:

Line 515:

==={{header|BaCon}}===

<syntaxhighlight lang=qbasic>' ASCII

<syntaxhighlight lang="qbasic">' ASCII

c$ = "$"

PRINT c$, ": ", ASC(c$)

Line 550:

Line 530:

==={{header|Commodore BASIC}}===

Commodore BASIC uses PETSCII code for its character set.

<syntaxhighlight lang=gwbasic>10 CH = 65: REM IN PETSCII CODE FOR 'A' IS 65

<syntaxhighlight lang="gwbasic">10 CH = 65: REM IN PETSCII CODE FOR 'A' IS 65

20 D$ = "B": REM D$ HOLDS THE CHARACTER 'B'

30 PRINT CHR$(CH): REM THIS PRINTS 'A'

Line 558:

Line 538:

==={{header|IS-BASIC}}===

<syntaxhighlight lang=IS-~~BASIC~~>100 PRINT ORD("A")

<syntaxhighlight lang="is-basic">100 PRINT ORD("A")

110 PRINT CHR$(65)</syntaxhighlight>

Line 564:

Line 544:

<syntaxhighlight lang=~~QBasic~~>PRINT "a - > "; ASC("a")

<syntaxhighlight lang="qbasic">PRINT "a - > "; ASC("a")

PRINT "98 -> "; CHR$(98)</syntaxhighlight>

==={{header|Sinclair ZX81 BASIC}}===

<syntaxhighlight lang=basic>10 REM THE ZX81 USES ITS OWN NON-ASCII CHARACTER SET

<syntaxhighlight lang="basic">10 REM THE ZX81 USES ITS OWN NON-ASCII CHARACTER SET

20 REM WHICH DOES NOT INCLUDE LOWER-CASE LETTERS

30 PRINT CODE "A"

Line 577:

Line 557:

==={{header|True BASIC}}===

<syntaxhighlight lang=qbasic>PRINT "a - > "; ord("a")

<syntaxhighlight lang="qbasic">PRINT "a - > "; ord("a")

PRINT "98 -> "; chr$(98)

END</syntaxhighlight>

==={{header|Yabasic}}===

<syntaxhighlight lang=yabasic>print "a - > ", asc("a")

<syntaxhighlight lang="yabasic">print "a - > ", asc("a")

print "98 -> ", chr$(98)</syntaxhighlight>

=={{header|BASIC256}}==

<syntaxhighlight lang=freebasic># ASCII char

<syntaxhighlight lang="freebasic"># ASCII char

charCode = 97

char$ = "a"

Line 603:

Line 581:

π

960</pre>

=={{header|Batch File}}==

@echo off

Line 651:

Line 627:

a

</pre>

=={{header|BBC BASIC}}==

<syntaxhighlight lang=bbcbasic> charCode = 97

<syntaxhighlight lang="bbcbasic"> charCode = 97

char$ = "a"

PRINT CHR$(charCode) : REM prints a

PRINT ASC(char$) : REM prints 97</syntaxhighlight>

=={{header|Befunge}}==

The instruction <tt>.</tt> will output as an integer. <tt>,</tt> will output as ASCII character.

=={{header|BQN}}==

BQN's character arithmetic makes it easy to convert between numbers and characters. Since arithmetic generalizes to arrays, the same function works for both integers and arrays. Here, only the conversion from number to character is defined, since it can be automatically inverted with Undo (<code>⁼</code>): the inverse simply subtracts <code>@</code>.

<syntaxhighlight lang=bqn> FromCharCode ← @⊸+

<syntaxhighlight lang="bqn"> FromCharCode ← @⊸+

@⊸+

FromCharCode 97

Line 673:

Line 646:

FromCharCode⁼ 'a'

97</syntaxhighlight>

=={{header|Bracmat}}==

<syntaxhighlight lang=bracmat>( put

<syntaxhighlight lang="bracmat">( put

$ ( str

$ ( "\nLatin a

Line 700:

Line 672:

UTF-8: 97 = a

Cyrillic а (UTF-8): 1072 = а</pre>

=={{header|C}}==

<tt>char</tt> is already an integer type in C, and it gets automatically promoted to <tt>int</tt>. So you can use a character where you would otherwise use an integer. Conversely, you can use an integer where you would normally use a character, except you may need to cast it, as <tt>char</tt> is smaller.

<syntaxhighlight lang=c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

int main() {

Line 711:

Line 682:

return 0;

}</syntaxhighlight>

=={{header|C sharp|C#}}==

C# represents strings and characters internally as Unicode,

so casting a char to an int returns its Unicode character encoding.

<syntaxhighlight lang=csharp>using System;

<syntaxhighlight lang="csharp">using System;

namespace RosettaCode.CharacterCode

Line 728:

Line 698:

}

}</syntaxhighlight>

=={{header|C++}}==

<tt>char</tt> is already an integer type in C++, and it gets automatically promoted to <tt>int</tt>. So you can use a character where you would otherwise use an integer. Conversely, you can use an integer where you would normally use a character, except you may need to cast it, as <tt>char</tt> is smaller.

In this case, the output operator <tt><<</tt> is overloaded to handle integer (outputs the decimal representation) and character (outputs just the character) types differently, so we need to cast it in both cases.

<syntaxhighlight lang=cpp>#include <iostream>

<syntaxhighlight lang="cpp">#include <iostream>

int main() {

Line 740:

Line 709:

return 0;

}</syntaxhighlight>

=={{header|Clojure}}==

<syntaxhighlight lang=clojure>(print (int \a)) ; prints "97"

<syntaxhighlight lang="clojure">(print (int \a)) ; prints "97"

(print (char 97)) ; prints \a

Line 752:

Line 720:

(print (.codePointAt "𝅘𝅥𝅮" 0)) ; prints 119136

(print (String. (int-array 1 119136) 0 1)) ; prints 𝅘𝅥𝅮</syntaxhighlight>

=={{header|CLU}}==

<syntaxhighlight lang=clu>start_up = proc ()

<syntaxhighlight lang="clu">start_up = proc ()

po: stream := stream$primary_output()

Line 768:

Line 735:

<pre>97

a</pre>

=={{header|COBOL}}==

Tested with GnuCOBOL on an ASCII based GNU/Linux system.

Running this code on EBCDIC native hardware would display a control code and 000000093.

<syntaxhighlight lang=~~COBOL~~> identification division.

<syntaxhighlight lang="cobol"> identification division.

program-id. character-codes.

remarks. COBOL is an ordinal language, first is 1.

Line 786:

Line 752:

)

000000043</pre>

=={{header|CoffeeScript}}==

CoffeeScript transcompiles to JavaScript, so it uses the JS standard library.

<syntaxhighlight lang=coffeescript>console.log 'a'.charCodeAt 0 # 97

<syntaxhighlight lang="coffeescript">console.log 'a'.charCodeAt 0 # 97

console.log String.fromCharCode 97 # a</syntaxhighlight>

=={{header|Common Lisp}}==

<syntaxhighlight lang=lisp>(princ (char-code #\a)) ; prints "97"

<syntaxhighlight lang="lisp">(princ (char-code #\a)) ; prints "97"

(princ (code-char 97)) ; prints "a"</syntaxhighlight>

=={{header|Component Pascal}}==

BlackBox Component Builder

<syntaxhighlight lang=oberon2>PROCEDURE CharCodes*;

<syntaxhighlight lang="oberon2">PROCEDURE CharCodes*;

VAR

c : CHAR;

Line 810:

Line 773:

<pre>A:> 65

Ω:> 937</pre>

=={{header|D}}==

<syntaxhighlight lang=d>void main() {

<syntaxhighlight lang="d">void main() {

import std.stdio, std.utf;

Line 826:

Line 788:

=={{header|Dc}}==

A dc program cannot look into strings. But it can convert numeric values into single char strings or print numeric codes directly:

=={{header|Delphi}}==

Example from Studio 2006.

<syntaxhighlight lang=delphi>program Project1;

<syntaxhighlight lang="delphi">program Project1;

{$APPTYPE CONSOLE}

Line 854:

Line 814:

Readln;

end.</syntaxhighlight>

=={{header|DWScript}}==

<syntaxhighlight lang="delphi">PrintLn(Ord('a'));

PrintLn(Chr(97));</syntaxhighlight>

=={{header|Dyalect}}==

<syntaxhighlight lang=dyalect>print('a'.Order())

<syntaxhighlight lang="dyalect">print('a'.Order())

print(Char(97))</syntaxhighlight>

=={{header|DWScript}}==

<syntaxhighlight lang=delphi>PrintLn(Ord('a'));

PrintLn(Chr(97));</syntaxhighlight>

=={{header|E}}==

<syntaxhighlight lang=e>? 'a'.asInteger()

<syntaxhighlight lang="e">? 'a'.asInteger()

# value: 97

? <import:java.lang.makeCharacter>.asChar(97)

# value: 'a'</syntaxhighlight>

=={{header|EasyLang}}==

<syntaxhighlight lang=text>print strcode "a"

<syntaxhighlight lang="text">print strcode "a"

print strchar 97</syntaxhighlight>

=={{header|Eiffel}}==

All characters are of the type CHARACTER_8 (ASCII encoding) or CHARACTER_32 (Unicode encoding). CHARACTER is a synonym for either of these two (depending on the compiler option). Characters can be assigned using character literals (a single character enclosed in single quotes) or code value notation (of the form '%/value/' where value is an integer literal of any of the recognized forms).

class

APPLICATION

Line 908:

Line 863:

Limitations: There is no "put_character_32" feature for standard io (FILE class), so there appears to be no way to print Unicode characters.

=={{header|Elena}}==

ELENA 4.x :

<syntaxhighlight lang=elena>import extensions;

<syntaxhighlight lang="elena">import extensions;

public program()

Line 925:

Line 879:

97

</pre>

=={{header|Elixir}}==

A String in Elixir is a UTF-8 encoded binary.

<syntaxhighlight lang=elixir>iex(1)> code = ?a

<syntaxhighlight lang="elixir">iex(1)> code = ?a

97

iex(2)> to_string([code])

"a"</syntaxhighlight>

=={{header|Emacs Lisp}}==

<syntaxhighlight lang=~~Lisp~~>(string-to-char "a") ;=> 97

<syntaxhighlight lang="lisp">(string-to-char "a") ;=> 97

(format "%c" 97) ;=> "a"</syntaxhighlight>

=={{header|Erlang}}==

In Erlang, lists and strings are the same, only the representation changes. Thus:

<syntaxhighlight lang=erlang>1> F = fun([X]) -> X end.

<syntaxhighlight lang="erlang">1> F = fun([X]) -> X end.

#Fun<erl_eval.6.13229925>

2> F("a").

97</syntaxhighlight>

If entered manually, one can also get ASCII codes by prefixing characters with <tt>$</tt>:

<syntaxhighlight lang=erlang>3> $a.

<syntaxhighlight lang="erlang">3> $a.

97</syntaxhighlight>

Unicode is fully supported since release R13A only.

=={{header|Euphoria}}==

<syntaxhighlight lang=~~Euphoria~~>printf(1,"%d\n", 'a') -- prints "97"

<syntaxhighlight lang="euphoria">printf(1,"%d\n", 'a') -- prints "97"

printf(1,"%s\n", 97) -- prints "a"</syntaxhighlight>

=={{header|F Sharp|F#}}==

<syntaxhighlight lang=fsharp>let c = 'A'

<syntaxhighlight lang="fsharp">let c = 'A'

let n = 65

printfn "%d" (int c)

Line 959:

Line 908:

{{Out}}<pre>65

A</pre>

=={{header|Factor}}==

<syntaxhighlight lang=factor>CHAR: katakana-letter-a .

<syntaxhighlight lang="factor">CHAR: katakana-letter-a .

"ア" first .

12450 1string print</syntaxhighlight>

=={{header|FALSE}}==

<syntaxhighlight lang=false>'A."

<syntaxhighlight lang="false">'A."

"65,</syntaxhighlight>

=={{header|Fantom}}==

A character is represented in single quotes: the 'toInt' method returns the code for the character. The 'toChar' method converts an integer into its respective character.

<syntaxhighlight lang=fantom>fansh> 97.toChar

<syntaxhighlight lang="fantom">fansh> 97.toChar

a

fansh> 'a'.toInt

97</syntaxhighlight>

=={{header|Forth}}==

As with C, characters are just integers on the stack which are treated as ASCII.

<syntaxhighlight lang=forth>char a

<syntaxhighlight lang="forth">char a

dup . \ 97

emit \ a</syntaxhighlight>

=={{header|Fortran}}==

Functions ACHAR and IACHAR specifically work with the ASCII character set, while the results of CHAR and ICHAR will depend on the default character set being used.

<syntaxhighlight lang=fortran>WRITE(*,*) ACHAR(97), IACHAR("a")

<syntaxhighlight lang="fortran">WRITE(*,*) ACHAR(97), IACHAR("a")

WRITE(*,*) CHAR(97), ICHAR("a")</syntaxhighlight>

=={{header|Free Pascal}}==

''See [[#Pascal|Pascal]]''

=={{header|FreeBASIC}}==

' FreeBASIC v1.05.0 win64

Print "a - > "; Asc("a")

Line 1,007:

Line 949:

98 -> b

</pre>

=={{header|Frink}}==

The function <code>char[x]</code> in Frink returns the numerical Unicode codepoints for a string or character, or returns the Unicode string for an integer value or array of integer values. The <code>chars[x]</code> returns an array even if the string is a single character. These functions also correctly handle upper-plane Unicode characters as a single codepoint.

<syntaxhighlight lang=frink>println[char["a"]] // prints 97

<syntaxhighlight lang="frink">println[char["a"]] // prints 97

println[chars["a"]] // prints [97] (an array)

println[char[97]] // prints a

println[char["Frink rules!"]] // prints [70, 114, 105, 110, 107, 32, 114, 117, 108, 101, 115, 33]

println[[70, 114, 105, 110, 107, 32, 114, 117, 108, 101, 115, 33]] // prints "Frink rules!"</syntaxhighlight>

=={{header|Gambas}}==

<syntaxhighlight lang=gambas>Public Sub Form_Open()

<syntaxhighlight lang="gambas">Public Sub Form_Open()

Dim sChar As String

Line 1,032:

Line 972:

ASCII code 35 represents #

</pre>

=={{header|GAP}}==

<syntaxhighlight lang=gap># Code must be in 0 .. 255.

<syntaxhighlight lang="gap"># Code must be in 0 .. 255.

CharInt(65);

# 'A'

IntChar('Z');

# 90</syntaxhighlight>

=={{header|Go}}==

In Go, a character literal ''is'' simply an integer constant of the character code:

<syntaxhighlight lang=go>fmt.Println('a') // prints "97"

<syntaxhighlight lang="go">fmt.Println('a') // prints "97"

fmt.Println('π') // prints "960"</syntaxhighlight>

<syntaxhighlight lang=go>package main

<syntaxhighlight lang="go">package main

import (

Line 1,059:

Line 997:

The variable and constant types most commonly used for character data are <code>byte</code>, <code>rune</code>, and <code>string</code>.

This example program shows character codes (as literals) stored in typed variables, and printed out with default formatting. Note that since byte and rune are integer types, the default formatting is a printable base 10 number. String is not numeric, and a little extra work must be done to print the character codes.

<syntaxhighlight lang=go>package main

<syntaxhighlight lang="go">package main

import "fmt"

Line 1,088:

Line 1,026:

</pre>

For the second part of the task, printing the character of a given code, the <code>%c</code> verb of <code>fmt.Printf</code> will do this directly from integer values, emitting the UTF-8 encoding of the code, (which will typically print the character depending on your hardware and operating system configuration).

<syntaxhighlight lang=go>b := byte(97)

<syntaxhighlight lang="go">b := byte(97)

r := rune(960)

fmt.Printf("%c %c\n%c %c\n", 97, 960, b, r)</syntaxhighlight>

Line 1,099:

Line 1,037:

Examples showing strings constructed from integer constants and then printed:

<syntaxhighlight lang=go>fmt.Println(string(97)) // prints "a"

<syntaxhighlight lang="go">fmt.Println(string(97)) // prints "a"

fmt.Println(string(960)) // prints "π"

fmt.Println(string([]rune{97, 960})) // prints "aπ"</syntaxhighlight>

=={{header|Golfscript}}==

To convert a number to a string, we use the array to string coercion.

To convert a string to a number, we have a many options, of which the simplest and shortest are:

<syntaxhighlight lang=golfscript>'a')\;p

<syntaxhighlight lang="golfscript">'a')\;p

'a'(\;p

'a'0=p

'a'{}/p</syntaxhighlight>

=={{header|Groovy}}==

Groovy does not have a character literal at all, so one-character strings have to be ''coerced'' to '''char'''. Groovy '''printf''' (like Java, but unlike C) is ''not type-agnostic'', so the cast or coercion from '''char''' to '''int''' is also required. The reverse direction is considerably simpler.

<syntaxhighlight lang=groovy>printf ("%d\n", ('a' as char) as int)

<syntaxhighlight lang="groovy">printf ("%d\n", ('a' as char) as int)

printf ("%c\n", 97)</syntaxhighlight>

<pre>97

a</pre>

=={{header|Haskell}}==

<syntaxhighlight lang=haskell>import Data.Char

<syntaxhighlight lang="haskell">import Data.Char

main = do

Line 1,128:

Line 1,063:

print (ord 'π') -- prints "960"

print (chr 960) -- prints "'\960'"</syntaxhighlight>

=={{header|HicEst}}==

<syntaxhighlight lang=hicest>WRITE(Messagebox) ICHAR('a'), CHAR(97)</syntaxhighlight>

<syntaxhighlight lang="hicest">WRITE(Messagebox) ICHAR('a'), CHAR(97)</syntaxhighlight>

=={{header|HolyC}}==

<syntaxhighlight lang=holyc>Print("%d\n", 'a'); /* prints "97" */

<syntaxhighlight lang="holyc">Print("%d\n", 'a'); /* prints "97" */

Print("%c\n", 97); /* prints "a" */</syntaxhighlight>

=={{header|Hoon}}==

<syntaxhighlight lang=hoon>|%

<syntaxhighlight lang="hoon">|%

++ enc

|= char=@t `@ud`char

Line 1,143:

Line 1,075:

|= code=@ud `@t`code

--</syntaxhighlight>

=={{header|i}}==

<syntaxhighlight lang=i>software {

<syntaxhighlight lang="i">software {

print(number('a'))

print(text([97]))

}</syntaxhighlight>

=={{header|Icon}} and {{header|Unicon}}==

<syntaxhighlight lang=~~Icon~~>procedure main(arglist)

<syntaxhighlight lang="icon">procedure main(arglist)

if *arglist > 0 then L := arglist else L := [97, "a"]

Line 1,160:

Line 1,090:

{{Out}}<pre>97 ==> a

a ==> 97</pre>

=={{header|Io}}==

Here character is a sequence (string) of length one.

<syntaxhighlight lang=Io>"a" at(0) println // --> 97

<syntaxhighlight lang="io">"a" at(0) println // --> 97

97 asCharacter println // --> a

"π" at(0) println // --> 960

960 asCharacter println // --> π</syntaxhighlight>

=={{header|J}}==

<syntaxhighlight lang=j> 4 u: 97 98 99 9786

<syntaxhighlight lang="j"> 4 u: 97 98 99 9786

abc☺

Line 1,178:

Line 1,106:

<code>7 u:</code> converts from utf-8, <code>3 u:</code> by itself would give us:

<syntaxhighlight lang=j> 3 u: 'abc☺'

<syntaxhighlight lang="j"> 3 u: 'abc☺'

97 98 99 226 152 186</syntaxhighlight>

Also, if we limit ourselves to ascii, we have other ways of accomplishing the same thing. <code>a.</code> is a list of the 8 bit character codes and we can index from it, or search it (though that's mostly a notational convenience, since the underlying type already gives us all we need to know).

<syntaxhighlight lang=j> 97 98 99{a.

<syntaxhighlight lang="j"> 97 98 99{a.

abc

a.i.'abc'

97 98 99</syntaxhighlight>

=={{header|Java}}==

<tt>char</tt> is already an integer type in Java, and it gets automatically promoted to <tt>int</tt>. So you can use a character where you would otherwise use an integer. Conversely, you can use an integer where you would normally use a character, except you may need to cast it, as <tt>char</tt> is smaller.

In this case, the <tt>println</tt> method is overloaded to handle integer (outputs the decimal representation) and character (outputs just the character) types differently, so we need to cast it in both cases.

<syntaxhighlight lang=java>public class Foo {

<syntaxhighlight lang="java">public class Foo {

public static void main(String[] args) {

System.out.println((int)'a'); // prints "97"

Line 1,199:

Line 1,126:

}</syntaxhighlight>

Java characters support Unicode:

<syntaxhighlight lang=java>public class Bar {

<syntaxhighlight lang="java">public class Bar {

public static void main(String[] args) {

System.out.println((int)'π'); // prints "960"

Line 1,205:

Line 1,132:

}

}</syntaxhighlight>

=={{header|JavaScript}}==

Here character is just a string of length 1

<syntaxhighlight lang=javascript>console.log('a'.charCodeAt(0)); // prints "97"

<syntaxhighlight lang="javascript">console.log('a'.charCodeAt(0)); // prints "97"

console.log(String.fromCharCode(97)); // prints "a"</syntaxhighlight>

Line 1,214:

Line 1,140:

in addition to the usual 2-byte unicode characters.

<syntaxhighlight lang=~~JavaScript~~>['字'.codePointAt(0), '🐘'.codePointAt(0)]</syntaxhighlight>

<syntaxhighlight lang="javascript">['字'.codePointAt(0), '🐘'.codePointAt(0)]</syntaxhighlight>

and

<syntaxhighlight lang=~~JavaScript~~>[23383, 128024].map(function (x) {

<syntaxhighlight lang="javascript">[23383, 128024].map(function (x) {

return String.fromCodePoint(x);

})</syntaxhighlight>

Line 1,228:

Line 1,154:

=={{header|Joy}}==

<syntaxhighlight lang=joy>'a ord.

<syntaxhighlight lang="joy">'a ord.

97 chr.</syntaxhighlight>

=={{header|jq}}==

jq data strings are JSON strings, which can be "explode"d into an array of integers, each representing a Unicode codepoint. The inverse of the <tt>explode</tt> filter is <tt>implode</tt>. <tt>explode</tt> can of course be used for single-character strings, and so for example:

<syntaxhighlight lang=jq>"a" | explode # => [ 97 ]

<syntaxhighlight lang="jq">"a" | explode # => [ 97 ]

[97] | implode # => "a"</syntaxhighlight>

Here is a filter which can be used to convert an integer to the corresponding

character:<syntaxhighlight lang=jq>def chr: [.] | implode;

character:<syntaxhighlight lang="jq">def chr: [.] | implode;

</syntaxhighlight>

Example:

1024 | chr # => "Ѐ"

=={{header|Julia}}==

Julia character constants (of type <code>Char</code>) are treated as an integer type representing the Unicode codepoint of the character, and can easily be converted to and from other integer types.

<syntaxhighlight lang=julia>println(Int('a'))

<syntaxhighlight lang="julia">println(Int('a'))

println(Char(97))</syntaxhighlight>

{{out}}<pre>97

a</pre>

=={{header|K}}==

<syntaxhighlight lang=K> _ic "abcABC"

<syntaxhighlight lang="k"> _ic "abcABC"

97 98 99 65 66 67

_ci 97 98 99 65 66 67

"abcABC"</syntaxhighlight>

=={{header|Kotlin}}==

<syntaxhighlight lang=scala>fun main(args: Array<String>) {

<syntaxhighlight lang="scala">fun main(args: Array<String>) {

var c = 'a'

var i = c.toInt()

Line 1,275:

Line 1,196:

99 <-> c

</pre>

=={{header|LabVIEW}}==

{{VI snippet}}

[[File:LabVIEW_Character_codes.png]]

=={{header|Lang5}}==

<syntaxhighlight lang=lang5>: CHAR "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[" comb

<syntaxhighlight lang="lang5">: CHAR "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[" comb

'\\ comb -1 remove append "]^_`abcdefghijklmnopqrstuvwxyz{|}~" comb append ;

: CODE 95 iota 33 + ; : comb "" split ;

Line 1,290:

Line 1,209:

'a ord . # 97

97 chr . # a</syntaxhighlight>

=={{header|langur}}==

Langur has code point literals (enclosed in straight single quotes), which may use escape codes. They are integers.

Line 1,296:

Line 1,214:

The s2cp() and cp2s() functions convert between code point integers and strings. Also, string indexing is by code point.

<syntaxhighlight lang=langur>val .a1 = 'a'

<syntaxhighlight lang="langur">val .a1 = 'a'

val .a2 = 97

val .a3 = "a"[1]

Line 1,315:

Line 1,233:

letters: a, a, a, a, aaaa

</pre>

=={{header|Lasso}}==

<syntaxhighlight lang=~~Lasso~~>'a'->integer

<syntaxhighlight lang="lasso">'a'->integer

'A'->integer

97->bytes

Line 1,325:

Line 1,242:

a

A</pre>

=={{header|LFE}}==

In LFE/Erlang, lists and strings are the same, only the representation changes. For example:

<syntaxhighlight lang=lisp>> (list 68 111 110 39 116 32 80 97 110 105 99 46)

<syntaxhighlight lang="lisp">> (list 68 111 110 39 116 32 80 97 110 105 99 46)

"Don't Panic."</syntaxhighlight>

As for this exercise, here's how you could print out the ASCII code for a letter, and a letter from the ASCII code:

<syntaxhighlight lang=lisp>> (: io format '"~w~n" '"a")

<syntaxhighlight lang="lisp">> (: io format '"~w~n" '"a")

97

ok

Line 1,338:

Line 1,254:

"a"

ok</syntaxhighlight>

=={{header|Liberty BASIC}}==

<syntaxhighlight lang=lb>charCode = 97

<syntaxhighlight lang="lb">charCode = 97

char$ = "a"

print chr$(charCode) 'prints a

print asc(char$) 'prints 97</syntaxhighlight>

=={{header|LIL}}==

LIL does not handle NUL bytes in character strings, char 0 returns an empty string.

<syntaxhighlight lang=tcl>print [char 97]

<syntaxhighlight lang="tcl">print [char 97]

print [codeat "a" 0]</syntaxhighlight>

Line 1,353:

Line 1,267:

<pre>a

97</pre>

=={{header|Lingo}}==

<syntaxhighlight lang=lingo>-- returns Unicode code point (=ASCII code for ASCII characters) for character

<syntaxhighlight lang="lingo">-- returns Unicode code point (=ASCII code for ASCII characters) for character

put chartonum("a")

-- 97

Line 1,362:

Line 1,275:

put numtochar(934)

-- Φ</syntaxhighlight>

=={{header|Little}}==

<syntaxhighlight lang=C>puts("Unicode value of ñ is ${scan("ñ", "%c")}");

<syntaxhighlight lang="c">puts("Unicode value of ñ is ${scan("ñ", "%c")}");

printf("The code 241 in Unicode is the letter: %c.\n", 241);

</syntaxhighlight>

=={{header|LiveCode}}==

<syntaxhighlight lang=~~LiveCode~~>Since 7.0.x works with unicode

<syntaxhighlight lang="livecode">Since 7.0.x works with unicode

put charToNum("") && numToChar(240)</syntaxhighlight>

=={{header|Logo}}==

Logo characters are words of length 1.

<syntaxhighlight lang=logo>print ascii "a ; 97

<syntaxhighlight lang="logo">print ascii "a ; 97

print char 97 ; a</syntaxhighlight>

=={{header|Logtalk}}==

<syntaxhighlight lang=logtalk>|?- char_code(Char, 97), write(Char).

<syntaxhighlight lang="logtalk">|?- char_code(Char, 97), write(Char).

a

Char = a

yes</syntaxhighlight>

<syntaxhighlight lang=logtalk>|?- char_code(a, Code), write(Code).

<syntaxhighlight lang="logtalk">|?- char_code(a, Code), write(Code).

97

Code = 97

yes</syntaxhighlight>

=={{header|Lua}}==

<syntaxhighlight lang=lua>print(string.byte("a")) -- prints "97"

<syntaxhighlight lang="lua">print(string.byte("a")) -- prints "97"

print(string.char(97)) -- prints "a"</syntaxhighlight>

=={{header|M2000 Interpreter}}==

\\ ANSI

Print Asc("a")

Line 1,416:

Line 1,323:

\\ 97 98 99 100

</syntaxhighlight>

=={{header|Maple}}==

There are two ways to do this in Maple. First, there are procedures in StringTools for this purpose.

<syntaxhighlight lang=~~Maple~~>> use StringTools in Ord( "A" ); Char( 65 ) end;

<syntaxhighlight lang="maple">> use StringTools in Ord( "A" ); Char( 65 ) end;

65

Line 1,425:

Line 1,331:

</syntaxhighlight>

Second, the procedure convert handles conversions to and from byte values.

<syntaxhighlight lang=~~Maple~~>> convert( "A", bytes );

<syntaxhighlight lang="maple">> convert( "A", bytes );

[65]

Line 1,431:

Line 1,337:

"A"

</syntaxhighlight>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Use the FromCharacterCode and ToCharacterCode functions:

<syntaxhighlight lang=~~Mathematica~~>ToCharacterCode["abcd"]

<syntaxhighlight lang="mathematica">ToCharacterCode["abcd"]

FromCharacterCode[{97}]</syntaxhighlight>

{{Out}}<pre>{97, 98, 99, 100}

"a"</pre>

=={{header|MATLAB}} / {{header|Octave}}==

There are two built-in function that perform these tasks.

To convert from a number to a character use:

<syntaxhighlight lang=~~MATLAB~~>character = char(asciiNumber)</syntaxhighlight>

<syntaxhighlight lang="matlab">character = char(asciiNumber)</syntaxhighlight>

To convert from a character to its corresponding ascii character use:

<syntaxhighlight lang=~~MATLAB~~>asciiNumber = double(character)</syntaxhighlight>

<syntaxhighlight lang="matlab">asciiNumber = double(character)</syntaxhighlight>

or if you need this number as an integer not a double use:

<syntaxhighlight lang=~~MATLAB~~>asciiNumber = uint16(character)

<syntaxhighlight lang="matlab">asciiNumber = uint16(character)

asciiNumber = uint32(character)

asciiNumber = uint64(character)</syntaxhighlight>

Sample Usage:

<syntaxhighlight lang=~~MATLAB~~>>> char(87)

<syntaxhighlight lang="matlab">>> char(87)

ans =

Line 1,471:

Line 1,375:

87</syntaxhighlight>

=={{header|Maxima}}==

<syntaxhighlight lang=maxima>ascii(65);

<syntaxhighlight lang="maxima">ascii(65);

"A"

cint("A");

65</syntaxhighlight>

=={{header|Metafont}}==

Metafont handles only ''ASCII'' (even though codes beyond 127 can be given and used as real ASCII codes)

<syntaxhighlight lang=metafont>message "enter a letter: ";

<syntaxhighlight lang="metafont">message "enter a letter: ";

string a;

a := readstring;

Line 1,495:

Line 1,397:

message char hex"c3" & char hex"a8"; % since C3 A8 is the UTF-8 encoding for "è"

end</syntaxhighlight>

=={{header|Microsoft Small Basic}}==

<syntaxhighlight lang=vb>TextWindow.WriteLine("The ascii code for 'A' is: " + Text.GetCharacterCode("A") + ".")

<syntaxhighlight lang="vb">TextWindow.WriteLine("The ascii code for 'A' is: " + Text.GetCharacterCode("A") + ".")

TextWindow.WriteLine("The character for '65' is: " + Text.GetCharacter(65) + ".")</syntaxhighlight>

<syntaxhighlight lang=basic>The ascii code for 'A' is: 65.

<syntaxhighlight lang="basic">The ascii code for 'A' is: 65.

The character for '65' is: A.

Press any key to continue...</syntaxhighlight>

=={{header|Modula-2}}==

<syntaxhighlight lang=modula2>MODULE asc;

<syntaxhighlight lang="modula2">MODULE asc;

IMPORT InOut;

Line 1,525:

Line 1,425:

END asc.</syntaxhighlight>

<syntaxhighlight lang=~~Modula~~-2>jan@Beryllium:~/modula/rosetta$ ./asc

<syntaxhighlight lang="modula-2">jan@Beryllium:~/modula/rosetta$ ./asc

a 97 1</syntaxhighlight>

=={{header|Modula-3}}==

The built in functions <code>ORD</code> and <code>VAL</code> work on characters, among other things.

<syntaxhighlight lang=modula3>ORD('a') (* Returns 97 *)

<syntaxhighlight lang="modula3">ORD('a') (* Returns 97 *)

VAL(97, CHAR); (* Returns 'a' *)</syntaxhighlight>

=={{header|MUMPS}}==

<syntaxhighlight lang=~~MUMPS~~>WRITE $ASCII("M")

<syntaxhighlight lang="mumps">WRITE $ASCII("M")

WRITE $CHAR(77)</syntaxhighlight>

=={{header|Nanoquery}}==

<syntaxhighlight lang=~~Nanoquery~~>println ord("a")

<syntaxhighlight lang="nanoquery">println ord("a")

println chr(97)

Line 1,548:

Line 1,445:

960

π</pre>

=={{header|Neko}}==

Neko treats strings as an array of bytes

<syntaxhighlight lang=neko>// An 'a' and a 'b'

<syntaxhighlight lang="neko">// An 'a' and a 'b'

var s = "a";

var c = 98;

Line 1,568:

Line 1,464:

Neko also has standard primitives for handling the byte array as UTF-8

<syntaxhighlight lang=neko>// While Neko also includes some UTF-8 operations,

<syntaxhighlight lang="neko">// While Neko also includes some UTF-8 operations,

// native strings are just arrays of bytes

var us = "¥·£·€·$·¢·₡·₢·₣·₤·₥·₦·₧·₨·₩·₪·₫·₭·₮·₯·₹";

Line 1,594:

Line 1,490:

<pre>UFT-8 code for '€': 8364

UTF-8 code 8356: ₤</pre>

=={{header|NESL}}==

In NESL, character literals are prefixed with a backtick. The functions <tt>char_code</tt> and <tt>code_char</tt> convert between characters and integer character codes.

<syntaxhighlight lang=nesl>char_code(`a);

<syntaxhighlight lang="nesl">char_code(`a);

it = 97 : int</syntaxhighlight>

<syntaxhighlight lang=nesl>code_char(97);

<syntaxhighlight lang="nesl">code_char(97);

it = `a : char</syntaxhighlight>

=={{header|NetRexx}}==

NetRexx provides built-in functions to convert between character and decimal/hexadecimal.

<syntaxhighlight lang=~~NetRexx~~>/* NetRexx */

<syntaxhighlight lang="netrexx">/* NetRexx */

options replace format comments java crossref symbols nobinary

Line 1,666:

Line 1,560:

32| '₴' 8372 20B4 '₴' '₴'

33| '₵' 8373 20B5 '₵' '₵'</pre>

=={{header|Nim}}==

<syntaxhighlight lang=nim>echo ord('a') # echoes 97

<syntaxhighlight lang="nim">echo ord('a') # echoes 97

echo chr(97) # echoes a

Line 1,675:

Line 1,568:

echo int("π".runeAt(0)) # echoes 960

echo Rune(960) # echoes π</syntaxhighlight>

=={{header|NS-HUBASIC}}==

NS-HUBASIC uses a non-ASCII character set that doesn't include letters in lowercase.

<syntaxhighlight lang=NS-~~HUBASIC~~>10 PRINT CODE "A"

<syntaxhighlight lang="ns-hubasic">10 PRINT CODE "A"

20 PRINT CHR$(38)</syntaxhighlight>

<pre> 0A

&</pre>

=={{header|Oberon-2}}==

<syntaxhighlight lang=oberon2>MODULE Ascii;

<syntaxhighlight lang="oberon2">MODULE Ascii;

IMPORT Out;

VAR

Line 1,699:

Line 1,590:

97

a</pre>

=={{header|Objeck}}==

<syntaxhighlight lang=objeck>'a'->As(Int)->PrintLine();

<syntaxhighlight lang="objeck">'a'->As(Int)->PrintLine();

97->As(Char)->PrintLine();</syntaxhighlight>

=={{header|Object Pascal}}==

''See [[#Pascal|Pascal]]''

=={{header|OCaml}}==

<syntaxhighlight lang=ocaml>Printf.printf "%d\n" (int_of_char 'a'); (* prints "97" *)

<syntaxhighlight lang="ocaml">Printf.printf "%d\n" (int_of_char 'a'); (* prints "97" *)

Printf.printf "%c\n" (char_of_int 97); (* prints "a" *)</syntaxhighlight>

The following are aliases for the above functions:

<syntaxhighlight lang=ocaml># Char.code ;;

<syntaxhighlight lang="ocaml"># Char.code ;;

- : char -> int = <fun>

# Char.chr;;

- : int -> char = <fun></syntaxhighlight>

=={{header|Oforth}}==

Oforth has not type or class for characters. A character is an integer which value is its unicode code.

<syntaxhighlight lang=~~Oforth~~>'a' println</syntaxhighlight>

<syntaxhighlight lang="oforth">'a' println</syntaxhighlight>

Line 1,727:

Line 1,614:

97

</pre>

=={{header|OpenEdge/Progress}}==

<syntaxhighlight lang=~~Progress~~ (~~Openedge~~ ~~ABL~~)>MESSAGE

<syntaxhighlight lang="progress (openedge abl)">MESSAGE

CHR(97) SKIP

ASC("a")

VIEW-AS ALERT-BOX.</syntaxhighlight>

=={{header|Oz}}==

Characters in Oz are the same as integers in the range 0-255 (ISO 8859-1 encoding). To print a number as a character, we need to use it as a string (i.e. a list of integers from 0 to 255):

<syntaxhighlight lang=oz>{System.show &a} %% prints "97"

<syntaxhighlight lang="oz">{System.show &a} %% prints "97"

{System.showInfo [97]} %% prints "a"</syntaxhighlight>

=={{header|PARI/GP}}==

<syntaxhighlight lang=parigp>print(Vecsmall("a")[1]);

<syntaxhighlight lang="parigp">print(Vecsmall("a")[1]);

print(Strchr([72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]))</syntaxhighlight>

=={{header|Pascal}}==

<syntaxhighlight lang=pascal>writeln(ord('a'));

<syntaxhighlight lang="pascal">writeln(ord('a'));

writeln(chr(97));</syntaxhighlight>

=={{header|Perl}}==

===Narrow===

The code is straightforward when characters are all narrow (single byte).

<syntaxhighlight lang=perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use utf8;

Line 1,800:

Line 1,682:

===Wide===

Have to work a little harder to handle wide (multi-byte) characters.

<syntaxhighlight lang=perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use feature 'say';

Line 1,843:

Line 1,725:

UTF-8: f0 9f 91 a8 e2 80 8d f0 9f 91 a9 e2 80 8d f0 9f 91 a7 e2 80 8d f0 9f 91 a6

Round trip: 👨‍👩‍👧‍👦</pre>

=={{header|Phix}}==

Characters and their ascii codes are one and the same. (See also printf, %d / %s / %c.)

?'A'

puts(1,65)

Line 1,858:

Line 1,739:

A

</pre>

=={{header|Phixmonti}}==

<syntaxhighlight lang=~~Phixmonti~~>'a' print nl

<syntaxhighlight lang="phixmonti">'a' print nl

97 tochar print</syntaxhighlight>

=={{header|PHP}}==

Here character is just a string of length 1

<syntaxhighlight lang=php>echo ord('a'), "\n"; // prints "97"

<syntaxhighlight lang="php">echo ord('a'), "\n"; // prints "97"

echo chr(97), "\n"; // prints "a"</syntaxhighlight>

=={{header|Picat}}==

println(chr(97)),

println(ord('a')),

Line 1,878:

Line 1,756:

97

97</pre>

=={{header|PicoLisp}}==

<syntaxhighlight lang=~~PicoLisp~~>: (char "a")

<syntaxhighlight lang="picolisp">: (char "a")

-> 97

: (char "字")

Line 1,890:

Line 1,767:

: (mapcar char @)

-> (25991 23383)</syntaxhighlight>

=={{header|PL/I}}==

<syntaxhighlight lang=PL/I>declare 1 u union,

<syntaxhighlight lang="pl/i">declare 1 u union,

2 c character (1),

2 i fixed binary (8) unsigned;

c = 'a'; put skip list (i); /* prints 97 */

i = 97; put skip list (c); /* prints 'a' */</syntaxhighlight>

=={{header|PowerShell}}==

Powershell does allow for character literals with [convert]

<syntaxhighlight lang=powershell>$char = [convert]::toChar(0x2f) #=> /</syntaxhighlight>

<syntaxhighlight lang="powershell">$char = [convert]::toChar(0x2f) #=> /</syntaxhighlight>

PowerShell does not allow for character literals directly, so to get a character one first needs to convert a single-character string to a char:

Then a simple cast to int yields the character code:

<syntaxhighlight lang=powershell>$charcode = [int] $char # => 97</syntaxhighlight>

<syntaxhighlight lang="powershell">$charcode = [int] $char # => 97</syntaxhighlight>

This also works with Unicode:

For converting an integral character code into the actual character, a cast to char suffices:

<syntaxhighlight lang=powershell>[char] 97 # a

<syntaxhighlight lang="powershell">[char] 97 # a

[char] 9786 # ☺</syntaxhighlight>

=={{header|Prolog}}==

SWI-Prolog has predefined predicate char_code/2.

Line 1,919:

Line 1,793:

?- char_code(X, 97).

X = a.</pre>

=={{header|PureBasic}}==

PureBasic allows compiling code so that it will use either Ascii or a Unicode (UCS-2) encoding for representing its string content.

Line 1,925:

Line 1,798:

A one-character string is used here to hold the character and a numerical character type is used to hold the character code.

The character type is either one or two bytes in size, depending on whether compiling for Ascii or Unicode respectively.

<syntaxhighlight lang=~~PureBasic~~>If OpenConsole()

<syntaxhighlight lang="purebasic">If OpenConsole()

;Results are the same when compiled for Ascii or Unicode

charCode.c = 97

Line 1,938:

Line 1,811:

This version should be compiled with Unicode setting and the source code to be encoded using UTF-8.

<syntaxhighlight lang=~~PureBasic~~>If OpenConsole()

<syntaxhighlight lang="purebasic">If OpenConsole()

;UTF-8 encoding compiled for Unicode (UCS-2)

charCode.c = 960

Line 1,949:

Line 1,822:

CloseConsole()

EndIf</syntaxhighlight>

=={{header|Python}}==

Line 1,955:

Line 1,827:

8-bit characters:

<syntaxhighlight lang=python>print ord('a') # prints "97"

<syntaxhighlight lang="python">print ord('a') # prints "97"

print chr(97) # prints "a"</syntaxhighlight>

Unicode characters:

<syntaxhighlight lang=python>print ord(u'π') # prints "960"

<syntaxhighlight lang="python">print ord(u'π') # prints "960"

print unichr(960) # prints "π"</syntaxhighlight>

Here character is just a string of length 1

<syntaxhighlight lang=python>print(ord('a')) # prints "97" (will also work in 2.x)

<syntaxhighlight lang="python">print(ord('a')) # prints "97" (will also work in 2.x)

print(ord('π')) # prints "960"

print(chr(97)) # prints "a" (will also work in 2.x)

print(chr(960)) # prints "π"</syntaxhighlight>

=={{header|Quackery}}==

Line 1,986:

Line 1,857:

a

Stack empty.</pre>

=={{header|R}}==

<syntaxhighlight lang=R>ascii <- as.integer(charToRaw("hello world")); ascii

<syntaxhighlight lang="r">ascii <- as.integer(charToRaw("hello world")); ascii

text <- rawToChar(as.raw(ascii)); text</syntaxhighlight>

=={{header|Racket}}==

<syntaxhighlight lang=~~Racket~~>#lang racket

<syntaxhighlight lang="racket">#lang racket

(define (code ch)

Line 2,003:

Line 1,872:

(char 97)

(char 955)</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

Both Perl 5 and Raku have good Unicode support, though Raku attempts to make working with Unicode effortless. Note that even multi-byte emoji and characters outside the BMP are considered single characters. Also note: all of these routines are built into the base compiler. No need to load external libraries. See [[wp:Unicode_character_property#General_Category|Wikipedia: Unicode character properties]] for explanation of Unicode property.

<syntaxhighlight lang=raku line>for 'AΑА𪚥🇺🇸👨‍👩‍👧‍👦'.comb {

<syntaxhighlight lang="raku" line>for 'AΑА𪚥🇺🇸👨‍👩‍👧‍👦'.comb {

.put for

[ 'Character',

Line 2,116:

Line 1,984:

Round trip by name: 👨‍👩‍👧‍👦

Round trip by ordinal: 👨‍👩‍👧‍👦</pre>

=={{header|RapidQ}}==

Print Chr$(97)

Print Asc("a")

</syntaxhighlight>

=={{header|Red}}==

<syntaxhighlight lang=~~Red~~>Red []

<syntaxhighlight lang="red">Red []

print to-integer first "a" ;; -> 97

print to-integer #"a" ;; -> 97

Line 2,130:

Line 1,996:

print to-char 97 ;; -> a

</syntaxhighlight>

=={{header|Retro}}==

=={{header|REXX}}==

REXX supports handling of characters with built-in functions (BIFs), whether it be hexadecimal, binary (bits), or decimal code(s).

===ASCII===

<syntaxhighlight lang=rexx>/*REXX program displays a char's ASCII code/value (or EBCDIC if run on an EBCDIC system)*/

<syntaxhighlight lang="rexx">/*REXX program displays a char's ASCII code/value (or EBCDIC if run on an EBCDIC system)*/

yyy= 'c' /*assign a lowercase c to YYY. */

yyy= "c" /* (same as above) */

Line 2,178:

Line 2,042:

===EBCDIC===

<syntaxhighlight lang=rexx>/* REXX */

<syntaxhighlight lang="rexx">/* REXX */

yyy='c' /*assign a lowercase c to YYY */

yyy='83'x /*assign hexadecimal 83 to YYY */

Line 2,197:

Line 2,061:

129

10000001</pre>

=={{header|Ring}}==

see ascii("a") + nl

see char(97) + nl

</syntaxhighlight>

=={{header|Ruby}}==

In Ruby 1.9 characters are represented as length-1 strings; same as in Python. The previous "character literal" syntax <tt>?a</tt> is now the same as <tt>"a"</tt>. Subscripting a string also gives a length-1 string. There is now an "ord" method of strings to convert a character into its integer code.

<syntaxhighlight lang=ruby>> "a".ord

<syntaxhighlight lang="ruby">> "a".ord

=> 97

> 97.chr

=> "a"</syntaxhighlight>

=={{header|Run BASIC}}==

<syntaxhighlight lang=runbasic>print chr$(97) 'prints a

<syntaxhighlight lang="runbasic">print chr$(97) 'prints a

print asc("a") 'prints 97</syntaxhighlight>

=={{header|Rust}}==

<syntaxhighlight lang=rust>use std::char::from_u32;

<syntaxhighlight lang="rust">use std::char::from_u32;

fn main() {

Line 2,233:

Line 2,093:

960

π</pre>

=={{header|Sather}}==

<syntaxhighlight lang=sather>class MAIN is

<syntaxhighlight lang="sather">class MAIN is

main is

#OUT + 'a'.int + "\n"; -- or

Line 2,242:

Line 2,101:

end;

end;</syntaxhighlight>

=={{header|Scala}}==

Scala supports unicode characters, but each character is UTF-16, so there is not a 1-to-1 relationship for supplementary character sets.

===In a REPL session===

<syntaxhighlight lang=scala>scala> 'a' toInt

<syntaxhighlight lang="scala">scala> 'a' toInt

res2: Int = 97

Line 2,260:

Line 2,118:

===Full swing workout===

Taken the supplemental character sets in account.

<syntaxhighlight lang=scala>import java.lang.Character._; import scala.annotation.tailrec

<syntaxhighlight lang="scala">import java.lang.Character._; import scala.annotation.tailrec

object CharacterCode extends App {

Line 2,375:

Line 2,233:

65: 𠀀 "\uD840\uDC00" U+20000 (131072) NN HIGH SURROGATES D840

66: 𪚥 "\uD869\uDEA5" U+2A6A5 (173733) NN HIGH SURROGATES D869</pre>[http://illegalargumentexception.blogspot.nl/2009/05/java-rough-guide-to-character-encoding.html More background info: "Java: a rough guide to character encoding"]

=={{header|Scheme}}==

<syntaxhighlight lang=scheme>(display (char->integer #\a)) (newline) ; prints "97"

<syntaxhighlight lang="scheme">(display (char->integer #\a)) (newline) ; prints "97"

(display (integer->char 97)) (newline) ; prints "a"</syntaxhighlight>

=={{header|Seed7}}==

<syntaxhighlight lang=seed7>writeln(ord('a'));

<syntaxhighlight lang="seed7">writeln(ord('a'));

writeln(chr(97));</syntaxhighlight>

=={{header|SenseTalk}}==

<syntaxhighlight lang=sensetalk>put CharToNum("a")

<syntaxhighlight lang="sensetalk">put CharToNum("a")

put NumToChar(97)</syntaxhighlight>

=={{header|SequenceL}}==

SequenceL natively supports ASCII characters.

'''SequenceL Interpreter Session:'''

<syntaxhighlight lang=sequencel>cmd:>asciiToInt('a')

<syntaxhighlight lang="sequencel">cmd:>asciiToInt('a')

97

cmd:>intToAscii(97)

'a'</syntaxhighlight>

=={{header|Sidef}}==

<syntaxhighlight lang=ruby>say 'a'.ord; # => 97

<syntaxhighlight lang="ruby">say 'a'.ord; # => 97

say 97.chr; # => 'a'</syntaxhighlight>

=={{header|Slate}}==

<syntaxhighlight lang=slate>$a code.

<syntaxhighlight lang="slate">$a code.

97 as: String Character.</syntaxhighlight>

=={{header|Smalltalk}}==

<syntaxhighlight lang=smalltalk>($a asInteger) displayNl. "output 97"

<syntaxhighlight lang="smalltalk">($a asInteger) displayNl. "output 97"

(Character value: 97) displayNl. "output a"</syntaxhighlight>

Ansi Smalltalk defines <tt>codePoint</tt>

<syntaxhighlight lang=smalltalk>Transcript showCR:$a codePoint.

<syntaxhighlight lang="smalltalk">Transcript showCR:$a codePoint.

Transcript showCR:(Character codePoint:97).

Transcript showCR:(98 asCharacter).

Line 2,437:

Line 2,288:

120097

120098</pre>

=={{header|SmileBASIC}}==

<syntaxhighlight lang=smilebasic>PRINT CHR$(97) 'a

<syntaxhighlight lang="smilebasic">PRINT CHR$(97) 'a

PRINT ASC("a") '97</syntaxhighlight>

=={{header|SNOBOL4}}==

Snobol implementations may or may not have built-in char( ) and ord ( ) or asc( ).

These are based on examples in the Snobol4+ tutorial and work with the native (1-byte) charset.

<syntaxhighlight lang=~~SNOBOL4~~> define('chr(n)') :(chr_end)

<syntaxhighlight lang="snobol4"> define('chr(n)') :(chr_end)

chr &alphabet tab(n) len(1) . chr :s(return)f(freturn)

chr_end

Line 2,463:

Line 2,312:

A

65</pre>

=={{header|SPL}}==

In SPL all characters are used in UTF-16LE encoding.

<syntaxhighlight lang=spl>x = #.array("a")

<syntaxhighlight lang="spl">x = #.array("a")

#.output("a -> ",x[1]," ",x[2])

x = [98,0]

Line 2,475:

Line 2,323:

98 0 -> b

</pre>

=={{header|Standard ML}}==

<syntaxhighlight lang=sml>print (Int.toString (ord #"a") ^ "\n"); (* prints "97" *)

<syntaxhighlight lang="sml">print (Int.toString (ord #"a") ^ "\n"); (* prints "97" *)

print (Char.toString (chr 97) ^ "\n"); (* prints "a" *)</syntaxhighlight>

=={{header|Stata}}==

The Mata '''ascii''' function transforms a string into a numeric vector of UTF-8 bytes. For instance:

<syntaxhighlight lang=stata>: ascii("α")

<syntaxhighlight lang="stata">: ascii("α")

1 2

+-------------+

Line 2,493:

Line 2,339:

ASCII characters are mapped to single bytes:

<syntaxhighlight lang=stata>: ascii("We the People")

<syntaxhighlight lang="stata">: ascii("We the People")

1 2 3 4 5 6 7 8 9 10 11 12 13

+-------------------------------------------------------------------------------+

Line 2,501:

Line 2,347:

Conversely, the '''char''' function transforms a byte vector into a string:

<syntaxhighlight lang=stata>: char((73,32,115,116,97,110,100,32,104,101,114,101))

<syntaxhighlight lang="stata">: char((73,32,115,116,97,110,100,32,104,101,114,101))

I stand here</syntaxhighlight>

=={{header|Swift}}==

The type that represent a Unicode code point is <code>UnicodeScalar</code>.

You can initialize it with a string literal:

<syntaxhighlight lang=swift>let c1: UnicodeScalar = "a"

<syntaxhighlight lang="swift">let c1: UnicodeScalar = "a"

println(c1.value) // prints "97"

let c2: UnicodeScalar = "π"

println(c2.value) // prints "960"</syntaxhighlight>

Or, you can get it by iterating a string's unicode scalars view:

<syntaxhighlight lang=swift>let s1 = "a"

<syntaxhighlight lang="swift">let s1 = "a"

for c in s1.unicodeScalars {

println(c.value) // prints "97"

Line 2,522:

Line 2,367:

You can also initialize it from a <code>UInt32</code> integer:

<syntaxhighlight lang=swift>let i1: UInt32 = 97

<syntaxhighlight lang="swift">let i1: UInt32 = 97

println(UnicodeScalar(i1)) // prints "a"

let i2: UInt32 = 960

println(UnicodeScalar(i2)) // prints "π"</syntaxhighlight>

=={{header|Tailspin}}==

Tailspin works with Unicode codepoints

'abc' -> $::asCodePoints -> !OUT::write

'$#10;' -> !OUT::write

Line 2,539:

Line 2,383:

a

</pre>

=={{header|Tcl}}==

<syntaxhighlight lang=tcl># ASCII

<syntaxhighlight lang="tcl"># ASCII

puts [scan "a" %c] ;# ==> 97

puts [format %c 97] ;# ==> a

Line 2,547:

Line 2,390:

puts [scan "π" %c] ;# ==> 960

puts [format %c 960] ;# ==> π</syntaxhighlight>

=={{header|TI-83 BASIC}}==

TI-83 BASIC provides no built in way to do this, so in all String<-->List routines and anything else which requires character codes, a workaround using inString( and sub( is used.

In this example, the code of 'A' is displayed, and then the character matching a user-defined code is displayed.

<syntaxhighlight lang=ti83b>"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789→Str1

<syntaxhighlight lang="ti83b">"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789→Str1

Disp inString(Str1,"A

Input "CODE? ",A

Disp sub(Str1,A,1</syntaxhighlight>

=={{header|TI-89 BASIC}}==

The TI-89 uses an 8-bit charset/encoding which is similar to ISO-8859-1, but with more mathematical symbols and Greek letters.

Line 2,565:

Line 2,406:

The below program will display the character and code for any key pressed. Some keys do not correspond to characters and have codes greater than 255.

<syntaxhighlight lang=ti89b>Prgm

<syntaxhighlight lang="ti89b">Prgm

Local k, s

ClrIO

Line 2,586:

Line 2,427:

EndLoop

EndPrgm</syntaxhighlight>

=={{header|Trith}}==

Characters are Unicode code points, so the solution is the same for Unicode characters as it is for ASCII characters:

<syntaxhighlight lang=trith>"a" ord print

<syntaxhighlight lang="trith">"a" ord print

97 chr print</syntaxhighlight>

<syntaxhighlight lang=trith>"π" ord print

<syntaxhighlight lang="trith">"π" ord print

960 chr print</syntaxhighlight>

=={{header|TUSCRIPT}}==

<syntaxhighlight lang=tuscript>$$ MODE TUSCRIPT

<syntaxhighlight lang="tuscript">$$ MODE TUSCRIPT

SET character ="a", code=DECODE (character,byte)

PRINT character,"=",code</syntaxhighlight>

{{Out}}<pre>a=97</pre>

=={{header|uBasic/4tH}}==

uBasic/4tH is an integer BASIC, just like Tiny BASIC. However, the function ORD() is supported, just as CHR(). The latter is only allowed within a PRINT statement.

<syntaxhighlight lang=text>z = ORD("a") : PRINT CHR(z) ' Prints "a"</syntaxhighlight>

<syntaxhighlight lang="text">z = ORD("a") : PRINT CHR(z) ' Prints "a"</syntaxhighlight>

=={{header|UNIX Shell}}==

Aamrun$ printf "%d\n" \'a

97

Line 2,612:

Line 2,449:

Aamrun$

</syntaxhighlight>

=={{header|Ursa}}==

<syntaxhighlight lang=ursa># outputs the character value for 'a'

<syntaxhighlight lang="ursa"># outputs the character value for 'a'

out (ord "a") endl console

# outputs the character 'a' given its value

out (chr 97) endl console</syntaxhighlight>

=={{header|Ursala}}==

Character code functions are not built in but easily defined as reifications of

the character table.

<syntaxhighlight lang=~~Ursala~~>#import std

<syntaxhighlight lang="ursala">#import std

#import nat

Line 2,632:

Line 2,467:

test = (chr97,asc`a)</syntaxhighlight>

{{Out}}<pre>(`a,97)</pre>

=={{header|VBA}}==

<syntaxhighlight lang=vba>Debug.Print Chr(97) 'Prints a

<syntaxhighlight lang="vba">Debug.Print Chr(97) 'Prints a

Debug.Print [Code("a")] ' Prints 97</syntaxhighlight>

=={{header|VBScript}}==

'prints a

WScript.StdOut.WriteLine Chr(97)

Line 2,645:

Line 2,478:

WScript.StdOut.WriteLine Asc("a")

</syntaxhighlight>

=={{header|Vim Script}}==

The behavior of the two functions depends on the value of the option <code>encoding</code>.

<syntaxhighlight lang=vim>"encoding is set to utf-8

<syntaxhighlight lang="vim">"encoding is set to utf-8

echo char2nr("a")

"Prints 97

Line 2,654:

Line 2,486:

echo nr2char(97)

"Prints a</syntaxhighlight>

=={{header|Visual Basic .NET}}==

<syntaxhighlight lang=vbnet>Console.WriteLine(Chr(97)) 'Prints a

<syntaxhighlight lang="vbnet">Console.WriteLine(Chr(97)) 'Prints a

Console.WriteLine(Asc("a")) 'Prints 97</syntaxhighlight>

=={{header|Vlang}}==

<syntaxhighlight lang=vlang>fn main() {

<syntaxhighlight lang="vlang">fn main() {

println('a'[0]) // prints "97"

println('π'[0]) // prints "207"

Line 2,678:

Line 2,508:

97->0x61 207->0xcf 128->0x80

</pre>

=={{header|Wren}}==

Wren does not have a ''character'' type as such but one can use single character strings instead. Strings can contain any Unicode code point.

<syntaxhighlight lang=ecmascript>var cps = []

<syntaxhighlight lang="ecmascript">var cps = []

for (c in ["a", "π", "字", "🐘"]) {

var cp = c.codePoints[0]

Line 2,705:

Line 2,534:

128024 = 🐘

</pre>

=={{header|XLISP}}==

In a REPL:

<syntaxhighlight lang=scheme>[1] (INTEGER->CHAR 97)

<syntaxhighlight lang="scheme">[1] (INTEGER->CHAR 97)

#\a

Line 2,714:

Line 2,542:

97</syntaxhighlight>

=={{header|XPL0}}==

A character is represented by an integer value equal to its ASCII code.

Line 2,720:

Line 2,547:

character to an integer equal to its ASCII code.

<syntaxhighlight lang=~~XPL0~~>IntOut(0, ^a); \(Integer Out) displays "97" on the console (device 0)

<syntaxhighlight lang="xpl0">IntOut(0, ^a); \(Integer Out) displays "97" on the console (device 0)

ChOut(0, 97); \(Character Out) displays "a" on the console (device 0)</syntaxhighlight>

=={{header|Z80 Assembly}}==

The Z80 doesn't understand what ASCII codes are by itself. Most computers/systems that use it will have firmware that maps each code to its corresponding glyph. Printing a character given its code is trivial. On the Amstrad CPC:

<syntaxhighlight lang=z80>LD A,'a'

<syntaxhighlight lang="z80">LD A,'a'

call &BB5a</syntaxhighlight>

Printing a character code given a character takes slightly more work. You'll need to separate each hexadecimal digit of the ASCII code, convert each digit to ASCII, and print it. Once again, thanks to Keith of [[http://www.chibiakumas.com Chibiakumas]] for this code:

<syntaxhighlight lang=z80>ShowHex:

<syntaxhighlight lang="z80">ShowHex:

push af

and %11110000

Line 2,748:

Line 2,574:

jp PrintChar ;this is whatever routine prints to the screen on your system.

; It must end in a "ret" and it must take the accumulator as its argument.</syntaxhighlight>

=={{header|Zig}}==

<syntaxhighlight lang=zig>const std = @import("std");

<syntaxhighlight lang="zig">const std = @import("std");

const debug = std.debug;

Line 2,797:

Line 2,622:

'お' code: 12362 [hexa: U+304a]

All 2 tests passed.</pre>

=={{header|zkl}}==

The character set is 8 bit ASCII (but doesn't care if you use UTF-8 or unicode characters).

<syntaxhighlight lang=zkl> "a".toAsc() //-->97

<syntaxhighlight lang="zkl"> "a".toAsc() //-->97

(97).toChar() //-->"a"</syntaxhighlight>

=={{header|Zoea}}==

program: character_codes

input: a

output: 97

</syntaxhighlight>

=={{header|Zoea Visual}}==

[http://zoea.co.uk/examples/zv-rc/Character_codes.png Character Codes]

=={{header|ZX Spectrum Basic}}==

<syntaxhighlight lang=zxbasic>10 PRINT CHR$ 97: REM prints a

<syntaxhighlight lang="zxbasic">10 PRINT CHR$ 97: REM prints a

20 PRINT CODE "a": REM prints 97</syntaxhighlight>