Character codes: Difference between revisions

[[Category:Basic language learning]]

[[Category:String manipulation]]

[[Category:Simple]]

 

 

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

<br><br>

 

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

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

field-symbols <n> type x.

assign c to <n> casting.

move <n> to n.

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

=={{header|ACL2}}==

Similar to Common Lisp:

 

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

=={{header|Ada}}==

 

procedure Char_Code is

begin

Put_Line (Character'Val (97) & " =" & Integer'Image (Character'Pos ('a')));

The predefined language attributes S'Pos and S'Val for every discrete subtype, and Character is such a type, yield the position of a value and value by its position correspondingly.

{{out}}

<pre>a = 97</pre>

=={{header|Aime}}==

o_integer('a');

o_byte('\n');

# prints "a"

o_byte(97);

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

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

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

''Character conversions'' may be available in the ''standard prelude'' so that when

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

records are read.

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

make conv(tape, ebcdic conv);

Every '''channel''' has an associated standard character conversion that can be determined

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

file/tape. eg.

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

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

write( decode( "a" ) );

% display the character corresponding to 97 ("a" in ASCII) %

write( code( 97 ) );

=={{header|APL}}==

{{works with|Dyalog APL}}

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

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

APL

⎕UCS 'Hello, world!'

=={{header|AppleScript}}==

{{out}}

<pre>(*97*)

(*97, 65*)</pre>

 

 

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

{

return chmap[c]

s = sprintf("%c%c", 97, 98)

print s

=={{header|Axe}}==

=={{header|Babel}}==

 

 

{{Out}}<pre>

</pre>

 

{{out}}

babel

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

char = "a"

PRINT CHR$(charCode) 'prints a

 

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

{{works with|ZX Spectrum Basic}}

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

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

 

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

 

<pre>!=97</pre>

 

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

char$ = "a"

PRINT CHR$(charCode) : REM prints a

=={{header|Befunge}}==

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

 

=={{header|Bracmat}}==

$ ( str

$ ( "\nLatin a

)

)

{{Out}}<pre>Latin a

ISO-9959-1: 97 = a

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.

 

 

int main() {

printf("%c\n", 97); /* prints "a"; we don't have to cast because printf is type agnostic */

return 0;

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

C# represents strings and characters internally as Unicode,

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

 

namespace RosettaCode.CharacterCode

}

}

 

=={{header|Clojure}}==

(print (char 97)) ; prints \a

 

; use String because char in Java can't represent characters outside Basic Multilingual Plane

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

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

program-id. character-codes.

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

display function ord('*')

goback.

 

{{out}}

)

000000043</pre>

=={{header|CoffeeScript}}==

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

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

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

BlackBox Component Builder

VAR

c : CHAR;

c := CHR(3A9H);

StdLog.Char(c);StdLog.String(":> ");StdLog.Int(ORD(c));StdLog.Ln

{{Out}}

<pre>A:> 65

Ω:> 937</pre>

=={{header|D}}==

import std.stdio, std.utf;

 

// 'index' has moved to next character input position.

assert(index == 1);

{{out}}

<pre>97</pre>

=={{header|Delphi}}==

Example from Studio 2006.

 

{$APPTYPE CONSOLE}

 

Readln;

 

=={{header|DWScript}}==

 

=={{header|E}}==

# value: 97

 

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

 

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

end

end

 

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}}==

 

 

{{out}}

<pre>

=={{header|Elixir}}==

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

97

iex(2)> to_string([code])

 

=={{header|Erlang}}==

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

#Fun<erl_eval.6.13229925>

2> F("a").

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

Unicode is fully supported since release R13A only.

=={{header|Euphoria}}==

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

let n = 65

printfn "%d" (int c)

{{Out}}<pre>65

A</pre>

=={{header|Factor}}==

"ア" first .

 

=={{header|FALSE}}==

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

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

dup . \ 97

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

=={{header|FreeBASIC}}==

' FreeBASIC v1.05.0 win64

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

Sleep

End

 

{{out}}

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.

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]

 

CharInt(65);

# 'A'

IntChar('Z');

 

=={{header|Go}}==

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

Literal constants in Go are not typed (named constants can be).

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.

 

import "fmt"

// We can also print the bytes of a string without an explicit loop

fmt.Printf("\n string bytes: % #x\n", s)

{{out}}

<pre>

</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).

r := rune(960)

{{out}}

<pre>

 

Examples showing strings constructed from integer constants and then printed:

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

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

'a'(\;p

'a'0=p

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

{{Out}}

<pre>97

a</pre>

=={{header|Haskell}}==

 

main = do

print (chr 97) -- prints "'a'"

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

=={{header|HicEst}}==

print(number('a'))

print(text([97]))

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

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

 

every x := !L do

write(x, " ==> ", char(integer(x)) | ord(x) ) # char produces a character, ord produces a number

Icon and Unicon do not currently support double byte character sets.

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

a ==> 97</pre>

=={{header|Io}}==

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

97 asCharacter println // --> a

 

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

=={{header|J}}==

abc☺

 

3 u: 7 u: 'abc☺'

 

 

 

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).

 

abc

a.i.'abc'

 

=={{header|Java}}==

 

=={{header|JavaScript}}==

Here character is just a string of length 1

 

ES6 brings '''String.codePointAt()''' and '''String.fromCodePoint()''', which provide access to 4-byte unicode characters,

in addition to the usual 2-byte unicode characters.

 

 

{{Out}}

 

 

and

 

return String.fromCodePoint(x);

 

{{Out}}

 

=={{header|Joy}}==

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

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

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.

{{out}}<pre>97

a</pre>

=={{header|K}}==

97 98 99 65 66 67

 

_ci 97 98 99 65 66 67

 

=={{header|LabVIEW}}==

{{VI snippet}}<br/>

[[File:LabVIEW_Character_codes.png]]

 

=={{header|Lang5}}==

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

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

 

'a ord . # 97

 

=={{header|Lasso}}==

'A'->integer

97->bytes

{{out}}<pre>97

65

a

A</pre>

=={{header|LFE}}==

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

 

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

97

ok

> (: io format '"~p~n" (list '(97)))

"a"

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

char$ = "a"

print chr$(charCode) 'prints a

 

=={{header|Lingo}}==

put chartonum("a")

-- 97

-- returns character for Unicode code point (=ASCII code for ASCII characters)

put numtochar(934)

=={{header|Little}}==

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

=={{header|LiveCode}}==

=={{header|Logo}}==

Logo characters are words of length 1.

=={{header|Logtalk}}==

a

Char = a

97

Code = 97

=={{header|Lua}}==

 

=={{header|Maple}}==

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

65

 

"A"

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

[65]

 

> convert( [65], bytes );

"A"

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

Use the FromCharacterCode and ToCharacterCode functions:

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

 

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

 

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

asciiNumber = uint32(character)

 

Sample Usage:

 

ans =

ans =

 

=={{header|Maxima}}==

"A"

 

cint("A");

=={{header|Metafont}}==

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

string a;

a := readstring;

message char10; % (this add a newline...)

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

 

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

 

IMPORT InOut;

InOut.Write (CHR (ascii));

InOut.WriteLn

{{out}}

 

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

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

=={{header|MUMPS}}==

 

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

 

 

=={{header|NetRexx}}==

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

options replace format comments java crossref symbols nobinary

 

say ci.right(3)"| '"cc"'" cd.right(6) cx.right(4, 0) "'"dc"' '"xc"'"

end ci

{{Out}}

<pre style="height:20ex; overflow:scroll">' abcde$¢£¤¥₠₡₢₣₤₥₦₧₨₩₪₫€₭₮₯₰₱₲₳₴₵'

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

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

=={{header|Nim}}==

echo chr(97) # echoes a

 

 

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

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

IMPORT Out;

VAR

Out.Int(d,3);Out.Ln;

Out.Char(c);Out.Ln

{{Out}}<pre>

97

=={{header|Objeck}}==

=={{header|OCaml}}==

 

The following are aliases for the above functions:

- : char -> int = <fun>

# Char.chr;;

=={{header|Oforth}}==

 

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

 

 

{{out}}

97

</pre>

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

CHR(97) SKIP

ASC("a")

=={{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):

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

=={{header|Pascal}}==

=={{header|Perl}}==

 

=={{header|Phix}}==

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

{{out}}

<pre>

</pre>

 

=={{header|PHP}}==

Here character is just a string of length 1

 

=={{header|PicoLisp}}==

-> 97

: (char "字")

-> ("文" "字")

: (mapcar char @)

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

2 c character (1),

2 i fixed binary (8) unsigned;

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

=={{header|PowerShell}}==

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:

This also works with Unicode:

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

=={{header|Prolog}}==

SWI-Prolog has predefined predicate char_code/2.

?- 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.

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.

;Results are the same when compiled for Ascii or Unicode

charCode.c = 97

Input()

CloseConsole()

 

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

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

charCode.c = 960

Input()

CloseConsole()

=={{header|Python}}==

{{works with|Python|2.x}}

 

8-bit characters:

 

Unicode characters:

 

{{works with|Python|3.x}}

Here character is just a string of length 1

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

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

 

 

=={{header|Racket}}==

 

(define (code ch)

(printf "The unicode number ~a is the character ~s\n" n (integer->char n)))

(char 97)

 

=={{header|RapidQ}}==

Print Chr$(97)

Print Asc("a")

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

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

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

say ' dec code: ' c2d(yyy) /* decimal */

say ' bin code: ' x2b( c2x(yyy) ) /* binary (as a bit string) */

'''output'''

<pre>

 

===EBCDIC===

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

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

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

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

{{out}}

<pre>a

129

10000001</pre>

=={{header|Ring}}==

see ascii("a") + nl

see char(97) + nl

 

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

 

=> 97

> 97.chr

 

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

=={{header|Rust}}==

 

fn main() {

//unicode char

println!("{}", 'π' as u32);

{{out}}

<pre>97

960

π</pre>

=={{header|Sather}}==

main is

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

#OUT + CHAR::from_ascii_int(97) + "\n";

end;

=={{header|Scala}}==

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

res2: Int = 97

 

 

scala> "\uD869\uDEA5"

===Full swing workout===

Taken the supplemental character sets in account.

 

object CharacterCode extends App {

f"${"(" + UnicodeToInt(coll).toString}%8s) ${flags(coll)} ${getName(coll(0).toInt)} "

}.foreach(println)

{{Out}}

<pre style="height:20ex; overflow:scroll">

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}}==

=={{header|Seed7}}==

=={{header|SequenceL}}==

SequenceL natively supports ASCII characters.<br>

'''SequenceL Interpreter Session:'''

97

cmd:>intToAscii(97)

=={{header|Slate}}==

=={{header|Smalltalk}}==

 

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

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

chr_end

output = chr(65)

output = asc('A')

{{Out}}

<pre>A

65</pre>

 

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

 

=={{header|Swift}}==

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

You can initialize it with a string literal:

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

let c2: UnicodeScalar = "π"

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

for c in s1.unicodeScalars {

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

for c in s2.unicodeScalars {

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

 

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

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

let i2: UInt32 = 960

=={{header|Tcl}}==

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

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

# Unicode is the same

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

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

Disp inString(Str1,"A

Input "CODE? ",A

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

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.

Local k, s

ClrIO

EndIf

EndLoop

=={{header|Trith}}==

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

=={{header|TUSCRIPT}}==

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

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

=={{header|Ursa}}==

out (ord "a") endl console

# outputs the character 'a' given its value

=={{header|Ursala}}==

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

the character table.

#import nat

 

#cast %cnX

 

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

 

 

=={{header|VBScript}}==

'prints a

WScript.StdOut.WriteLine Chr(97)

'prints 97

WScript.StdOut.WriteLine Asc("a")

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

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

echo char2nr("a")

"Prints 97

 

echo nr2char(97)

 

 

 

=={{header|XLISP}}==

In a REPL:

 

#\a

[2] (CHAR->INTEGER #\a)

 

=={{header|XPL0}}==

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

character to an integer equal to its ASCII code.

 

 

=={{header|zkl}}==

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

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

{{omit from|bc}}

{{omit from|GUISS}}