Binary strings: Difference between revisions

{{task|String manipulation}}

Many languages have powerful and useful ('''binary safe''') [[wp:String (computer science)|string]] [[wp:Comparison of programming languages (string functions)|manipulation functions]], while others don't, making it harder for these languages to accomplish some tasks.

In particular the functions you need to create are:

* String creation and destruction (when needed and if there's no [[garbage collection]] or similar mechanism)

* Join strings

 

Possible contexts of use: compression algorithms (like [[LZW compression]]), L-systems (manipulation of symbols), many more.

=={{header|Ada}}==

Ada has native support for single dimensioned arrays, which provide all specified operations. String is a case of array. The array of bytes is predefined in Ada in the package System.Storage_Elements ([http://www.adaic.org/standards/05rm/html/RM-13-7-1.html LRM 13.7.1]). Storage_Element is substitute for byte.

 

Data : Storage_Array (1..20); -- Data created

begin

... Data & (1,2,3,4) ... -- The result is Data with bytes 1,2,3,4 appended

... Data (3..5) ... -- The result the substring of Data from 3 to 5

Storage_Array is "binary string" used for memory representation. For stream-oriented I/O communication Ada provides alternative "binary string" called Stream_Element_Array ([http://www.adaic.org/standards/05rm/html/RM-13-13-1.html LRM 13.13.1]). When dealing with octets of bits, programmers are encouraged to provide a data type of their own to ensure that the byte is exactly 8 bits length. For example:

for Octet'Size use 8;

Alternatively:

...

type Octet is new Interfaces.Unsigned_8;

Note that all of these types will have all operations described above.

=={{header|ALGOL 68}}==

{{trans|Tcl}}

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards AND formatted transput statements removed) - tested with release 1.8.8d.fc9.i386 - ELLA has no FORMATted transput}} -->

STRING a,b,c,d,e,f,g,h,i,j,l,r;

a := "hello world";

 

# Extract a CHAR from a CPU word #

Output:

<pre>

7th byte in CPU word is: w

</pre>

=={{header|AWK}}==

 

BEGIN {

d=a""b""c;

printf("d=<%s>\n",d);

 

Output:

d=<123 abc @456 789>

</pre>

=={{header|BASIC}}==

 

==={{header|Applesoft BASIC}}===

A$ = "STRING" : REM CREATION

A$ = "" : REM DESTRUCTION

 

REM JOIN STRINGS

 

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

20 LET s$ = "Hello"

30 LET t$ = "Bob"

110 IF s$ = t$ THEN PRINT "Strings are the same"

120 REM print characters 2 to 4 of a string (a substring)

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

B$ = A$ : REM clone / copy

IF A$ = B$ THEN PRINT "Strings are equal" : REM comparison

IF I% MID$(A$, I%, 1) = new$

UNTIL I% = 0

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return 0;

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

{{works with|C sharp|3.0}}

 

 

class Program

Console.WriteLine(join);

}

 

 

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

String creation (garbage collection will handle its destruction)

using the string as an atom and casting a character list to a string

"string"

 

String assignment

(defvar *string* "string")

 

comparing two string

(equal "string" "string")

 

copy a string

(copy-seq "string")

 

(defun string-empty-p (string)

 

(concatenate 'string "string" "b")

 

"ring"

 

string replacement isn't covered by the ansi standard probably best to use (replace-all) or cl-ppcre

 

joining strings works in the same way as appending bytes

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

BlackBox Component Builder

MODULE NpctBinaryString;

IMPORT StdLog,Strings;

END Do;

END NpctBinaryString.

Execute: ^Q NpctBinaryString.Do<br/>

Output:

</pre>

=={{header|D}}==

import std.array: empty, replace;

import std.string: representation, assumeUTF;

// Join two strings.

ubyte[] str3 = str1 ~ str2;

 

=={{header|Déjà Vu}}==

 

Déjà Vu has a <code>blob</code> type, which is much like Python 3's <code>bytearray</code>. They are used for dealing with binary data in the standard library, and works basically like a list, except it can only have integer numbers from 0 to 255 as elements, pushing and popping is not supported, and can be resized to any size in a single step.

 

set-to b 0 255

!. get-from b 0 #prints 255

!. b #prints (blob:"abc")

!. !encode!utf-8 b #prints "abc"

=={{header|E}}==

 

To work with binary strings we must first have a byte type; this is a place where E shows its Java roots (to be fixed).

 

 

<ol>

<li>There are several ways to create a FlexList; perhaps the simplest is:

# value: [].diverge()

 

 

? def bstr2 := [-0x7F,0x2,0x3].diverge(int8)

As E is a memory-safe garbage-collected language there is no explicit destruction. It is good practice to work with immutable ConstLists when reasonable, however; especially when passing strings around.

</li><li>There is no specific assignment between FlexLists; a reference may be passed in the usual manner, or the contents of one could be copied to another as shown below.

</li><li>There is no comparison operation between FlexLists (since it would not be a stable ordering <!-- XXX cite? -->), but there is between ConstLists.

</li><li>To make an independent copy of a FlexList, simply <code>.diverge()</code> it again.

# value: false

 

? bstr.size().isZero()

</li><li>Appending a single element to a FlexList is done by <code>.push(<var>x</var>)</code>:

? bstr

</li><li>Substrings, or ''runs'', are always immutable and specified as start-end indexes (as opposed to first-last or start-count). Or, one can copy an arbitrary portion of one list into another using <code>replace(<var>target range</var>, <var>source list</var>, <var>source range</var>)</code>.

# value: [2]

 

? bstr.replace(0, bstr.size(), bstr2, 1, 3)

? bstr

</li><li>Replacing must be written as an explicit loop; there is no built-in operation (though there is for character strings).

? bstr2

</li><li>Two lists can be concatenated into a ConstList by <code>+</code>: <code>bstr1 + bstr2</code>. <code>append</code> appends on the end of a FlexList, and <code>replace</code> can be used to insert at the beginning or anywhere inside.

? bstr1

</li></ol>

 

=={{header|Erlang}}==

-compile([export_all]).

 

replace(Rest,Value,Replacement,<< Acc/binary, Replacement >>);

replace(<<Keep,Rest/binary>>,Value,Replacement,Acc) ->

{{out}}

Creation: <<0,1,1,2,3,5,8,13>>

Copy: <<0,1,1,2,3,5,8,13>>

Replacement: <<0,42,42,2,3,5,8,13>>

Append: <<0,1,1,2,3,5,8,13,21>>

=={{header|Factor}}==

Factor has a <code>byte-array</code> type which works exactly like other arrays, except only bytes can be stored in it. Comparisons on <code>byte-array</code>s (like comparisons on arrays) are lexicographic.

 

To convert a string to a byte-array:

<pre>

B{

</pre>

Reverse:

<pre>"日本"</pre>

=={{header|Forth}}==

In Forth, as in Assembler, all strings are binary ie: they are simply bytes in memory. <br>

This code is an example of how to create string functions from low-level operations.

<br>

Adding the 256 byte buffer it takes only 560 bytes; useable in small embedded environments.

 

\ Portions of this code are found at http://forth.sourceforge.net/mirror/toolbelt-ext/index.html

 

: STRLEN ( addr -- length) c@ ; \ alias the "character fetch" operator

 

 

: ENDSTR ( str -- addr) \ calculate the address at the end of a string

 

: PLACE ( addr1 len addr2 -- ) \ addr1 and length, placed at addr2 as counted string

 

: STRING, ( addr len -- ) \ compile a string at the next available memory (called 'HERE')

 

: APPEND-CHAR ( char string -- ) \ append char to string

 

: substr ( string1 start length -- strpad) \ Extract a substring of string and return an output string

 

\ COMPARE takes the 4 inputs from the stack (addr1 len1 addr2 len2 )

comparestr 1 = ;

 

 

With the above code compiled into our system, we can test interactively

at the Forth console to see if we have satisfied the Rosetta code requirements

 

 

\ 1. String creation and destruction (when needed and if there's no garbage collection or similar mechanism)

 

\ C, takes a byte off the stack and writes it into the next available memory address

 

HEX ok

 

\ test what we created using the DUMP utility

 

 

string: buffer1 ok

string: buffer2 ok

string1 writestr Now is the time for all good men to come to the aid ok

buffer1 writestr Now is the time for all good men to come to the aid ok

 

 

ok

 

 

=={{header|Go}}==

 

import (

rem := append(append([]byte{}, b[:1]...), b[3:]...)

fmt.Println(string(rem))

{{out}}

<pre>

bary

</pre>

 

=={{header|Haskell}}==

Note that any of the following functions can be assigned

as Haskell can be somewhat intimidating to the (currently) non-

functional programmer.

{- The above import is needed only for the last function.

It is used there purely for readability and conciseness -}

Haskell would be able to figure out the type

of "world" -}

 

returning a boolean result using a

simple conditional -}

if x == y

then True

 

of characters in Haskell, test and

see if the given string is an empty list -}

if x == []

then True

 

append strings, using the built-in

(++) concatenation operator

as typed strings -}

strAppend :: String -> String -> String

 

from the given string -}

strExtract :: Int -> String -> String

 

two integers, from the given string -}

strPull :: Int -> Int -> String -> String

 

and elegant solution. Using an imported standard library

(Text.Regex), replace a given substring with another -}

strReplace :: String -> String -> String -> String

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

Icon and Unicon strings strings are variable length and unrestricted. See [[Logical_operations#Icon_and_Unicon|Logical Operations]] for ways to manipulate strings at the bit level.

s := "abc" # create a string

v := s # assignment

s == t # expression s equals t

t := s[2+:3] # t is set to position 2 for 3 characters

s := replace(s,s2,s3) # IPL replace function

 

The {{libheader|Icon Programming Library}} provides the procedure [http://www.cs.arizona.edu/icon/library/src/procs/strings.icn replace in strings]

local result, i

 

}

 

=={{header|J}}==

J's literal data type supports arbitrary binary data (strings are binary strings by default). J's semantics are pass by value (with garbage collection) with a minor exception (mapped files).

 

* Example binary string creation

 

* Example binary string deletion (removing all references to a string allows it to be deleted, in this case we give the name a numeric value to replace its prior string value):

 

* Example binary string assignment

 

* Example binary string comparison

 

* Example binary string cloning and copying

 

Though, technically, its the internal reference which is cloned, not the internal representation of the value. But operations which modify strings are copy on write, so this distinction is not visible without going outside the language.

 

* Example check if a binary string is empty

 

* Example apppend a byte to a binary string

byte=: DEL

 

* Extract a substring from a binary string

 

* Replace every occurrence of a byte (or a string) in a string with another string

 

* Join strings

 

Note also: given an integer n, the corresponding byte value may be obtained by indexing into <code>a.</code> which is the ordered array of all bytes.:

 

Thus, the binary string containing bytes with numeric values 1 0 255 can be obtained this way:

 

=={{header|JavaScript}}==

 

JavaScript has native support for binary strings. All strings are "binary" and they're not zero terminated; however to be more exact you can't really see the bytes on the string, strings go from Unicode 0 to Unicode FFFF

var str='';

//or

[str," ",str3].join(" "/*this is the character that will glue the strings*/)//we can join an array of strings

str3+str4;

=={{header|jq}}==

 

jq's strings are JSON strings and so cannot be safely used as "binary strings" in the sense of this article. The most convenient way to store a string of bytes in jq is as a jq array of integers, it being understood that jq itself does **not** provide a mechanism for guaranteeing that all the elements of a particular array are integers in the expected range.

 

# then pass it along:

def check_binary:

and 0 <= . and . <= 255) then $a

else error("\(.) is an invalid representation of a byte")

Examples

 

[]

reduce .[] as $byte ([];

if $byte == x then . + a else . + [$byte] end)

 

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

Liberty BASIC's strings are native byte strings. They can contain any byte sequence. They are not zero-terminated. They can be huge in size.

'string creation

s$ = "Hello, world!"

'join strings

s$ = "Good" + "bye" + " for now."

 

=={{header|Lua}}==

bar = 'bar'

assert (foo == "foo") -- Comparing string var to string literal

print (str)

 

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

(* String assignment *) BinaryString1 = {12,56,82,65} , BinaryString2 = {83,12,56,65}

-> {12,56,82,65}

-> {12,56,82,65,33,44}

(* Join strings *) BinaryString4 = Join[BinaryString1 , BinaryString2]

=={{header|MATLAB}} / {{header|Octave}}==

a=['123',0,' abc '];

b=['456',9];

d=[a,b,c];

disp(d);

Output:

<pre>

123 abc @456 789

</pre>

=={{header|Nim}}==

x = "this is a string"

y = "this is another string"

 

echo x[5..8] # substring

 

z = x & y # join strings

import strutils

 

=={{header|OCaml}}==

 

 

<code>String.create n</code> returns a fresh string of length n, which initially contains arbitrary characters:

 

No destruction, OCaml features a garbage collector.

 

* String assignment

val str : string = "some text"

 

(* modifying a character, OCaml strings are mutable *)

# str.[0] <- 'S' ;;

 

* String comparison

- : bool = true

 

# "Hello" > "Ciao" ;;

 

* String cloning and copying

 

* Check if a string is empty

val string_is_empty : string -> bool = <fun>

 

 

# string_is_empty "" ;;

 

* Append a byte to a string

a byte and return the result as a new string

 

 

But OCaml has a module named Buffer for string buffers.

This module implements string buffers that automatically expand as necessary. It provides accumulative concatenation of strings in quasi-linear time (instead of quadratic time when strings are concatenated pairwise).

 

 

* Extract a substring from a string

 

* Replace every occurrence of a byte (or a string) in a string with another string

using the '''Str''' module

# let replace str occ by =

Str.global_replace (Str.regexp_string occ) by str

val replace : string -> string -> string -> string = <fun>

# replace "The white dog let out a single, loud bark." "white" "black" ;;

 

* Join strings

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

This code accepts arbitrary characters, but you can use <code>Strchr</code> to display ASCII strings.

copy_str(v)=v \\ Creates a copy, not a pointer

append_str(v,n)=concat(v,n)

u[8..12]

replace_str(u,108,[121])

{{out}}

<pre>%1 = 0

%6 = [72, 101, 121, 121, 111, 44, 32, 119, 111, 114, 121, 100]

%7 = []</pre>

=={{header|Pascal}}==

Pascal's original strings were limited to 255 characters. Most implementations had the string length in byte 0. Extension exist for longer strings as well as C compatible string terminated by null. See Examples below

greeting = 'Hello';

var

{ Join strings}

s3 := greeting + ' and how are you, ' + s1 + '?';

 

 

 

 

 

 

 

 

 

 

 

 

 

 

{{out}}

=={{header|PicoLisp}}==

Byte strings are represented in PicoLisp as lists of numbers. They can be

I/O of raw bytes is done via the 'wr' (write) and 'rd' (read) functions. The

following creates a file consisting of 256 bytes, with values from 0 to 255:

Looking at a hex dump of that file:

00000000 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ................

00000010 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F ................

00000020 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F !"#$%&'()*+,-./

00000030 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 0123456789:;<=>?

To read part of that file, an external tool like 'dd' might be used:

(make

(while (rd 1)

(link @) ) ) )

Now such byte lists can be assigned the normal way ('let', 'setq' etc.), they

can be compared with '=', '>', '>=' etc, and manipulated with all internal map-,

If desired, a string containing meaningful values can also be converted to

a transient symbol, e.g. the example above

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

/* PL/I has immediate facilities for all those operations except for */

/* replace. */

end;

end replace;

 

=={{header|PureBasic}}==

;string creation

x$ = "hello world"

; join strings

x$ = "hel" + "lo w" + "orld"

=={{header|Python}}==

===2.x===

* String creation

 

s2 = 'You may use any of \' or " as delimiter'

s3 = """This text

goes over several lines

 

* String assignment

There is nothing special about assignments:

 

t = "world!"

 

* String comparison

They're compared byte by byte, lexicographically:

 

assert '\t' == '\x09'

assert "one" < "two"

 

* String cloning and copying

* Check if a string is empty

 

 

* Append a byte to a string

 

txt += '\x07'

 

* Extract a substring from a string

Strings are sequences, they can be indexed with s[index] (index is 0-based) and sliced s[start:stop] (all characters from s[start] up to, but ''not'' including, s[stop])

 

assert txt[4] == " "

assert txt[0:4] == "Some"

assert txt[:4] == "Some" # you can omit the starting index if 0

assert txt[5:9] == "more"

 

Negative indexes count from the end: -1 is the last byte, and so on:

 

assert txt[-1] == "t"

 

* Replace every occurrence of a byte (or a string) in a string with another string

Strings are objects and have methods, like replace:

 

v2 = v1.replace("l", "L")

 

* Join strings

If they're separate variables, use the + operator:

 

v2 = "world"

 

If the elements to join are contained inside any iterable container (e.g. a list)

 

joined = ",".join(items)

print joined

# output:

 

The reverse operation (split) is also possible:

 

fields = line.split(',')

print fields

# output:

 

===3.x===

 

To specify a literal immutable byte string (<code>bytes</code>), prefix a string literal with "b":

s2 = b'You may use any of \' or " as delimiter'

s3 = b"""This text

goes over several lines

 

You can use the normal string escape sequences to encode special bytes.

 

Indexing a byte string results in an integer (the byte value at that byte):

 

Similarly, a byte string can be converted to and from a list of integers:

 

list(x) # evaluates to [97, 98, 99]

=={{header|Racket}}==

 

#lang racket

 

 

(bytes-join (list b2 b3) #" ") ; -> #"BBBBB BAAAA"

 

 

 

 

 

 

 

 

 

 

 

<br><br>

 

=={{header|Ruby}}==

A String object holds and manipulates an arbitrary sequence of bytes. There are also the [http://www.ruby-doc.org/core/classes/Array.html#M002222 Array#pack] and [http://www.ruby-doc.org/core/classes/String.html#M000760 String#unpack] methods to convert data to binary strings.

x = "hello world"

b = "lo w"

c = "orld"

 

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

s$ = "Hello, world"

'join strings

s$ = "See " + "you " + "later."

 

=={{header|Seed7}}==

Seed7 strings are capable to hold binary data.

The [http://seed7.sourceforge.net/libraries/string.htm string.s7i] library contains

more string functions.

=={{header|Smalltalk}}==

Smalltalk strings are variable length and unrestricted. They are builtin and no additional library is req'd.

 

s := #[16r01 16r02 16r00 16r03] asString # strings can contain any value, even nulls

s := String new:3. # a mutable string

s2 := s1 , $x # append a character

s2 := s1 , 123 asCharacter # append an arbitrary byte

 

In addition (because they inherit from collection), a lot more is inherited (map, fold, enumeration, finding substrings, etc.)

=={{header|Tcl}}==

Tcl strings are binary safe, and a binary string is any string that only contains UNICODE characters in the range <tt>\u0000</tt>–<tt>\u00FF</tt>.

set x "hello world"

 

set b "lo w"

set c "orld"

 

=={{header|zkl}}==

Strings in zkl are bytes with a zero terminator. So they are binary safe as long as the data doesn't contain a zero. Data objects are true binary strings: bytes with a length. It is basically a binary editor. Datas come in two flavors: Int and String. The difference is some methods treat String type as containing (zero or more) null terminated strings. Datas have an implicit null terminator so they can easily convert to a String.

Data(0,String,1,2,3) // same

Data(0,Int,"foo","bar") //-->foobar\0

 

d2:=Data(0,Int,"sam");

{{omit from|GUISS}}

{{omit from|Lotus 123 Macro Scripting}}