String length: Difference between revisions
→Character Length: raw utf8 example |
added OpenEdge solution |
||
Line 926: | Line 926: | ||
This gives the number of bytes, not of characters. e.g. length("è") is 2 when "è" is encoded e.g. as UTF-8. |
This gives the number of bytes, not of characters. e.g. length("è") is 2 when "è" is encoded e.g. as UTF-8. |
||
=={{header|OpenEdge/Progress}}== |
|||
The codepage can be set independently for input / output and internal operations. The following examples are started from an iso8859-1 session and therefore need to use fix-codepage to adjust the string to utf-8. |
|||
===Character Length=== |
|||
<lang progress>DEF VAR lcc AS LONGCHAR. |
|||
FIX-CODEPAGE( lcc ) = "UTF-8". |
|||
lcc = "møøse". |
|||
MESSAGE LENGTH( lcc ) VIEW-AS ALERT-BOX.</lang> |
|||
===Byte Length=== |
|||
<lang progress>DEF VAR lcc AS LONGCHAR. |
|||
FIX-CODEPAGE( lcc ) = "UTF-8". |
|||
lcc = "møøse". |
|||
MESSAGE LENGTH( lcc, "RAW" ) VIEW-AS ALERT-BOX.</lang> |
|||
=={{header|Oz}}== |
=={{header|Oz}}== |
Revision as of 04:23, 20 July 2011
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
In this task, the goal is to find the character and byte length of a string. This means encodings like UTF-8 need to be handled properly, as there is not necessarily a one-to-one relationship between bytes and characters. For example, the character length of "møøse" is 5 but the byte length is 7 in UTF-8 and 10 in UTF-16.
Please mark your examples with ===Character Length=== or ===Byte Length===.
4D
Byte Length
<lang 4d>$length:=Length("Hello, world!")</lang>
ActionScript
Character Length
<lang actionscript>myStrVar.length()</lang>
Ada
Byte Length
<lang ada>Str : String := "Hello World"; Length : constant Natural := Str'Size / 8;</lang> The 'Size attribute returns the size of an object in bits. Provided that under "byte" one understands an octet of bits, the length in "bytes" will be 'Size divided to 8. Note that this is not necessarily the machine storage unit. In order to make the program portable, System.Storage_Unit should be used instead of "magic number" 8. System.Storage_Unit yields the number of bits in a storage unit on the current machine. Further, the length of a string object is not the length of what the string contains in whatever measurement units. String as an object may have a "dope" to keep the array bounds. In fact the object length can even be 0, if the compiler optimized the object away. So in most cases "byte length" makes no sense in Ada.
Character Length
<lang ada>Latin_1_Str : String := "Hello World"; UCS_16_Str : Wide_String := "Hello World"; Unicode_Str : Wide_Wide_String := "Hello World"; Latin_1_Length : constant Natural := Latin_1_Str'Length; UCS_16_Length : constant Natural := UCS_16_Str'Length; Unicode_Length : constant Natural := Unicode_Str'Length;</lang> The attribute 'Length yields the number of elements of an array. Since strings in Ada are arrays of characters, 'Length is the string length. Ada supports strings of Latin-1, UCS-16 and full Unicode characters. In the example above character length of all three strings is 11. The length of the objects in bits will differ.
ALGOL 68
Bits and Bytes Length
<lang algol68>BITS bits := bits pack((TRUE, TRUE, FALSE, FALSE)); # packed array of BOOL # BYTES bytes := bytes pack("Hello, world"); # packed array of CHAR # print((
"BITS and BYTES are fixed width:", new line, "bits width:", bits width, ", max bits: ", max bits, ", bits:", bits, new line, "bytes width: ",bytes width, ", UPB:",UPB STRING(bytes), ", string:", STRING(bytes),"!", new line
))</lang> Output:
BITS and BYTES are fixed width: bits width: +32, max bits: TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT, bits:TTFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF bytes width: +32, UPB: +32, string:Hello, world!
Character Length
<lang algol68>STRING str := "hello, world"; INT length := UPB str; printf(($"Length of """g""" is "g(3)l$,str,length));
printf(($l"STRINGS can start at -1, in which case LWB must be used:"l$)); STRING s := "abcd"[@-1]; print(("s:",s, ", LWB:", LWB s, ", UPB:",UPB s, ", LEN:",UPB s - LWB s + 1))</lang> Output:
Length of "hello, world" is +12 STRINGS can start at -1, in which case LWB must be used: s:abcd, LWB: -1, UPB: +2, LEN: +4
AppleScript
Byte Length
<lang applescript>count of "Hello World"</lang> Mac OS X 10.5 (Leopard) includes AppleScript 2.0 which uses only Unicode (UTF-16) character strings. This example has not been tested and may not work on previous versions of AppleScript. <lang applescript>set inString to "Hello World" as Unicode text set byteCount to 0 set idList to id of inString
repeat with incr in idList
set byteCount to byteCount + 2 if incr as integer > 65535 then set byteCount to byteCount + 2 end if
end repeat
byteCount</lang>
Character Length
<lang applescript>count of "Hello World"</lang> Or: <lang applescript>count "Hello World"</lang>
AutoHotkey
Character Length
<lang AutoHotkey>Msgbox % StrLen("Hello World")</lang> Or: <lang AutoHotkey>String := "Hello World" StringLen, Length, String Msgbox % Length</lang>
AWK
Byte Length
From within any code block: <lang awk>w=length("Hello, world!") # static string example x=length("Hello," s " world!") # dynamic string example y=length($1) # input field example z=length(s) # variable name example</lang> Ad hoc program from command line:
echo "Hello, wørld!" | awk '{print length($0)}' # 14
From executable script: (prints for every line arriving on stdin) <lang awk>#!/usr/bin/awk -f {print"The length of this line is "length($0)}</lang>
Batch File
Byte Length
<lang dos>@echo off setlocal enabledelayedexpansion call :length %1 res echo length of %1 is %res% goto :eof
- length
set str=%~1 set cnt=0
- loop
if "%str%" equ "" ( set %2=%cnt% goto :eof ) set str=!str:~1! set /a cnt = cnt + 1 goto loop</lang>
BASIC
Character Length
BASIC only supports single-byte characters. The character "ø" is converted to "°" for printing to the console and length functions, but will still output to a file as "ø". <lang qbasic> INPUT a$
PRINT LEN(a$)</lang>
ZX Spectrum Basic
The ZX Spectrum needs line numbers:
<lang basic> 10 INPUT a$ 20 PRINT LEN(a$) </lang>
BBC BASIC
Character Length
<lang bbcbasic> INPUT text$
PRINT LEN(text$)</lang>
Byte Length
<lang bbcbasic> CP_ACP = 0
CP_UTF8 = &FDE9 textA$ = "møøse" textW$ = " " textU$ = " " SYS "MultiByteToWideChar", CP_ACP, 0, textA$, -1, !^textW$, LEN(textW$)/2 TO nW% SYS "WideCharToMultiByte", CP_UTF8, 0, textW$, -1, !^textU$, LEN(textU$), 0, 0 PRINT "Length in bytes (ANSI encoding) = " ; LEN(textA$) PRINT "Length in bytes (UTF-16 encoding) = " ; 2*(nW%-1) PRINT "Length in bytes (UTF-8 encoding) = " ; LEN($$!^textU$)</lang>
Output:
Length in bytes (ANSI encoding) = 5 Length in bytes (UTF-16 encoding) = 10 Length in bytes (UTF-8 encoding) = 7
C
Byte Length
<lang c>#include <string.h>
int main(void) {
const char *string = "Hello, world!"; size_t length = strlen(string); return 0;
}</lang> or by hand:
<lang c>int main(void) {
const char *string = "Hello, world!"; size_t length = 0; const char *p = string; while (*p++ != '\0') length++; return 0;
}</lang>
or (for arrays of char only)
<lang c>#include <stdlib.h>
int main(void) {
char s[] = "Hello, world!"; size_t length = sizeof s - 1; return 0;
}</lang>
Character Length
For wide character strings (usually Unicode uniform-width encodings such as UCS-2 or UCS-4):
<lang c>#include <stdio.h>
- include <wchar.h>
int main(void) {
wchar_t *s = L"\x304A\x306F\x3088\x3046"; /* Japanese hiragana ohayou */ size_t length;
length = wcslen(s); printf("Length in characters = %d\n", length); printf("Length in bytes = %d\n", sizeof(s) * sizeof(wchar_t)); return 0;
}</lang>
Dealing with raw multibyte string
Following code is written in UTF-8, and environment locale is assumed to be UTF-8 too. Note that "møøse" is here directly written in the source code for clarity, which is not a good idea in general. mbstowcs()
, when passed NULL as the first argument, effectively counts the number of chars in given string under current locale.
<lang c>#include <stdio.h>
- include <stdlib.h>
- include <locale.h>
int main() { setlocale(LC_CTYPE, ""); char moose[] = "møøse"; printf("bytes: %d\n", sizeof(moose) - 1); printf("chars: %d\n", (int)mbstowcs(0, moose, 0));
return 0;
}</lang>output
bytes: 7 chars: 5
C++
Byte Length
<lang cpp>#include <string> // (not <string.h>!) using std::string;
int main() {
string s = "Hello, world!"; string::size_type length = s.length(); // option 1: In Characters/Bytes string::size_type size = s.size(); // option 2: In Characters/Bytes // In bytes same as above since sizeof(char) == 1 string::size_type bytes = s.length() * sizeof(string::value_type);
}</lang> For wide character strings:
<lang cpp>#include <string> using std::wstring;
int main() {
wstring s = L"\u304A\u306F\u3088\u3046"; wstring::size_type length = s.length() * sizeof(wstring::value_type); // in bytes
}</lang>
Character Length
For wide character strings:
<lang cpp>#include <string> using std::wstring;
int main() {
wstring s = L"\u304A\u306F\u3088\u3046"; wstring::size_type length = s.length();
}</lang>
For narrow character strings and arbitrary locales:
<lang cpp>#include <cwchar> // for mbstate_t
- include <locale>
// give the character length for a given named locale std::size_t char_length(std::string const& text, char const* locale_name) {
// locales work on pointers; get length and data from string and // then don't touch the original string any more, to avoid // invalidating the data pointer std::size_t len = text.length(); char const* input = text.data();
// get the named locale std::locale loc(locale_name);
// get the conversion facet of the locale typedef std::codecvt<wchar_t, char, std::mbstate_t> cvt_type; cvt_type const& cvt = std::use_facet<cvt_type>(loc);
// allocate buffer for conversion destination std::size_t bufsize = cvt.max_length()*len; wchar_t* destbuf = new wchar_t[bufsize]; wchar_t* dest_end;
// do the conversion mbstate_t state = mbstate_t(); cvt.in(state, input, input+len, input, destbuf, destbuf+bufsize, dest_end);
// determine the length of the converted sequence std::size_t length = dest_end - destbuf;
// get rid of the buffer delete[] destbuf;
// return the result return length;
}</lang>
Example usage (note that the locale names are OS specific):
<lang cpp>#include <iostream>
int main() {
// Tür (German for door) in UTF8 std::cout << char_length("\x54\xc3\xbc\x72", "de_DE.utf8") << "\n"; // outputs 3
// Tür in ISO-8859-1 std::cout << char_length("\x54\xfc\x72", "de_DE") << "\n"; // outputs 3
}</lang>
Note that the strings are given as explicit hex sequences, so that the encoding used for the source code won't matter.
C#
Platform: .NET
Character Length
<lang csharp>string s = "Hello, world!"; int characterLength = s.Length;</lang>
Byte Length
Strings in .NET are stored in Unicode. <lang csharp>using System.Text;
string s = "Hello, world!"; int byteLength = Encoding.Unicode.GetByteCount(s);</lang> To get the number of bytes that the string would require in a different encoding, e.g., UTF8: <lang csharp>int utf8ByteLength = Encoding.UTF8.GetByteCount(s);</lang>
Clean
Byte Length
Clean Strings are unboxed arrays of characters. Characters are always a single byte. The function size returns the number of elements in an array.
<lang clean>import StdEnv
strlen :: String -> Int strlen string = size string
Start = strlen "Hello, world!"</lang>
Clojure
Byte Length
<lang clojure>(count (.getBytes "Hello, world!")) ; 13 bytes (count (.getBytes "π")) ; two bytes</lang>
Character length
<lang clojure>(count "Hello, world!")</lang>
ColdFusion
Byte Length
<lang cfm>#len("Hello World")#</lang>
Character Length
<lang cfm>#len("Hello World")#</lang>
Common Lisp
Byte Length
In Common Lisp, there is no standard way to examine byte representations of characters, except perhaps to write a string to a file, then reopen the file as binary. However, specific implementations will have ways to do so. For example:
<lang lisp>(length (sb-ext:string-to-octets "Hello Wørld"))</lang> returns 12.
Character Length
Common Lisp represents strings as sequences of characters, not bytes, so there is no ambiguity about the encoding. The length function always returns the number of characters in a string. <lang lisp>(length "Hello World")</lang> returns 11, and
(length "Hello Wørld")
returns 11 too.
Component Pascal
Component Pascal encodes strings in UTF-16, which represents each character with 16-bit value.
Character Length
<lang oberon2> MODULE TestLen;
IMPORT Out;
PROCEDURE DoCharLength*; VAR s: ARRAY 16 OF CHAR; len: INTEGER; BEGIN s := "møøse"; len := LEN(s$); Out.String("s: "); Out.String(s); Out.Ln; Out.String("Length of characters: "); Out.Int(len, 0); Out.Ln END DoCharLength;
END TestLen. </lang>
A symbol $ in LEN(s$) in Component Pascal allows to copy sequence of characters up to null-terminated character. So, LEN(s$) returns a real length of characters instead of allocated by variable.
Running command TestLen.DoCharLength gives following output:
s: møøse Length of characters: 5
Byte Length
<lang oberon2> MODULE TestLen;
IMPORT Out;
PROCEDURE DoByteLength*; VAR s: ARRAY 16 OF CHAR; len, v: INTEGER; BEGIN s := "møøse"; len := LEN(s$); v := SIZE(CHAR) * len; Out.String("s: "); Out.String(s); Out.Ln; Out.String("Length of characters in bytes: "); Out.Int(v, 0); Out.Ln END DoByteLength;
END TestLen. </lang>
Running command TestLen.DoByteLength gives following output:
s: møøse Length of characters in bytes: 10
D
Byte Length
<lang d>string i = readln().chomp(); writefln("Length: ", i.length);</lang>
Character Length
<lang d>string i = readln().chomp(); writefln("Character length: ", i.toUTF32().length);</lang>
E
Character Length
<lang e>"Hello World".size()</lang>
Euphoria
Character Length
<lang Euphoria>print(1,length("Hello World"))</lang>
F#
This is delegated to the standard .Net framework string and encoding functions.
Byte Length
<lang fsharp>open System.Text let byte_length str = Encoding.UTF8.GetByteCount(str)</lang>
Character Length
<lang fsharp>"Hello, World".Length</lang>
Factor
Byte Length
Here are two words to compute the byte length of strings. The first one doesn't allocate new memory, the second one can easily be adapted to measure the byte length of encodings other than UTF8. <lang factor>: string-byte-length ( string -- n ) [ code-point-length ] map-sum ;
- string-byte-length-2 ( string -- n ) utf8 encode length ;</lang>
Character Length
length
works on any sequece, of which strings are one. Strings are UTF8 encoded.
<lang factor>length</lang>
Fantom
Byte length
A string can be converted into an instance of Buf
to treat the string as a sequence of bytes according to a given charset: the default is UTF8, but 16-bit representations can also be used.
<lang fantom> fansh> c := "møøse" møøse fansh> c.toBuf.size // find the byte length of the string in default (UTF8) encoding 7 fansh> c.toBuf.toHex // display UTF8 representation 6dc3b8c3b87365 fansh> c.toBuf(Charset.utf16LE).size // byte length in UTF16 little-endian 10 fansh> c.toBuf(Charset.utf16LE).toHex // display as UTF16 little-endian 6d00f800f80073006500 fansh> c.toBuf(Charset.utf16BE).size // byte length in UTF16 big-endian 10 fansh> c.toBuf(Charset.utf16BE).toHex // display as UTF16 big-endian 006d00f800f800730065 </lang>
Character length
<lang fantom> fansh> c := "møøse" møøse fansh> c.size 5 </lang>
Forth
Byte Length
Strings in Forth come in two forms, neither of which are the null-terminated form commonly used in the C standard library.
Counted string
A counted string is a single pointer to a short string in memory. The string's first byte is the count of the number of characters in the string. This is how symbols are stored in a Forth dictionary.
<lang forth>CREATE s ," Hello world" \ create string "s" s C@ ( -- length=11 ) s COUNT ( addr len ) \ convert to a stack string, described below</lang>
Stack string
A string on the stack is represented by a pair of cells: the address of the string data and the length of the string data (in characters). The word COUNT converts a counted string into a stack string. The STRING utility wordset of ANS Forth works on these addr-len pairs. This representation has the advantages of not requiring null-termination, easy representation of substrings, and not being limited to 255 characters.
<lang forth>S" string" ( addr len) DUP . \ 6</lang>
Character Length
The 1994 ANS standard does not have any notion of a particular character encoding, although it distinguishes between character and machine-word addresses. (There is some ongoing work on standardizing an "XCHAR" wordset for dealing with strings in particular encodings such as UTF-8.)
The following code will count the number of UTF-8 characters in a null-terminated string. It relies on the fact that all bytes of a UTF-8 character except the first have the the binary bit pattern "10xxxxxx".
<lang forth>2 base !
- utf8+ ( str -- str )
begin char+ dup c@ 11000000 and 10000000 <> until ;
decimal</lang>
<lang forth>: count-utf8 ( zstr -- n )
0 begin swap dup c@ while utf8+ swap 1+ repeat drop ;</lang>
Go
Byte Length
<lang go>package main import "fmt" func main() {
s := "møøse" fmt.Println(len(s)) // => 7
}</lang>
Character Length
<lang go>package main import "fmt" import "utf8" func main() {
s := "møøse" fmt.Println(utf8.RuneCountInString(s)) // => 5
}</lang> or <lang go>package main import "fmt" func main() {
s := "møøse" fmt.Println(len([]int(s))) // => 5
}</lang>
Groovy
Calculating "Byte-length" (by which one typically means "in-memory storage size in bytes") is not possible through the facilities of the Groovy language alone. Calculating "Character length" is built into the Groovy extensions to java.lang.String.
Character Length
<lang groovy>println "Hello World!".size()</lang>
Output:
12
Note: The Java "String.length()" method also works in Groovy, but "size()" is consistent with usage in other sequential or composite types.
Haskell
Byte Length
It is not possible to determine the "byte length" of an ordinary string, because in Haskell, a string is a boxed list of unicode characters. So each character in a string is represented as whatever the compiler considers as the most efficient representation of a cons-cell and a unicode character, and not as a byte.
For efficient storage of sequences of bytes, there's Data.ByteString, which uses Word8 as a base type. Byte strings have an additional Data.ByteString.Char8 interface, which will truncate each Unicode Char to 8 bits as soon as it is converted to a byte string. However, this is not adequate for the task, because truncation simple will garble characters other than Latin-1, instead of encoding them into UTF-8, say.
There are several (non-standard, so far) Unicode encoding libraries available on Hackage. As an example, we'll use encoding-0.2, as Data.Encoding:
<lang haskell>import Data.Encoding import Data.ByteString as B
strUTF8 :: ByteString strUTF8 = encode UTF8 "Hello World!"
strUTF32 :: ByteString strUTF32 = encode UTF32 "Hello World!"
strlenUTF8 = B.length strUTF8 strlenUTF32 = B.length strUTF32</lang>
Character Length
The base type Char defined by the standard is already intended for (plain) Unicode characters.
<lang haskell>strlen = length "Hello, world!"</lang>
HicEst
<lang hicest>LEN("1 character == 1 byte") ! 21</lang>
Icon and Unicon
Character Length
<lang Icon> length := *s</lang>
Note: Neither Icon nor Unicon currently supports double-byte character sets.
IDL
Byte Length
Compiler: any IDL compiler should do
<lang idl>length = strlen("Hello, world!")</lang>
Character Length
<lang idl>length = strlen("Hello, world!")</lang>
Io
Byte Length
<lang io>"møøse" sizeInBytes</lang>
Character Length
<lang io>"møøse" size</lang>
J
Byte Length
<lang j> # 'møøse' 7</lang> Here we use the default encoding for character literals (8 bit wide literals).
Character Length
<lang j> #7 u: 'møøse' 5</lang> Here we have used 16 bit wide character literals. See also the dictionary page for u:.
Java
Byte Length
Java encodes strings in UTF-16, which represents each character with one or two 16-bit values. The length method of String objects returns the number of 16-bit values used to encode a string, so the number of bytes can be determined by doubling that number.
<lang java5>String s = "Hello, world!"; int byteCount = s.length() * 2;</lang>
Another way to know the byte length of a string is to explicitly specify the charset we desire.
<lang java5>String s = "Hello, world!"; int byteCountUTF16 = s.getBytes("UTF-16").length; int byteCountUTF8 = s.getBytes("UTF-8").length;</lang>
Character Length
Java encodes strings in UTF-16, which represents each character with one or two 16-bit values. The most commonly used characters are represented by one 16-bit value, while rarer ones like some mathematical symbols are represented by two.
The length method of String objects gives the number of 16-bit values used to encode a string. <lang java5>String s = "Hello, world!"; int length = s.length();</lang>
Since Java 1.5, the actual number of characters can be determined by calling the codePointCount method. <lang java5>String str = "\uD834\uDD2A"; //U+1D12A int length1 = str.length(); //2 int length2 = str.codePointCount(0, str.length()); //1</lang>
JavaScript
Byte Length
JavaScript encodes strings in UTF-16, which represents each character with one or two 16-bit values. The length property of string objects gives the number of 16-bit values used to encode a string, so the number of bytes can be determined by doubling that number.
<lang javascript>var s = "Hello, world!"; var byteCount = s.length * 2; //26</lang>
Character Length
JavaScript encodes strings in UTF-16, which represents each character with one or two 16-bit values. The most commonly used characters are represented by one 16-bit value, while rarer ones like some mathematical symbols are represented by two.
JavaScript has no built-in way to determine how many characters are in a string. However, if the string only contains commonly used characters, the number of characters will be equal to the number of 16-bit values used to represent the characters. <lang javascript>var str1 = "Hello, world!"; var len1 = str1.length; //13
var str2 = "\uD834\uDD2A"; //U+1D12A represented by a UTF-16 surrogate pair var len2 = str2.length; //2</lang>
JudoScript
Byte Length
<lang judoscript>//Store length of hello world in length and print it . length = "Hello World".length();</lang>
Character Length
<lang judoscript>//Store length of hello world in length and print it . length = "Hello World".length()</lang>
LabVIEW
Byte Length
LabVIEW is using a special variant of UTF-8, so byte length == character length.
Character Length
Liberty BASIC
See BASIC
Logo
Logo is so old that only ASCII encoding is supported. Modern versions of Logo may have enhanced character set support. <lang logo>print count "|Hello World| ; 11 print count "møøse ; 5 print char 248 ; ø - implies ISO-Latin character set</lang>
LSE64
Byte Length
LSE stores strings as arrays of characters in 64-bit cells plus a count. <lang lse64>" Hello world" @ 1 + 8 * , # 96 = (11+1)*(size of a cell) = 12*8</lang>
Character Length
LSE uses counted strings: arrays of characters, where the first cell contains the number of characters in the string. <lang lse64>" Hello world" @ , # 11</lang>
Lua
In Lua, a character is always the size of one byte so there is no difference between byte length and character length.
Byte Length
<lang lua>str = "Hello world" length = #str</lang>
or
<lang lua>str = "Hello world" length = string.len(str)</lang>
Character Length
<lang lua>str = "Hello world" length = #str</lang>
or
<lang lua>str = "Hello world" length = string.len(str)</lang>
Mathematica
Character length
<lang mathematica>StringLength["Hello world"]</lang>
Byte length
<lang mathematica>StringByteCount["Hello world"]</lang>
MATLAB
Character Length
<lang MATLAB>>> length('møøse')
ans =
5</lang>
Byte Length
MATLAB apparently encodes strings using UTF-16. <lang MATLAB>>> numel(dec2hex('møøse'))
ans =
10</lang>
MAXScript
Character Length
<lang maxscript>"Hello world".count</lang>
Metafont
Metafont has no way of handling properly encodings different from ASCII. So it is able to count only the number of bytes in a string.
<lang metafont>string s; s := "Hello Moose"; show length(s); % 11 (ok) s := "Hello Møøse"; show length(s); % 13 (number of bytes when the string is UTF-8 encoded,
% since ø takes two bytes)</lang>
Note: in the lang tag, Møøse is Latin1-reencoded, showing up two bytes (as Latin1) instead of one
mIRC Scripting Language
Byte Length
<lang mirc>alias stringlength { echo -a Your Name is: $len($$?="Whats your name") letters long! }</lang>
Character Length
$utfdecode() converts an UTF-8 string to the locale encoding, with unrepresentable characters as question marks. Since mIRC is not yet fully Unicode aware, entering Unicode text trough a dialog box will automatically convert it to ASCII. <lang mirc>alias utf8len { return $len($utfdecode($1)) } alias stringlength2 {
var %name = Børje echo -a %name is: $utf8len(%name) characters long!
}</lang>
Modula-3
Byte Length
<lang modula3>MODULE ByteLength EXPORTS Main;
IMPORT IO, Fmt, Text;
VAR s: TEXT := "Foo bar baz";
BEGIN
IO.Put("Byte length of s: " & Fmt.Int((Text.Length(s) * BYTESIZE(s))) & "\n");
END ByteLength.</lang>
Character Length
<lang modula3>MODULE StringLength EXPORTS Main;
IMPORT IO, Fmt, Text;
VAR s: TEXT := "Foo bar baz";
BEGIN
IO.Put("String length of s: " & Fmt.Int(Text.Length(s)) & "\n");
END StringLength.</lang>
Nemerle
Both examples rely on .Net faculties, so they're almost identical to C#
Character Length
<lang Nemerle>def message = "How long am I anyways?"; def charlength = message.Length;</lang>
Byte Length
<lang Nemerle>using System.Text;
def message = "How long am I anyways?"; def bytelength = Encoding.Unicode.GetByteCount(message);</lang>
Oberon-2
Byte Length
<lang oberon2>MODULE Size;
IMPORT Out;
VAR s: LONGINT; string: ARRAY 5 OF CHAR;
BEGIN
string := "Foo"; s := LEN(string); Out.String("Size: "); Out.LongInt(s,0); Out.Ln;
END Size.</lang>
Output:
Size: 5
Character Length
<lang oberon2>MODULE Length;
IMPORT Out, Strings;
VAR l: INTEGER; string: ARRAY 5 OF CHAR;
BEGIN
string := "Foo"; l := Strings.Length(string); Out.String("Length: "); Out.Int(l,0); Out.Ln;
END Length.</lang>
Output:
Length: 3
Objective-C
In order to be not ambiguous about the encoding used in the string, we explicitly provide it in UTF-8 encoding. The string is "møøse" (ø UTF-8 encoded is in hexadecimal C3 B8).
Character Length
<lang objc>// Return the length in characters unsigned int numberOfCharacters = [@"møøse" length]; // 5</lang>
Byte Length
<lang objc>// Return the number of bytes depending on the encoding, // here explicitly UTF-8 unsigned numberOfBytes =
[@"møøse" lengthOfBytesUsingEncoding: NSUTF8StringEncoding]; // 7</lang>
Objeck
All character string elements are 1-byte in size therefore a string's byte size and length are the same.
Character Length
<lang objeck> "Foo"->Size()->PrintLine(); </lang>
Byte Length
<lang objeck> "Foo"->Size()->PrintLine(); </lang>
OCaml
In OCaml currently, characters inside the standard type string are bytes, and a single character taken alone has the same binary representation as the OCaml int (which is equivalent to a C long) which is a machine word.
For internationalization there is Camomile, a comprehensive Unicode library for OCaml. Camomile provides Unicode character type, UTF-8, UTF-16, and more...
Byte Length
Standard OCaml strings are classic ASCII ISO 8859-1, so the function String.length returns the byte length which is the character length in this encoding: <lang ocaml>String.length "Hello world" ;;</lang>
Character Length
While using the UTF8 module of Camomile the byte length of an utf8 encoded string will be get with String.length and the character length will be returned by UTF8.length: <lang ocaml>String.length "møøse" UTF8.length "møøse"</lang>
Octave
<lang octave>s = "string"; stringlen = length(s)</lang>
This gives the number of bytes, not of characters. e.g. length("è") is 2 when "è" is encoded e.g. as UTF-8.
OpenEdge/Progress
The codepage can be set independently for input / output and internal operations. The following examples are started from an iso8859-1 session and therefore need to use fix-codepage to adjust the string to utf-8.
Character Length
<lang progress>DEF VAR lcc AS LONGCHAR.
FIX-CODEPAGE( lcc ) = "UTF-8". lcc = "møøse".
MESSAGE LENGTH( lcc ) VIEW-AS ALERT-BOX.</lang>
Byte Length
<lang progress>DEF VAR lcc AS LONGCHAR.
FIX-CODEPAGE( lcc ) = "UTF-8". lcc = "møøse".
MESSAGE LENGTH( lcc, "RAW" ) VIEW-AS ALERT-BOX.</lang>
Oz
Byte Length
<lang oz>{Show {Length "Hello World"}}</lang> Oz uses a single-byte encoding by default. So for normal strings, this will also show the correct character length.
PARI/GP
Character Length
Characters = bytes in Pari; the underlying strings are C strings interpreted as US-ASCII. <lang parigp>len(s)=#s; \\ Alternately, len(s)=length(s); or even len=length;</lang>
Byte Length
This works on objects of any sort, not just strings, and includes overhead. <lang parigp>len(s)=sizebyte(s);</lang>
Perl
Byte Length
Strings in Perl consist of characters. Measuring the byte length therefore requires conversion to some binary representation (called encoding, both noun and verb).
<lang perl>use utf8; # so we can use literal characters like ☺ in source use Encode qw(encode);
print length encode 'UTF-8', "Hello, world! ☺";
- 17. The last character takes 3 bytes, the others 1 byte each.
print length encode 'UTF-16', "Hello, world! ☺";
- 32. 2 bytes for the BOM, then 15 byte pairs for each character.</lang>
Character Length
<lang perl>my $length = length "Hello, world!";</lang>
Perl 6
Byte Length
<lang perl>say "møøse".utf8.bytes;</lang>
Character Length
<lang perl>say "møøse".chars;</lang>
PHP
Byte Length
<lang php>$length = strlen('Hello, world!');</lang>
Character Length
<lang php>$length = mb_strlen('Hello, world!', 'UTF-8'); // or whatever encoding</lang>
PicoLisp
<lang PicoLisp>(let Str "møøse"
(prinl "Character Length of \"" Str "\" is " (length Str)) (prinl "Byte Length of \"" Str "\" is " (size Str)) )</lang>
Output:
Character Length of "møøse" is 5 Byte Length of "møøse" is 7 -> 7
PL/I
<lang PL/I> declare WS widechar (13) initial ('Hello world.'); put ('Character length=', length (WS)); put skip list ('Byte length=', size(WS));
declare SM graphic (13) initial ('Hello world'); put ('Character length=', length(SM)); put skip list ('Byte length=', size(trim(SM)); </lang>
PL/SQL
Byte Length
<lang plsql>DECLARE
string VARCHAR2( 50 ) := 'Hello, world!'; stringlength NUMBER;
BEGIN
stringlength := LENGTHB( string );
END;</lang>
Character Length
<lang plsql>DECLARE
string VARCHAR2( 50 ) := 'Hello, world!'; stringlength NUMBER;
BEGIN
stringlength := length( string );
END;</lang>
Pop11
Byte Length
Currently Pop11 supports only strings consisting of 1-byte units. Strings can carry arbitrary binary data, so user can for example use UTF-8 (however builtin procedures will treat each byte as a single character). The length function for strings returns length in bytes:
<lang pop11>lvars str = 'Hello, world!'; lvars len = length(str);</lang>
PostScript
Character Length
<lang> (Hello World) length = 11 </lang>
PowerShell
Character Length
<lang powershell>$s = "Hëlló Wørłð" $s.Length</lang>
Byte Length
For UTF-16, which is the default in .NET and therefore PowerShell: <lang powershell>$s = "Hëlló Wørłð" [System.Text.Encoding]::Unicode.GetByteCount($s)</lang> For UTF-8: <lang powershell>[System.Text.Encoding]::UTF8.GetByteCount($s)</lang>
PureBasic
Character Length
<lang PureBasic> a = Len("Hello World") ;a will be 11</lang>
Byte Length
Returns the number of bytes required to store the string in memory in the given format in bytes. 'Format' can be #PB_Ascii, #PB_UTF8 or #PB_Unicode. PureBasic code can be compiled using either Unicode (2-byte) or Ascii (1-byte) encodings for strings. If 'Format' is not specified, the mode of the executable (unicode or ascii) is used.
Note: The number of bytes returned does not include the terminating Null-Character of the string. The size of the Null-Character is 1 byte for Ascii and UTF8 mode and 2 bytes for Unicode mode.
<lang PureBasic>a = StringByteLength("ä", #PB_UTF8) ;a will be 2 b = StringByteLength("ä", #PB_Ascii) ;b will be 1 c = StringByteLength("ä", #PB_Unicode) ;c will be 2 </lang>
Python
2.x
In Python 2.x, there are two types of strings: regular (8-bit) strings, and Unicode strings. Unicode string literals are prefixed with "u".
Byte Length
For 8-bit strings, the byte length is the same as the character length:
>>> len('ascii') 5
For Unicode strings, byte length depends on the encoding. Python use 2 or 4 bytes per character internally for unicode strings, depending on how it was built. The internal representation is not interesting for the user.
# The letter Alef >>> len(u'\u05d0'.encode('utf-8')) 2 >>> len(u'\u05d0'.encode('iso-8859-8')) 1
Example from the problem statement: <lang python>#!/bin/env python
- -*- coding: UTF-8 -*-
s = u"møøse" assert len(s) == 5 assert len(s.encode('UTF-8')) == 7 assert len(s.encode('UTF-16')) == 12 # The extra character is probably a leading Unicode byte-order mark (BOM).</lang>
Character Length
len() returns the number of characters in a unicode string or plain ascii string. To get the length of encoded string, you have to decode it first:
>>> len('ascii') 5 >>> len(u'\u05d0') # the letter Alef as unicode literal 1 >>> len('\xd7\x90'.decode('utf-8')) # Same encoded as utf-8 string 1
3.x
In Python 3.x, strings are Unicode strings.
Byte Length
Byte length depends on the encoding. Python use 2 or 4 bytes per character internally for unicode strings, depending on how it was built. The internal representation is not interesting for the user.
You can use len() to get the length of a byte sequence. To get a byte sequence from a string, you have to encode it with the desired encoding:
# The letter Alef >>>f1 = " abc1234" >>> len( f1)
Character Length
len() returns the number of characters in a string. To get the length of an encoded byte sequence, you have to decode it first:
>>> len('ascii') 5 >>> len('\u05d0') # the letter Alef as unicode literal 1 >>> len(b'\xd7\x90'.decode('utf-8')) # Same encoded as utf-8 byte sequence 1
R
Byte length
<lang R>a <- "m\u00f8\u00f8se" print(nchar(a, type="bytes")) # print 7</lang>
Character length
<lang R>print(nchar(a, type="chars")) # print 5</lang>
REBOL
Byte Length
REBOL 2.x does not natively support UCS (Unicode), so character and byte length are the same. See utf-8.r for an external UTF-8 library.
<lang REBOL>text: "møøse" print rejoin ["Byte length for '" text "': " length? text]</lang>
Output:
Byte length for 'møøse': 5
Retro
Byte Length
<lang Retro>"møøse" getLength putn</lang>
Character Length
Retro does not have built-in support for Unicode, but counting of characters can be done with a small amount of effort.
<lang Retro>chain: UTF8' {{
: utf+ ( $-$ ) [ 1+ dup @ %11000000 and %10000000 = ] while ;
: count ( $-$ ) 0 !here repeat dup @ 0; drop utf+ here ++ again ;
---reveal---
: getLength ( $-n ) count drop @here ;
}}
- chain
"møøse" ^UTF8'getLength putn</lang>
REXX
<lang REXX> sss='123456789abcdef' say 'the length of sss is:' length(sss) </lang> Output:
the length of sss is: 15
Ruby
<lang ruby># Ruby 1.8: this is byte length
- Ruby 1.9: this is character length
puts "Hello World".length
- => 11</lang>
A string is a sequence of bytes. In Ruby 1.8, strings have no encodings, so String#length is the byte length. In Ruby 1.9, the String class learned about encodings and multibyte characters, so String#length is the character length.
Byte Length
<lang ruby>puts "Hello World".bytesize
- => 11</lang>
String#bytesize is a new method in Ruby 1.8.7.
In Ruby 1.8.7, String#bytesize and String#length are alike: they both return the byte length. But in Ruby 1.9, String#bytesize returns the byte length and String#length returns the character length.
Character Length
In both Ruby 1.8 and Ruby 1.9, the regular expressions know three ways to encode Japanese kanji.
- /./n uses no multibyte encoding.
- /./e uses EUC-JP.
- /./s uses Shift-JIS (but it really uses code page 932, an extension of Shift-JIS).
- /./u uses UTF-8.
String#scan(/./u) returns an array of UTF-8 characters, then Array#length counts the characters. Alternatively, String#gsub(/./u, '.') replaces each UTF-8 character with an ASCII '.', then String#length counts the ASCII characters.
<lang ruby>puts "Hello World".scan(/./u).length
- => 11
puts "Hello World".gsub(/./u, '.').length
- => 11</lang>
There are also some libraries that know about multibyte characters. How to get the character length depends on the library.
<lang ruby>require 'active_support' puts "Hello World".chars.length</lang>
Ruby 1.8 and 1.9
The next example works with both Ruby 1.8 and Ruby 1.9. It shows the byte length and character length of 文字化け in three different encodings. (To run each example, you must copy it to a file and save it with the correct encoding. The magic comment "-*- coding: cp932 -*-" tells Emacs to save a file with that coding.)
Program | Output |
---|---|
<lang ruby># -*- coding: cp932 -*-
s = "文字化け" puts "Byte length: %d" % s.unpack("C*").length puts "Character length: %d" % s.scan(/./s).length</lang> |
Byte length: 8 Character length: 4 |
<lang ruby># -*- coding: euc-jp -*-
s = "文字化け" puts "Byte length: %d" % s.unpack("C*").length puts "Character length: %d" % s.scan(/./e).length</lang> |
Byte length: 8 Character length: 4 |
<lang ruby># -*- coding: utf-8 -*-
s = "文字化け" puts "Byte length: %d" % s.unpack("C*").length puts "Character length: %d" % s.scan(/./u).length</lang> |
Byte length: 12 Character length: 4 |
Ruby 1.9 only
The next examples show the byte length and character length of "møøse" in different encodings. (To run each example, you must copy it to a file and save it with the correct encoding.)
Program | Output |
---|---|
<lang ruby># -*- coding: iso-8859-1 -*-
s = "møøse" puts "Byte length: %d" % s.bytesize puts "Character length: %d" % s.length</lang> |
Byte length: 5 Character length: 5 |
<lang ruby># -*- coding: utf-8 -*-
s = "møøse" puts "Byte length: %d" % s.bytesize puts "Character length: %d" % s.length</lang> |
Byte length: 7 Character length: 5 |
<lang ruby># -*- coding: gb18030 -*-
s = "møøse" puts "Byte length: %d" % s.bytesize puts "Character length: %d" % s.length</lang> |
Byte length: 11 Character length: 5 |
Ruby 1.9 uses a magic comment like "coding: utf-8" to decide the encoding. (The extra "-*-" are only for Emacs.) A string literal like "møøse" gets this encoding. If there is no magic comment, then the default encoding is "us-ascii", and a literal "møøse" is a syntax error.
If you enter a string literal in irb, then the default encoding varies by system, but is "utf-8" on some systems.
Scheme
Byte Length
string-size function is only Gauche function. <lang scheme>(string-size "Hello world")</lang>
<lang scheme>(bytes-length #"Hello world")</lang>
Character Length
string-length function is in R5RS, R6RS. <lang scheme> (string-length "Hello world")</lang>
Seed7
Character Length
<lang seed7>length("Hello, world!")</lang>
Slate
<lang slate>'Hello, world!' length.</lang>
Smalltalk
Byte Length
<lang smalltalk>string := 'Hello, world!'. string size.</lang>
Character Length
In GNU Smalltalk:
<lang smalltalk>string := 'Hello, world!'. string numberOfCharacters.</lang>
requires loading the Iconv package:
<lang smalltalk>PackageLoader fileInPackage: 'Iconv'</lang>
SNOBOL4
Byte Length
<lang snobol4> output = "Byte length: " size(trim(input)) end </lang>
Character Length
The example works AFAIK only with CSnobol4 by Phil Budne <lang snobol4> -include "utf.sno" output = "Char length: " utfsize(trim(input)) end </lang>
Standard ML
Byte Length
<lang sml>val strlen = size "Hello, world!";</lang>
Character Length
<lang sml>val strlen = size "Hello, world!";</lang>
Tcl
Byte Length
Formally, Tcl does not guarantee to use any particular representation for its strings internally (the underlying implementation objects can hold strings in at least three different formats, mutating between them as necessary) so to way to calculate the "byte length" of a string can only be done with respect to some user-selected encoding. This is done this way (for UTF-8): <lang tcl>string length [encoding convertto utf-8 $theString]</lang> Thus, we have these examples: <lang tcl>set s1 "hello, world" set s2 "\u304A\u306F\u3088\u3046" set enc utf-8 puts [format "length of \"%s\" in bytes is %d" \
$s1 [string length [encoding convertto $enc $s1]]]
puts [format "length of \"%s\" in bytes is %d" \
$s2 [string length [encoding convertto $enc $s2]]]</lang>
Character Length
Basic version:
<lang tcl>string length "Hello, world!"</lang>
or more elaborately, needs Interpreter any 8.X. Tested on 8.4.12.
<lang tcl>fconfigure stdout -encoding utf-8; #So that Unicode string will print correctly set s1 "hello, world" set s2 "\u304A\u306F\u3088\u3046" puts [format "length of \"%s\" in characters is %d" $s1 [string length $s1]] puts [format "length of \"%s\" in characters is %d" $s2 [string length $s2]]</lang>
TI-89 BASIC
The TI-89 uses an fixed 8-bit encoding so there is no difference between character length and byte length.
<lang ti89b>■ dim("møøse") 5</lang>
Toka
Byte Length
<lang toka>" hello, world!" string.getLength</lang>
Trith
Character Length
<lang trith>"møøse" length</lang>
Byte Length
<lang trith>"møøse" size</lang>
UNIX Shell
Byte Length
With external utilities:
<lang bash>string='Hello, world!' length=`printf '%s' "$string" | wc -c | tr -dc '0-9'` echo $length # if you want it printed to the terminal</lang>
<lang bash>string='Hello, world!' length=`expr "x$string" : '.*' - 1` echo $length # if you want it printed to the terminal</lang>
With SUSv3 parameter expansion modifier:
<lang bash>string='Hello, world!' length="${#string}" echo $length # if you want it printed to the terminal</lang>
VBScript
Byte Length
<lang vbscript>LenB(string|varname)</lang>
Returns the number of bytes required to store a string in memory. Returns null if string|varname is null.
Character Length
<lang vbscript>Len(string|varname)</lang>
Returns the length of the string|varname . Returns null if string|varname is null.
x86 Assembly
Byte Length
<lang x86 Assembly> .data string: .asciz "Test"
.text .globl main
main:
pushl %ebp movl %esp, %ebp
pushl %edi xorb %al, %al movl $-1, %ecx movl $string, %edi cld repne scasb not %ecx dec %ecx popl %edi
;; string lenght is stored into %ecx register
leave ret
</lang> Using AT & T syntax with AS (the portable GNU assembleur) under linux.
XSLT
Character Length
<lang xml><?xml version="1.0" encoding="UTF-8"?></lang>
...
<lang xml><xsl:value-of select="string-length('møøse')" /> </lang>
xTalk
Byte Length
<lang xtalk>put the length of "Hello World"</lang>
or
<lang xtalk>put the number of characters in "Hello World"</lang>
Character Length
<lang xtalk>put the length of "Hello World"</lang>
or
<lang xtalk>put the number of characters in "Hello World"</lang>
Yorick
Character Length
<lang yorick>strlen("Hello, world!")</lang>
- Programming Tasks
- Basic language learning
- 4D
- ActionScript
- Ada
- ALGOL 68
- AppleScript
- AppleScript examples needing attention
- Examples needing attention
- AutoHotkey
- AWK
- Batch File
- BASIC
- ZX Spectrum Basic
- BBC BASIC
- C
- C++
- C sharp
- Clean
- Clojure
- ColdFusion
- ColdFusion examples needing attention
- Common Lisp
- Component Pascal
- D
- E
- Euphoria
- F Sharp
- Factor
- Fantom
- Forth
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- IDL
- IDL examples needing attention
- Io
- J
- Java
- JavaScript
- JudoScript
- JudoScript examples needing attention
- LabVIEW
- Liberty BASIC
- Logo
- LSE64
- Lua
- Mathematica
- MATLAB
- MAXScript
- Metafont
- MIRC Scripting Language
- MIRC Scripting Language examples needing attention
- Modula-3
- Nemerle
- Oberon-2
- Objective-C
- Objeck
- OCaml
- Octave
- OpenEdge/Progress
- Oz
- PARI/GP
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- PL/SQL
- PL/SQL examples needing attention
- Pop11
- PostScript
- PowerShell
- PureBasic
- Python
- R
- REBOL
- Retro
- REXX
- Ruby
- Active support
- Scheme
- Seed7
- Slate
- Smalltalk
- SNOBOL4
- Standard ML
- Standard ML examples needing attention
- Tcl
- TI-89 BASIC
- Toka
- Trith
- UNIX Shell
- VBScript
- X86 Assembly
- XSLT
- XTalk
- XTalk examples needing attention
- Yorick
- String manipulation