Character codes: Difference between revisions

 

 

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

=={{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')));

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

{

return chmap[c]

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

print s

 

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

char$ = "a"

PRINT CHR$(charCode) : REM prints a

=={{header|Befunge}}==

 

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

 

namespace RosettaCode.CharacterCode

}

}

 

=={{header|Clojure}}==

(print (char 97)) ; prints \a

 

; Unicode is also available, as Clojure uses the underlying java Strings & chars

(print (int \π)) ; prints 960

 

=={{header|CoffeeScript}}==

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

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

=={{header|D}}==

 

string test = "a";

size_t index = 0;

 

 

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

 

 

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

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

println[char[97]] // prints a

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

 

# 'A'

 

=={{header|Go}}==

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

 

import "fmt"

 

func main() {

 

<pre>

97 960 aπ

</pre>

r := rune(960)

<pre>

a π

 

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.

<pre>97

a</pre>

=={{header|Haskell}}==

 

main = do

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

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

=={{header|HicEst}}==

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

a ==> 97</pre>

 

=={{header|J}}==

abc☺

 

3 u: 7 u: 'abc☺'

 

 

 

=={{header|JavaScript}}==

Here character is just a string of length 1

 

=={{header|Joy}}==

 

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

Use the FromCharacterCode and ToCharacterCode functions:

 

"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

 

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

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

=={{header|MUMPS}}==

 

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

| Chr C2D C2X D2C X2C

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

31| '₳' 8371 20B3 '₳' '₳'

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

 

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

IMPORT Out;

VAR

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

Out.Char(c);Out.Ln

97

=={{header|Objeck}}==

=={{header|OCaml}}==

 

The following are aliases for the above functions:

- : char -> int = <fun>

# Char.chr;;

 

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

{{out}}

 

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

 

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

=={{header|PureBasic}}==

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

Here character is just a string of length 1

 

8-bit characters:

 

Unicode characters:

 

Here character is just a string of length 1

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

 

 

=={{header|Racket}}==

 

(define (code ch)

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

(char 97)

 

 

=={{header|REXX}}==

 

 

 

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

| Chr C/C++/Java source Code Point Hex Dec Mn Name

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

0:  "\uFEFF" U+0FEFF (65279) NN ZERO WIDTH NO-BREAK SPACE

2: a "\u0061" U+00061 (97) NN LATIN SMALL LETTER A

3: $ "\u0024" U+00024 (36) NN DOLLAR SIGN

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

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

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

chr_end

output = chr(65)

output = asc('A')

<pre>A

A

65</pre>

 

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

 

=={{header|Tcl}}==

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

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

# Unicode is the same

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

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

Disp inString(Str1,"A

Input "CODE? ",A

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

 

The TI Connect X desktop software converts between this unique character set and Unicode characters, though sometimes in a consistent but inappropriate fashion. <!-- Only Mac experience went into this statement; info for other platforms? -->

 

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)

=={{header|Ursala}}==

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

the character table.

#import nat

 

#cast %cnX

 

<pre>

</pre>

 

 

=={{header|XPL0}}==

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

character to an integer equal to its ASCII code.

 

 

 

{{omit from|GUISS}}