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>

 

 

#include <stdlib.h>

 

{

 

 

 

 

 

{

 

{

 

{

 

{

 

{

 

{

 

{

 

{

 

{

 

 

 

{

 

}

 

 

 

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

 

 

 

 

 

 

 

 

 

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

# value: false

 

? bstr.size().isZero()

? bstr

# value: [2]

 

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

? bstr

? bstr2

? bstr1

 

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

 

 

 

 

 

 

 

 

 

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

 

* Join strings

 

=={{header|Lua}}==

bar = 'bar'

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

print (str)

 

 

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

 

 

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:

 

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

# string comparison

if x == "hello"

else

puts "not equal"

# append a byte

# substring