Character codes: Difference between revisions

assign c to <n> casting.

move <n> to n.

Output:

<pre>

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

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

=={{header|Ada}}==

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

a = 97

</pre>

=={{header|Aime}}==

<lang aime># prints "97"

o_byte(97);

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

=={{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.

 

=={{header|AWK}}==

AWK has not 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>

<lang awk>function ord(c)

{

PRINT ASC(char) 'prints 97</lang>

 

{{works with|ZX Spectrum Basic}}

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

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

 

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

 

=={{header|CoffeeScript}}==

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

 

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

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

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

 

=={{header|D}}==

Could be treated like C, but since the standard string type is UTF-8, let's be verbose.

<lang d>import std.stdio, std.utf;

 

=={{header|Delphi}}==

Example from Studio 2006.

<lang delphi>program Project1;

 

Readln;

 

=={{header|DWScript}}==

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

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

 

=={{header|E}}==

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

# value: 97

 

=={{header|Erlang}}==

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

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

2> F("a").

97</lang>

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

<lang erlang>3> $a.

97</lang>

Unicode is fully supported since release R13A only.

 

=={{header|Euphoria}}==

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

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

printfn "%d" (int c)

printfn "%c" (char n)</lang>

Output

<pre>

 

=={{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.

a

fansh> 'a'.toInt

 

=={{header|Forth}}==

=={{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.

println[char[97]] // prints a

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

 

=={{header|GAP}}==

960

</pre>

For the second part of the task, printing the character of a given code, the <tt>%c</tt> verb of <tt>fmt.Printf</tt> 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.)

<lang go>b := byte(97)

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

<lang golfscript>97[]+''+p</lang>

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

<lang golfscript>'a')\;p

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

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

Output:

<pre>97

 

=={{header|Haskell}}==

<lang haskell>import Data.Char

 

}

}</lang>

Java characters support Unicode:

<lang java>public class Bar {

<lang joy>'a ord.

97 chr.</lang>

 

=={{header|K}}==

 

_ci 97 98 99 65 66 67

 

=={{header|LabVIEW}}==

{{VI snippet}}<br/>

[[File:LabVIEW_Character_codes.png]]

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

<lang lb>charCode = 97

<lang Mathematica>ToCharacterCode["abcd"]

FromCharacterCode[{97}]</lang>

Result:

<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:

 

=={{header|Metafont}}==

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

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

string a;

<lang MUMPS>WRITE $ASCII("M")

WRITE $CHAR(77)</lang>

 

=={{header|Objeck}}==

 

=={{header|OCaml}}==

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

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

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

 

Here character is just a string of length 1

<lang perl>print ord('a'), "\n"; # prints "97"

print chr(97), "\n"; # prints "a"</lang>

 

=={{header|PHP}}==

 

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

2 c character (1),

2 i fixed binary (8) unsigned;

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

 

=={{header|PowerShell}}==

<lang powershell>[char] 97 # a

[char] 9786 # ☺</lang>

=={{header|Prolog}}==

SWI-Prolog has predefined predicate char_code/2.

 

=={{header|PureBasic}}==

PureBasic allows compiling code so that it will use either Ascii or a Unicode (UCS-2) encoding for representing its string content. It also allows for the source code that is being compiled to be in either Ascii or UTF-8 encoding. 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.

<lang PureBasic>If OpenConsole()

 

=={{header|REXX}}==

yyy='34'x /*assign hexadecimal 34 to YYY.*/

yyy=x2c(34) /* (same as above) */

say c2x(yyy) /*displays the value of YYY in hexadecimal. */

say c2d(yyy) /*displays the value of YYY in decimal. */

 

=={{header|Ruby}}==

 

Without worrying about supplemental character sets:

<lang scala>scala> 'a' toInt

res9: Int = 97

res10: Char = a</lang>

 

<lang scala>def charToInt(c: Char, next: Char): Option[Int] = (c, next) match {

case _ if (c.isHighSurrogate && next.isLowSurrogate) => Some(java.lang.Character.toCodePoint(c, next))

 

=={{header|Scheme}}==

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

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

 

=={{header|Slate}}==

<lang slate>$a code.

97 as: String Character.</lang>

 

=={{header|Smalltalk}}==

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

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

 

=={{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.

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

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

 

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

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

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

 

=={{header|Tcl}}==

<lang tcl># ASCII

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

Input "CODE? ",A

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

 

The TI-89 uses an 8-bit charset/encoding which is similar to ISO-8859-1, but with more mathematical symbols and Greek letters. At least codes 14-31, 128-160, 180 differ. The ASCII region is unmodified. (TODO: Give a complete list.)

 

 

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. The portion of the program actually implementing the task is marked with a line of “©”s.

<lang ti89b>Prgm

Local k, s

<lang trith>"π" ord print

960 chr print</lang>

=={{header|TUSCRIPT}}==

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

Output:

<pre>a=97</pre>

 

=={{header|Ursala}}==

(`a,97)

</pre>