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)

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

<br><br>

 

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

(coerce '(#\s #\t #\r #\i #\n #\g) '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:

pStr + '.' + pAux:>First string.Second String

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

Note: Elixir data types are immutable.

x = "hello world"

 

b = "lo w"

c = "orld"

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

 

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

 

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)

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

s := &null # destroy a string (garbage collect value of s; set new value to &null)

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

 

import java.nio.charset.StandardCharsets;

import java.util.Arrays;

return index;

}

 

Test code:

 

 

import java.nio.charset.StandardCharsets;

Assert.assertThat(str.regionEquals(0, new MutableByteString(new byte[]{'h'}), 0, 2), is(false));

}

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

{{trans|MATLAB}}

# String assignment. Creation and garbage collection are automatic.

a = "123\x00 abc " # strings can contain bytes that are not printable in the local font

d = a * b * c

println(d)

{{output}}<pre>

123 abc

123 abc d456 789

</pre>

=={{header|Kotlin}}==

Strings in Kotlin are sequences of 16-bit unicode characters and have a lot of functions built-in, including all those required by this task.

 

The implementation is not intended to be particularly efficient as I've sometimes delegated to the corresponding String class functions in the interests of both simplicity and brevity. Moreover, when Java 9's 'compact strings' feature is implemented, it won't even save memory as Strings which don't contain characters with code-points above 255 are apparently going to be flagged and stored internally as arrays of single bytes by the JVM, not arrays of 2 byte characters as at present.

val length get() = bytes.size

 

println("ABCDEF with CD replaced by GH is ${bs3.replace("CD".bs, "GH".bs)}")

println("GHI£€ as a ByteString is $bs4")

 

{{out}}

GHI£€ as a ByteString is GHI£?

</pre>

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

foo = "Hello world!" -- created by assignment; destruction via garbage collection

 

foo = "Hello" & numtochar(32) & "world!"

foo = "Hello" & SPACE & "world!"

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

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 + '?';

=={{header|Perl}}==

Effective string manipulation has been a part of Perl since the beginning. Simple stuff is simply done, but modern Perl also supports Unicode, and tools like <code>pack/unpack</code> let you operate on strings below the level of bytes.

say 'Nothing to see here' if ! defined $s; # 'Nothing to see here'

say $s = ''; # ''

$t =~ s/ee/ook/; say $t; # 'bookkeeper'

say $u = substr $t, 2, 2; # 'ok'

=={{header|Phix}}==

The native string type in Phix can be used to store raw binary data and supports all of the operations mentioned in this task.

Strings are reference counted, and mutable with copy-on-write semantics. Memory is managed automatically and very efficiently, strings can easily be a billion characters long (on 32-bit, the precise limit is in fact 1,610,612,711 characters, available memory and performance impacts aside) and have a null terminator for C compatibility, but can contain embedded nulls as well.

Note that attempting to set an element (character/byte) to a value outside the range 0..255 will result in automatic expansion to dword-(or qword-)sequence, and can result in a run-time type check.

{{out}}

<pre>

"abc\ndef\nghi"

</pre>

 

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

Clear-Host

 

Write-Host '1..12 | Format-Wide {$_.ToString().PadLeft(2)}-Column 3 -Force' -NoNewline -ForegroundColor Yellow

1..12 | Format-Wide {$_.ToString().PadLeft(2)} -Column 3 -Force

{{Out}}

<pre>

10 11 12

</pre>

=={{header|Prolog}}==

 

?- X = "a test string".

X = "a test string".

Y = " with extra!",

Z = "a test string with extra!".

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

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2018.03}}

my Str $s = 'nema' ~ 0.chr ~ 'problema!';

say $s;

 

# (i.e. sequences of characters), like your name, or …

my Str $str = "My God, it's full of chars!";

# joining:

my ByteStr $b3 = $b1 ~ $sub;

 

{{out}}

replaced = [103 0 0 0 10 98 97 114 123]

joined = [103 0 0 0 10 98 97 114 123 0 0 10 98]</pre>

=={{header|Red}}==

s: copy "abc" ;; string creation

 

s: rejoin ["hello " "world" " !"] ;; join multiple strings

?? s

{{out}}

<pre>equal (case insensitive)

>>

</pre>

=={{header|REXX}}==

dingsta= '11110101'b /*four versions, bit string assignment.*/

dingsta= "11110101"b /*this is the same assignment as above.*/

tt= changeStr('~~', other, ";") /*change two tildes ──► one semicolon.*/

joined= dingsta || dingsta2 /*join two strings together (concat). */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>

 

=={{header|Ring}}==

The String in the Ring programming language holds and manipulates an arbitrary sequence of bytes.

 

x = "hello world"

c = "orld"

See a + b + c

 

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

For extra documentation, refer to [https://doc.rust-lang.org/std/string/struct.String.html] and [https://doc.rust-lang.org/book/strings.html].

 

fn main() {

let split_str: Vec<_> = f_str.split(' ').collect();

assert_eq!(split_str, ["Pooja", "and", "Sundar", "are", "up", "in", "Tumkur"], "Error in string split");

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

Before start, see this link :

The default text comparison method is Binary.

</pre>

'Set the string comparison method to Binary.

Option Compare Binary ' That is, "AAA" is less than "aaa".

' Set the string comparison method to Text.

String creation and destruction :

Sub Creation_String_FirstWay()

Dim myString As String

'Here, myString is created and equal ""

String assignment :

Dim myString$

'Here, myString is created and equal ""

myString = "Hello World" 'return : "Hello World"

myString = String(12, "A") 'return : "AAAAAAAAAAAA"

String comparison :

Dim A$, B$, C$

 

'See Also :

'https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/operators/like-operator

String cloning and copying :

Dim A As String, B$

A = "Hello world!"

'cloning :

B = A

Check if a string is empty :

Dim A As String, B As Variant

 

Debug.Print A = "" 'return True

'Note : StrPtr is the only way to know if you cancel the inputbox

Append a byte to a string :

Dim A As String

A = "Hello worl"

Debug.Print A & Chr(100) 'return : Hello world

Extract a substring from a string :

Dim A$, B As String

A = "Hello world"

B = Mid(A, 3, 8)

Debug.Print B 'return : llo worl

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

Dim A$, B As String, C$

A = "Hello world"

C = " "

Debug.Print Replace(A, B, C) 'return : He o wor d

Join Strings :

Dim A$, B As String

 

Debug.Print A + " " + B 'return : Hello world

End Sub

 

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