Binary strings: Difference between revisions

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

<br><br>

=={{header|11l}}==

print(x[0])</syntaxhighlight>

 

97

</pre>

=={{header|8086 Assembly}}==

The 8086 has built-in support for handling byte and word strings, using <code>DS:SI</code> and <code>ES:DI</code> as the source and destination pointers, respectively. String functions can either auto-increment or auto-decrement the pointers held in these registers; the '''direction flag''' determines which one takes place. (<code>CLD</code> for auto-inc, <code>STD</code> for auto-dec.)

===Copying strings===

This is a "deep copy," i.e. after this you will have a duplicate of the string "Hello" in two separate memory locations, not just a pointer to the original stored elsewhere.

cld

mov si,offset TestMessage

 

===Checking if a particular byte exists===

cld

mov di,offset TestMessage

 

===Compare two strings===

cld

mov si,offset foo

foo byte "test"

bar byte "test"</syntaxhighlight>

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

end; -- Data destructed</syntaxhighlight>

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;

type Octet_String is array (Positive range <>) of Octet;</syntaxhighlight>

Alternatively:

...

type Octet is new Interfaces.Unsigned_8;

type Octet_String is array (Positive range <>) of Octet;</syntaxhighlight>

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";

7th byte in CPU word is: w

</pre>

=={{header|Arturo}}==

 

x: "this is a string"

y: "this is another string"

this is a string!now this is another string too

This is a sTring!now This is anoTher sTring Too</pre>

=={{header|AWK}}==

 

BEGIN {

d=<123 abc @456 789>

</pre>

=={{header|BASIC}}==

 

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

A$ = "STRING" : REM CREATION

A$ = "" : REM DESTRUCTION

==={{header|GW-BASIC}}===

Also works in QBASIC, QuickBASIC, VB-DOS and PDS 7.1

10 ' SAVE"BINSTR", A

20 ' This program does string manipulation

 

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

110 REM create two strings

120 LET S$="Hello":LET T$="Bob"

 

==={{header|OxygenBasic}}===

'STRING CREATION AND DESTRUCTION

string A

 

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

20 LET s$ = "Hello"

30 LET t$ = "Bob"

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

130 PRINT s$(2 TO 4)</syntaxhighlight>

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

B$ = A$ : REM clone / copy

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

UNTIL I% = 0

</syntaxhighlight>

=={{header|BQN}}==

 

 

* Example binary string creation

 

* Example binary string deletion: effectively replaces the data with an integer, removing it from an accessible name.

 

* Example binary string assignment

 

* Example binary string comparison

 

* Example binary string cloning and copying

name2 ← name1</syntaxhighlight>

 

* Example check if a binary string is empty

 

* Example apppend a byte to a binary string

byte ← @

string ∾↩ byte</syntaxhighlight>

 

* Extract a substring from a binary string

 

* Join strings

 

Note also: given an integer n, the corresponding byte value may be added to the null character <code>@</code> to get the character at that codepoint. This works due to BQN's character arithmetic.

 

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

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

return 0;

}</syntaxhighlight>

 

=={{header|C++}}==

#include <iostream>

 

hello

hello world</pre>

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

</syntaxhighlight>

 

comparing two string

(equal "string" "string")

</syntaxhighlight>

 

copy a string

(copy-seq "string")

</syntaxhighlight>

 

(defun string-empty-p (string)

(zerop (length string)))</syntaxhighlight>

 

(concatenate 'string "string" "b")

</syntaxhighlight>

 

(subseq "string" 2 6)

"ring"

 

joining strings works in the same way as appending bytes

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

BlackBox Component Builder

MODULE NpctBinaryString;

IMPORT StdLog,Strings;

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

</pre>

=={{header|D}}==

import std.array: empty, replace;

import std.string: representation, assumeUTF;

ubyte[] str3 = str1 ~ str2;

}</syntaxhighlight>

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|C#}}

program Binary_strings;

 

hello

hello world</pre>

 

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

 

# value: int8</syntaxhighlight>

 

<ol>

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

# value: [].diverge()

 

</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.

# value: false</syntaxhighlight>

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

# value: false

 

# value: true</syntaxhighlight>

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

? bstr

# value: [0].diverge()</syntaxhighlight>

</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]

 

# value: [2, 3].diverge()</syntaxhighlight>

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

? bstr2

# value: [-127, -1, 3].diverge()</syntaxhighlight>

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

# value: [1, 2, 3, -127, 2, 3].diverge()</syntaxhighlight>

</li></ol>

=={{header|Elixir}}==

Note: Elixir data types are immutable.

x = "hello world"

 

c = "orld"

IO.puts a <> b <> c #=> hello world</syntaxhighlight>

=={{header|Erlang}}==

-compile([export_all]).

 

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

{{out}}

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

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

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

Join: <<0,1,1,2,3,5,8,13,21,34,55>></syntaxhighlight>

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

 

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)

 

</syntaxhighlight>

=={{header|FreeBASIC}}==

Dim As String cad, cad2

'creación de cadenas

Sleep

</syntaxhighlight>

=={{header|Go}}==

 

import (

bary

</pre>

=={{header|Groovy}}==

{{trans|Java}}

 

class MutableByteString {

 

Test Code

import org.testng.annotations.Test

 

}

}</syntaxhighlight>

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

string = "world" :: String</syntaxhighlight>

 

returning a boolean result using a

simple conditional -}

else False</syntaxhighlight>

 

of characters in Haskell, test and

see if the given string is an empty list -}

else False</syntaxhighlight>

 

append strings, using the built-in

(++) concatenation operator

strAppend x y = x ++ y</syntaxhighlight>

 

from the given string -}

strExtract :: Int -> String -> String

strExtract x s = take x s</syntaxhighlight>

 

two integers, from the given string -}

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

strPull x y s = take (y-x+1) (drop x s)</syntaxhighlight>

 

and elegant solution. Using an imported standard library

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

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

strReplace old new orig = subRegex (mkRegex old) orig new</syntaxhighlight>

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

 

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

 

 

end</syntaxhighlight>

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

name2=: name1</syntaxhighlight>

 

 

* Example check if a binary string is empty

 

* Example apppend a byte to a binary string

byte=: DEL

string=: string,byte</syntaxhighlight>

 

* Extract a substring from a binary string

 

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

'The quick brown fox runs...' rplc ' ';' !!! '</syntaxhighlight>

 

* 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;

Test code:

 

 

import java.nio.charset.StandardCharsets;

}

}</syntaxhighlight>

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

str3+str4;

str.concat('\n',str4); //concantenate them</syntaxhighlight>

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

end );</syntaxhighlight>

Examples

 

[]

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

</syntaxhighlight>

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

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

 

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!"

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

</syntaxhighlight>

=={{header|Lingo}}==

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

 

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

foo = "Hello" && "world!"</syntaxhighlight>

=={{header|Lua}}==

bar = 'bar'

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

 

str = foo .. bar -- Strings concatenate with .. operator</syntaxhighlight>

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

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

-> {12,56,82,65}

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

-> {12,56,82,65,83,12,56,65}</syntaxhighlight>

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

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

b=['456',9];

123 abc @456 789

</pre>

=={{header|Nim}}==

x = "this is a string"

y = "this is another string"

 

echo z.replace('t', 'T') # replace occurences of t with T</syntaxhighlight>

=={{header|OCaml}}==

 

 

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

- : string = "\000\023\000\000\001\000\000\000\000\000"</syntaxhighlight>

 

 

* String assignment

val str : string = "some text"

 

 

* String comparison

- : bool = true

 

 

* String cloning and copying

- : string = "Some text"</syntaxhighlight>

 

* Check if a string is empty

val string_is_empty : string -> bool = <fun>

 

a byte and return the result as a new string

 

- : string = "Some text!"</syntaxhighlight>

 

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

- : string = "text"</syntaxhighlight>

 

* 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

 

* Join strings

- : string = "Now just remind me how the horse moves again?"</syntaxhighlight>

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

%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

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

end.</syntaxhighlight>

=={{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 = ''; # ''

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

say 'Oklahoma' . ' is ' . uc $u; # 'Oklahoma is OK'</syntaxhighlight>

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"abc"</span>

"abc\ndef\nghi"

</pre>

=={{header|Picat}}==

Strings in Picat are lists of characters.

S1 = "binary_string",

println(s1=S1),

 

Since strings are lists of characters, all list functions/procedures are supported including the non-deterministic (backtrackable) <code>member/2</code>, <code>append/3-4</code>, <code>select/3</code> as well as list comprehensions. Some examples:

println(member=findall(C,(member(C,S1), C @< 'l') )),

 

list_comprehension = aoeiaoei

sort_remove_dups = aeghinorst</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:

(mapc wr (range 0 255)) )</syntaxhighlight>

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

...</syntaxhighlight>

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

(make

(while (rd 1)

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

a transient symbol, e.g. the example above

-> " !\"#$%&'()*+,-./"</syntaxhighlight>

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

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

/* replace. */

end replace;

</syntaxhighlight>

=={{header|PowerShell}}==

Clear-Host

 

10 11 12

</pre>

=={{header|Prolog}}==

 

?- X = "a test string".

X = "a test string".

Z = "a test string with extra!".

</syntaxhighlight>

=={{header|PureBasic}}==

;string creation

x$ = "hello world"

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

</syntaxhighlight>

=={{header|Python}}==

===2.x===

* String creation

 

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

s3 = """This text

There is nothing special about assignments:

 

t = "world!"

u = s + t # + concatenates</syntaxhighlight>

They're compared byte by byte, lexicographically:

 

assert '\t' == '\x09'

assert "one" < "two"

* Check if a string is empty

 

if not x: print "Empty string, provided you know x is a string"</syntaxhighlight>

 

* Append a byte to a string

 

txt += '\x07'

# txt refers now to a new string having "Some text\x07"</syntaxhighlight>

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"

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

 

assert txt[-1] == "t"

assert txt[-4:] == "text"</syntaxhighlight>

Strings are objects and have methods, like replace:

 

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

print v2 # prints heLLo worLd</syntaxhighlight>

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

 

v2 = "world"

msg = v1 + " " + v2</syntaxhighlight>

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

 

joined = ",".join(items)

print joined

The reverse operation (split) is also possible:

 

fields = line.split(',')

print fields

 

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

 

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

x[0] # evaluates to 97</syntaxhighlight>

 

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

 

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

bytes([97, 98, 99]) # evaluates to b'abc'</syntaxhighlight>

=={{header|Racket}}==

 

#lang racket

 

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

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2018.03}}

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

say $s;

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

 

>>

</pre>

=={{header|REXX}}==

Programming note: &nbsp; this REXX example demonstrates two types of &nbsp; ''quoting''.

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

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

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"

See a + b + c

</syntaxhighlight>

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

c = "orld"

p d = a + b + c</syntaxhighlight>

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

s$ = "Hello, world"

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

print s$</syntaxhighlight>

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

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

}</syntaxhighlight>

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

 

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 c "orld"

set d $a$b$c</syntaxhighlight>

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

Option Compare Text ' That is, "AAA" is equal to "aaa".</syntaxhighlight>

String creation and destruction :

Sub Creation_String_FirstWay()

Dim myString As String

End Sub '==> Here the string is destructed !</syntaxhighlight>

String assignment :

Dim myString$

'Here, myString is created and equal ""

End Sub</syntaxhighlight>

String comparison :

Dim A$, B$, C$

 

End Sub</syntaxhighlight>

String cloning and copying :

Dim A As String, B$

A = "Hello world!"

End Sub</syntaxhighlight>

Check if a string is empty :

Dim A As String, B As Variant

 

End Sub</syntaxhighlight>

Append a byte to a string :

Dim A As String

A = "Hello worl"

End Sub</syntaxhighlight>

Extract a substring from a string :

Dim A$, B As String

A = "Hello world"

End Sub</syntaxhighlight>

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

Dim A$, B As String, C$

A = "Hello world"

End Sub</syntaxhighlight>

Join Strings :

Dim A$, B As String

 

End Sub

</syntaxhighlight>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Main()

 

End Module</syntaxhighlight>

=={{header|Wren}}==

In Wren, a string is simply an array of bytes. Although they are typically characters stored in UTF-8 format, they don't have to be interpreted in that way and, in recognition of this as well as for efficiency reasons, many of the built-in string functions operate at the byte level.

 

Setting a string variable to the special value ''null'' means that the variable currently has no value though it can still be assigned one later.

var s = "abc"

 

t = "def"

var u = s + t // "abcdef"</syntaxhighlight>

=={{header|Yabasic}}==

// by Galileo, 07/2022

 

See you later.

---Program done, press RETURN---</pre>

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

d.append(d2).text // or d+d2</syntaxhighlight>

{{omit from|GUISS}}

{{omit from|Lotus 123 Macro Scripting}}