Character codes: Difference between revisions

babel

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

<syntaxhighlight lang="qbasic">charCode = 97

$: 36

€: 8364, 36</pre>

 

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

{{Out}}<pre>A

66</pre>

 

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

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

110 PRINT CHR$(65)</syntaxhighlight>

 

==={{header|QBasic}}===

{{works with|FreeBASIC}}

{{works with|Run BASIC}}

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

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

<pre>38

A</pre>

 

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

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

END</syntaxhighlight>

 

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

=={{header|Ecstasy}}==

<syntaxhighlight lang="java">

@Inject Console console;

// character to its integer value

UInt32 codepoint = char.codepoint;

| char from codepoint={fromCodePoint.quoted()}

);

}

}

</syntaxhighlight>

 

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

<syntaxhighlight lang="elena">import extensions;

 

var ch := $97;

 

console.printLine(ch.toInt())

}</syntaxhighlight>

97

</pre>

=={{header|Elixir}}==

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

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

fansh> 'a'.toInt

97</syntaxhighlight>

=={{header|Forth}}==

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

97 98 99 9786</syntaxhighlight>

 

 

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

a.i.'abc'

97 98 99</syntaxhighlight>

=={{header|Java}}==

 

=={{header|JavaScript}}==

Here character is just a string of length 1

{{VI snippet}}<br/>

[[File:LabVIEW_Character_codes.png]]

=={{header|Lang5}}==

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

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

 

 

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

writeln .a3 == .a4

writeln "numbers: ", join ", ", [.a1, .a2, .a3, .a4, .a5]

 

{{out}}

letters: a, a, a, a, aaaa

</pre>

=={{header|Lasso}}==

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

The character for '65' is: A.

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

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

<syntaxhighlight lang="modula2">MODULE 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="pascal">writeln(ord('a'));

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

=={{header|Perl}}==

===Narrow===

'Unicode script',

'Unicode block',

'Ordinal(s)',

'Hex ordinal(s)',

'Round trip by name',

'Round trip by ordinal'

Z

[ $_,

.uniprops('Script').join(', '),

.uniprops('Block').join(', '),

.ords,

.ords.fmt('0x%X'),

}</syntaxhighlight>

{{out}}

 

 

 

 

 

=={{header|RapidQ}}==

<syntaxhighlight lang="vb">

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.

> 97.chr

=> "a"</syntaxhighlight>

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

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

A

65</pre>

=={{header|SPL}}==

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

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

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

=={{header|VBA}}==

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

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

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

var cp = c.codePoints[0]

128024 = 🐘

</pre>

=={{header|XLISP}}==

In a REPL:

=={{header|Zig}}==

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

const unicode = std.unicode;

 

 

// Zig's string is just an array of bytes (u8).

 

for (message) |val| {

}

}

 

 

 

const utf8_view = unicode.Utf8View.initUnchecked(message);

while (iter.nextCodepoint()) |val| {

var array: [4]u8 = undefined;

 

}

}</syntaxhighlight>

 

{{out}}

'A' code: 65 [hexa: 0x41]

'B' code: 66 [hexa: 0x42]

'b' code: 98 [hexa: 0x62]

'c' code: 99 [hexa: 0x63]

'あ' code: 12354 [hexa: U+3042]

'い' code: 12356 [hexa: U+3044]

'う' code: 12358 [hexa: U+3046]

'え' code: 12360 [hexa: U+3048]

=={{header|zkl}}==

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