Tokenize a string: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Wren}}: Changed to Wren S/H) |
|||
(64 intermediate revisions by 38 users not shown) | |||
Line 11:
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">V text = ‘Hello,How,Are,You,Today’
V tokens = text.split(‘,’)
print(tokens.join(‘.’))</syntaxhighlight>
{{out}}
<pre>
Hello.How.Are.You.Today
</pre>
=={{header|360 Assembly}}==
<
TOKSTR CSECT
USING TOKSTR,R13 base register
Line 95 ⟶ 107:
PG DC CL80' ' buffer
YREGS
END TOKSTR</
{{out}}
<pre>
Hello.How.Are.You.Today
</pre>
=={{header|8080 Assembly}}==
<syntaxhighlight lang="8080asm">puts: equ 9
org 100h
jmp demo
;;; Split the string at DE by the character in C.
;;; Store pointers to the beginning of the elements starting at HL
;;; The amount of elements is returned in B.
split: mvi b,0 ; Amount of elements
sloop: mov m,e ; Store pointer at [HL]
inx h
mov m,d
inx h
inr b ; Increment counter
sscan: ldax d ; Get current character
inx d
cpi '$' ; Done?
rz ; Then stop
cmp c ; Place to split?
jnz sscan ; If not, keep going
dcx d
mvi a,'$' ; End the string here
stax d
inx d
jmp sloop ; Next part
;;; Test on the string given in the task
demo: lxi h,parts ; Parts array
lxi d,hello ; String
mvi c,','
call split ; Split the string
lxi h,parts ; Print each part
loop: mov e,m ; Load pointer into DE
inx h
mov d,m
inx h
push h ; Keep the array pointer
push b ; And the counter
mvi c,puts ; Print the string
call 5
lxi d,period ; And a period
mvi c,puts
call 5
pop b ; Restore the counter
pop h ; Restore the array pointer
dcr b ; One fewer string left
jnz loop
ret
period: db '. $'
hello: db 'Hello,How,Are,You,Today$'
parts: equ $</syntaxhighlight>
{{out}}
<pre>Hello. How. Are. You. Today.</pre>
=={{header|8086 Assembly}}==
<syntaxhighlight lang="asm"> cpu 8086
org 100h
section .text
jmp demo
;;; Split the string at DS:SI on the character in DL.
;;; Store pointers to strings starting at ES:DI.
;;; The amount of strings is returned in CX.
split: xor cx,cx ; Zero out counter
.loop: mov ax,si ; Store pointer to current location
stosw
inc cx ; Increment counter
.scan: lodsb ; Get byte
cmp al,'$' ; End of string?
je .done
cmp al,dl ; Character to split on?
jne .scan
mov [si-1],byte '$' ; Terminate string
jmp .loop
.done: ret
;;; Test on the string given in the task
demo: mov si,hello ; String to split
mov di,parts ; Place to store pointers
mov dl,',' ; Character to split string on
call split
;;; Print the resulting strings, and periods
mov si,parts ; Array of string pointers
print: lodsw ; Load next pointer
mov dx,ax ; Print string using DOS
mov ah,9
int 21h
mov dx,period ; Then print a period
int 21h
loop print ; Loop while there are strings
ret
section .data
period: db '. $'
hello: db 'Hello,How,Are,You,Today$'
section .bss
parts: resw 10</syntaxhighlight>
{{out}}
<pre>Hello. How. Are. You. Today. </pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program strTokenize64.s */
Line 242 ⟶ 349:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
{{Output}}
<pre>
Line 252 ⟶ 359:
Today
</pre>
=={{header|ACL2}}==
<
(if (or (endp xs) (eql (first xs) delim))
(mv nil (rest xs))
Line 281 ⟶ 389:
(progn$ (cw (first strs))
(cw (coerce (list delim) 'string))
(print-with (rest strs) delim))))</
{{out}}
<pre>> (print-with (split-str "Hello,How,Are,You,Today" #\,) #\.)
Hello.How.Are.You.Today.</pre>
=={{header|Action!}}==
The user must type in the monitor the following command after compilation and before running the program!<pre>SET EndProg=*</pre>
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">CARD EndProg ;required for ALLOCATE.ACT
INCLUDE "D2:ALLOCATE.ACT" ;from the Action! Tool Kit. You must type 'SET EndProg=*' from the monitor after compiling, but before running this program!
DEFINE PTR="CARD"
BYTE FUNC Split(CHAR ARRAY s CHAR c PTR ARRAY items)
BYTE i,count,start,len
CHAR ARRAY item
IF s(0)=0 THEN RETURN (0) FI
i=1 count=0
WHILE i<s(0)
DO
start=i
WHILE i<=s(0) AND s(i)#c
DO
i==+1
OD
len=i-start
item=Alloc(len+1)
SCopyS(item,s,start,i-1)
items(count)=item
count==+1
i==+1
OD
RETURN (count)
PROC Join(PTR ARRAY items BYTE count CHAR c CHAR ARRAY s)
BYTE i,pos
CHAR POINTER srcPtr,dstPtr
CHAR ARRAY item
s(0)=0
IF count=0 THEN RETURN FI
pos=1
FOR i=0 TO count-1
DO
item=items(i)
srcPtr=item+1
dstPtr=s+pos
MoveBlock(dstPtr,srcPtr,item(0))
pos==+item(0)
IF i<count-1 THEN
s(pos)='.
pos==+1
FI
OD
s(0)=pos-1
RETURN
PROC Clear(PTR ARRAY items BYTE POINTER count)
BYTE i
CHAR ARRAY item
IF count^=0 THEN RETURN FI
FOR i=0 TO count^-1
DO
item=items(i)
Free(item,item(0)+1)
OD
count^=0
RETURN
PROC Main()
CHAR ARRAY s="Hello,How,Are,You,Today"
CHAR ARRAY r(256)
PTR ARRAY items(100)
BYTE i,count
Put(125) PutE() ;clear screen
AllocInit(0)
count=Split(s,',,items)
Join(items,count,'.,r)
PrintF("Input:%E""%S""%E%E",s)
PrintE("Split:")
FOR i=0 TO count-1
DO
PrintF("""%S""",items(i))
IF i<count-1 THEN
Print(", ")
ELSE
PutE() PutE()
FI
OD
PrintF("Join:%E""%S""%E",r)
Clear(items,@count)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Tokenize_a_string.png Screenshot from Atari 8-bit computer]
<pre>
Input:
"Hello,How,Are,You,Today"
Split:
"Hello", "How", "Are", "You", "Today"
Join:
"Hello.How.Are.You.Today"
</pre>
=={{header|ActionScript}}==
<
var tokens:Array = hello.split(",");
trace(tokens.join("."));
// Or as a one-liner
trace("Hello,How,Are,You,Today".split(",").join("."));</
=={{header|Ada}}==
<
use Ada.Text_IO, Ada.Containers, Ada.Strings, Ada.Strings.Fixed, Ada.Strings.Maps;
Line 316 ⟶ 534:
Put (S & ".");
end loop;
end Tokenize;</
=={{header|ALGOL 68}}==
<
OP +:= = (REF FLEX[]STRING in out, STRING item)VOID:(
Line 367 ⟶ 585:
printf(($g"."$, string split(beetles, ", "),$l$));
printf(($g"."$, char split(beetles, ", "),$l$))
)</
{{out}}
<pre>
John Lennon.Paul McCartney.George Harrison.Ringo Starr.
John.Lennon..Paul.McCartney..George.Harrison..Ringo.Starr.
</pre>
=={{header|Amazing Hopper}}==
Hopper provides instructions for separating and modifying tokens from a string.
Let "s" be a string; "n" token number:
1) {n}, $(s) ==> gets token "n" from string "s".
2) {"word", n} $$(s) ==> replace token "n" of "s", with "word".
Note: the "splitnumber" macro cannot separate a number converted to a string by the "XTOSTR" function, because this function "rounds" the number to the decimal position by default.
<syntaxhighlight lang="hopper">
#include <hopper.h>
#proto splitdate(_DATETIME_)
#proto splitnumber(_N_)
#proto split(_S_,_T_)
main:
s="this string will be separated into parts with space token separator"
aS=0,let( aS :=_split(s," "))
{","}toksep // set a new token separator
{"String: ",s}
{"\nArray:\n",aS},
{"\nSize="}size(aS),println // "size" return an array: {dims,#rows,#cols,#pages}
{"\nOriginal number: ",-125.489922},println
w=0,let(w:=_split number(-125.489922) )
{"Integer part: "}[1]get(w) // get first element from array "w"
{"\nDecimal part: "}[2]get(w),println // get second element from array "w"
{"\nDate by DATENOW(TODAY) macro: "},print
dt=0, let( dt :=_splitdate(datenow(TODAY);!puts)) // "!" keep first element from stack
{"\nDate: "}[1]get(dt)
{"\nTime: "}[2]get(dt),println
exit(0)
.locals
splitdate(_DATETIME_)
_SEP_=0,gettoksep,mov(_SEP_) // "gettoksep" return actual token separator
{","}toksep, // set a new token separator
_NEWARRAY_={}
{1},$( _DATETIME_ ),
{2},$( _DATETIME_ ),pushall(_NEWARRAY_)
{_SEP_}toksep // restore ols token separator
{_NEWARRAY_}
back
splitnumber(_X_)
part_int=0,part_dec=0,
{_X_},!trunc,mov(part_int),
minus(part_int), !sign,mul
xtostr,mov(part_dec), part_dec+=2, // "part_dec+=2", delete "0." from "part_dec"
{part_dec}xtonum,mov(part_dec)
_NEWARRAY_={},{part_int,part_dec},pushall(_NEWARRAY_)
{_NEWARRAY_}
back
split(_S_,_T_)
_NEWARRAY_={},_VAR1_=0,_SEP_=0,gettoksep,mov(_SEP_)
{_T_}toksep,totaltoken(_S_),
mov(_VAR1_), // for total tokens
_VAR2_=1, // for real position of tokens into the string
___SPLIT_ITER:
{_VAR2_}$( _S_ ),push(_NEWARRAY_)
++_VAR2_,--_VAR1_
{ _VAR1_ },jnz(___SPLIT_ITER) // jump to "___SPLIT_ITER" if "_VAR1_" is not zero.
clear(_VAR2_),clear(_VAR1_)
{_SEP_}toksep
{_NEWARRAY_}
back
</syntaxhighlight>
{{Out}}
<pre>Output:
String: this string will be separated into parts with space token separator
Array:
this,string,will,be,separated,into,parts,with,space,token,separator
Size=1,11
Original number: -125.49
Integer part: -125
Decimal part: 489922
Date by DATENOW(TODAY) macro: 22/11/2021,18:41:20:13
Date: 22/11/2021
Time: 18:41:20:13
</pre>
=={{header|APL}}==
<
abc. 123. X. ⍝ 3 strings (char vectors), each with a period at the end.
</syntaxhighlight>
=={{header|AppleScript}}==
<
intercalate(".", splitOn(",", "Hello,How,Are,You,Today"))
end run
Line 400 ⟶ 713:
set my text item delimiters to dlm
return strJoined
end intercalate</
{{Out}}
<pre>Hello.How.Are.You.Today</pre>
Line 406 ⟶ 719:
Or,
<
set tokens to the text items of "Hello,How,Are,You,Today"
set my text item delimiters to "."
log tokens as text</
{{Out}}
Line 418 ⟶ 731:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
Line 582 ⟶ 895:
bx lr
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">str: "Hello,How,Are,You,Today"
print join.with:"." split.by:"," str</syntaxhighlight>
{{out}}
Line 597 ⟶ 907:
=={{header|Astro}}==
<
let tokens = text.split(||,||)
print tokens.join(with: '.')</
=={{header|AutoHotkey}}==
<
stringsplit, string, string, `,
loop, % string0
{
msgbox % string%A_Index%
}</
=={{header|AWK}}==
<
s = "Hello,How,Are,You,Today"
split(s, arr, ",")
Line 618 ⟶ 928:
}
print
}</
A more ''idiomatic'' way for AWK is
<
{
for(i=1; i <= NF; i++) printf $i ".";
print ""
}</
which "tokenize" each line of input and this is achieved by using "," as field separator
Line 632 ⟶ 942:
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<
110 GOSUB 200"TOKENIZE
120 FOR I = 1 TO N
Line 651 ⟶ 961:
290 A$(N) = A$(N) + C$
300 NEXT TI
310 RETURN</
==={{header|BaCon}}===
BaCon includes extensive support for ''delimited strings''.
<syntaxhighlight lang="bacon">OPTION BASE 1
string$ = "Hello,How,Are,You,Today"
' Tokenize a string into an array
SPLIT string$ BY "," TO array$
' Print array elements with new delimiter
PRINT COIL$(i, UBOUND(array$), array$[i], ".")
' Or simply replace the delimiter
PRINT DELIM$(string$, ",", ".")</syntaxhighlight>
{{out}}
<pre>prompt$ ./tokenize
Hello.How.Are.You.Today
Hello.How.Are.You.Today</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">instring$ = "Hello,How,Are,You,Today"
tokens$ = explode(instring$,",")
for i = 0 to tokens$[?]-1
print tokens$[i]; ".";
next i
end</syntaxhighlight>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<
text$ = "Hello,How,Are,You,Today"
Line 682 ⟶ 1,002:
PRINT array$(i%) "." ;
NEXT
PRINT</
==={{header|Chipmunk Basic}}===
Solutions [[#Applesoft BASIC|Applesoft BASIC]] and [[#Commodore BASIC|Commodore BASIC]] work without changes.
==={{header|Commodore BASIC}}===
Based on the AppleSoft BASIC version.
<
20 T$ = "HELLO,HOW,ARE,YOU,TODAY"
30 GOSUB 200, TOKENIZE
Line 703 ⟶ 1,025:
260 N = N + 1
270 NEXT L
280 RETURN</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">sub tokenize( instring as string, tokens() as string, sep as string )
redim tokens(0 to 0) as string
dim as string*1 ch
dim as uinteger t=0
for i as uinteger = 1 to len(instring)
ch = mid(instring,i,1)
if ch = sep then
t = t + 1
redim preserve tokens(0 to t)
else
tokens(t) = tokens(t) + ch
end if
next i
return
end sub
dim as string instring = "Hello,How,Are,You,Today"
redim as string tokens(-1)
tokenize( instring, tokens(), "," )
for i as uinteger = 0 to ubound(tokens)
print tokens(i);".";
next i</syntaxhighlight>
==={{header|Liberty BASIC}}===
<
For i = 0 To 4
array$(i) = Word$("Hello,How,Are,You,Today", (i + 1), ",")
Line 712 ⟶ 1,058:
Next i
Print Left$(array$, (Len(array$) - 1))</
==={{header|
The [[#Commodore BASIC|Commodore BASIC]] solution works without any changes.
==={{header|PowerBASIC}}===
PowerBASIC has a few keywords that make parsing strings trivial: <code>PARSE</code>, <code>PARSE$</code>, and <code>PARSECOUNT</code>. (<code>PARSE$</code>, not shown here, is for extracting tokens one at a time, while <code>PARSE</code> extracts all tokens at once into an array. <code>PARSECOUNT</code> returns the number of tokens found.)
<
DIM parseMe AS STRING
parseMe = "Hello,How,Are,You,Today"
Line 732 ⟶ 1,080:
MSGBOX outP
END FUNCTION</
==={{header|PureBasic}}===
'''As described
<
For i=1 To 5
Line 746 ⟶ 1,094:
ForEach MyStrings()
Print(MyStrings()+".")
Next</
'''Still, easier would be
<
==={{header|QBasic}}===
<
parseMe = "Hello,How,Are,You,Today"
Line 796 ⟶ 1,144:
PRINT "."; parsed(L0);
NEXT
END IF</
==={{header|Run BASIC}}===
<
FOR i = 1 to 5
textArray$(i) = word$(text$,i,",")
print textArray$(i);" ";
NEXT</
==={{header|VBScript}}===
====One liner====
<
In fact, the Visual Basic solution (below) could have done the same, as Join() is available.
Line 816 ⟶ 1,164:
Unlike PowerBASIC, there is no need to know beforehand how many tokens are in the string -- <code>Split</code> automagically builds the array for you.
<
Dim parseMe As String, parsed As Variant
parseMe = "Hello,How,Are,You,Today"
Line 829 ⟶ 1,177:
MsgBox outP
End Sub</
=={{header|Batch File}}==
<
setlocal enabledelayedexpansion
call :tokenize %1 res
Line 843 ⟶ 1,191:
for %%i in (%str%) do set %2=!%2!.%%i
set %2=!%2:~1!
goto :eof</
''Demo''
>tokenize.cmd "Hello,How,Are,You,Today"
Hello.How.Are.You.Today
=={{header|BQN}}==
Uses a splitting idiom from bqncrate.
<syntaxhighlight lang="bqn">Split ← (+`׬)⊸-∘= ⊔ ⊢
∾⟜'.'⊸∾´ ',' Split "Hello,How,Are,You,Today"</syntaxhighlight>
{{out}}
<pre>"Hello.How.Are.You.Today"</pre>
=={{header|Bracmat}}==
Solution that employs string pattern matching to spot the commas
<
& :?ReverseList
& whl
Line 863 ⟶ 1,219:
)
& out$!List
)</
Solution that starts by evaluating the input and employs the circumstance that the comma is a list constructing binary operator and that the string does not contain any other characters that are interpreted as operators on evaluation.
<
& :?ReverseList
& whl
Line 877 ⟶ 1,233:
)
& out$!List
)</
=={{header|C}}==
Line 886 ⟶ 1,242:
This example uses the ''strtok()'' function to separate the tokens. This function is destructive (replacing token separators with '\0'), so we have to make a copy of the string (using ''strdup()'') before tokenizing. ''strdup()'' is not part of [[ANSI C]], but is available on most platforms. It can easily be implemented with a combination of ''strlen()'', ''malloc()'', and ''strcpy()''.
<
#include<stdio.h>
#include<stdlib.h>
Line 907 ⟶ 1,263:
return 0;
}</
Another way to accomplish the task without the built-in string functions is to temporarily modify the separator character. This method does not need any additional memory, but requires the input string to be writeable.
<
typedef void (*callbackfunc)(const char *);
Line 935 ⟶ 1,291:
tokenize(array, ',', doprint);
return 0;
}</
=={{header|C sharp|C#}}==
<
// or Regex.Split ( "Hello,How,Are,You,Today", "," );
// (Regex is in System.Text.RegularExpressions namespace)
string[] strings = str.Split(',');
Console.WriteLine(String.Join(".", strings));
</syntaxhighlight>
=={{header|C++}}==
Line 950 ⟶ 1,306:
std::getline() is typically used to tokenize strings on a single-character delimiter
<
#include <sstream>
#include <vector>
Line 965 ⟶ 1,321:
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."));
std::cout << '\n';
}</
{{works with|C++98}}
C++ allows the user to redefine what is considered whitespace. If the delimiter is whitespace, tokenization becomes effortless.
<
#include <locale>
#include <sstream>
Line 994 ⟶ 1,350:
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."));
std::cout << '\n';
}</
{{works with|C++98}}
Line 1,000 ⟶ 1,356:
The boost library has multiple options for easy tokenization.
<
#include <vector>
#include <iterator>
Line 1,013 ⟶ 1,369:
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."))
std::cout << '\n';
}</
{{works with|C++23}}
C++20 and C++23 drastically improve the ergonomics of simple manipulation of ranges.
<syntaxhighlight lang="cpp">#include <string>
#include <ranges>
#include <iostream>
int main() {
std::string s = "Hello,How,Are,You,Today";
s = s // Assign the final string back to the string variable
| std::views::split(',') // Produce a range of the comma separated words
| std::views::join_with('.') // Concatenate the words into a single range of characters
| std::ranges::to<std::string>(); // Convert the range of characters into a regular string
std::cout << s;
}</syntaxhighlight>
=={{header|Ceylon}}==
{{works with|Ceylon 1.2}}
<
value input = "Hello,How,Are,You,Today";
value tokens = input.split(','.equals);
print(".".join(tokens));
}</
=={{header|CFEngine}}==
<syntaxhighlight lang="cfengine">bundle agent main
{
reports:
"${with}" with => join(".", splitstring("Hello,How,Are,You,Today", ",", 99));
}
</syntaxhighlight>
{{out}}
<pre>cf-agent -KIf ./tokenize-a-string.cf
R: Hello.How.Are.You.Today</pre>
See https://docs.cfengine.com/docs/master/reference-functions.html for a complete list of available functions.
=={{header|Clojure}}==
Using native Clojure functions and Java Interop:
<
Using the clojure.string library:
<
=={{header|CLU}}==
<syntaxhighlight lang="clu">% This iterator splits the string on a given character,
% and returns each substring in order.
tokenize = iter (s: string, c: char) yields (string)
while ~string$empty(s) do
next: int := string$indexc(c, s)
if next = 0 then
yield(s)
break
else
yield(string$substr(s, 1, next-1))
s := string$rest(s, next+1)
end
end
end tokenize
start_up = proc ()
po: stream := stream$primary_output()
str: string := "Hello,How,Are,You,Today"
for part: string in tokenize(str, ',') do
stream$putl(po, part || ".")
end
end start_up</syntaxhighlight>
{{out}}
<pre>Hello.
How.
Are.
You.
Today.</pre>
=={{header|COBOL}}==
This can be made to handle more complex cases; UNSTRING allows multiple delimiters, capture of which delimiter was used for each field, a POINTER for starting position (set on ending), along with match TALLYING.
<syntaxhighlight lang="cobol">
identification division.
program-id. tokenize.
Line 1,064 ⟶ 1,479:
goback.
end program tokenize.
</syntaxhighlight>
{{out}}
Line 1,074 ⟶ 1,489:
=={{header|CoffeeScript}}==
<
arr = "Hello,How,Are,You,Today".split ","
console.log arr.join "."
</syntaxhighlight>
=={{header|ColdFusion}}==
=== Classic tag based CFML ===
<
<cfoutput>
<cfset wordListTag = "Hello,How,Are,You,Today">
#Replace( wordListTag, ",", ".", "all" )#
</cfoutput>
</syntaxhighlight>
{{Output}}
<pre>
Line 1,093 ⟶ 1,508:
=== Script Based CFML ===
<
wordList = "Hello,How,Are,You,Today";
splitList = replace( wordList, ",", ".", "all" );
writeOutput( splitList );
</cfscript></
{{Output}}
<pre>
Line 1,107 ⟶ 1,522:
There are libraries out there that handle splitting (e.g., [http://www.cliki.net/SPLIT-SEQUENCE SPLIT-SEQUENCE], and the more-general [http://weitz.de/cl-ppcre/ CL-PPCRE]), but this is a simple one-off, too. When the words are written with write-with-periods, there is no final period after the last word.
<
(loop for start = 0 then (1+ finish)
for finish = (position #\, string :start start)
Line 1,114 ⟶ 1,529:
(defun write-with-periods (strings)
(format t "~{~A~^.~}" strings))</
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
include "strings.coh";
# Tokenize a string. Note: the string is modified in place.
sub tokenize(sep: uint8, str: [uint8], out: [[uint8]]): (length: intptr) is
length := 0;
loop
[out] := str;
out := @next out;
length := length + 1;
while [str] != 0 and [str] != sep loop
str := @next str;
end loop;
if [str] == sep then
[str] := 0;
str := @next str;
else
break;
end if;
end loop;
end sub;
# The string
var string: [uint8] := "Hello,How,Are,You,Today";
# Make a mutable copy
var buf: uint8[64];
CopyString(string, &buf[0]);
# Tokenize the copy
var parts: [uint8][64];
var length := tokenize(',', &buf[0], &parts[0]) as @indexof parts;
# Print each string
var i: @indexof parts := 0;
while i < length loop
print(parts[i]);
print(".\n");
i := i + 1;
end loop;</syntaxhighlight>
{{out}}
<pre>Hello.
How.
Are.
You.
Today.</pre>
=={{header|Crystal}}==
<syntaxhighlight lang="crystal">puts "Hello,How,Are,You,Today".split(',').join('.')</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|D}}==
<
import std.stdio, std.string;
"Hello,How,Are,You,Today".split(',').join('.').writeln;
}</
{{out}}
<pre>Hello.How.Are.You.Today</pre>
Line 1,128 ⟶ 1,596:
=== Using String.split ===
{{libheader| System.SysUtils}}
<syntaxhighlight lang="delphi">
program Tokenize_a_string;
Line 1,146 ⟶ 1,614:
end.
</syntaxhighlight>
=== Using TStringList ===
<syntaxhighlight lang="delphi">
program TokenizeString;
Line 1,182 ⟶ 1,650:
end.
</syntaxhighlight>
The result is:
<syntaxhighlight lang="delphi">
Hello
How
Line 1,192 ⟶ 1,660:
You
Today
</syntaxhighlight>
=={{header|dt}}==
<syntaxhighlight lang="dt">"Hello,How,Are,You,Today" "," split "." join pl</syntaxhighlight>
=={{header|Dyalect}}==
<syntaxhighlight lang="dyalect">var str = "Hello,How,Are,You,Today"
var strings = str.Split(',')
print(values: strings, separator: ".")</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|Déjà Vu}}==
<
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|E}}==
<
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
s$ = "Hello,How,Are,You,Today"
a$[] = strsplit s$ ","
for s$ in a$[]
write s$ & "."
.
</syntaxhighlight>
=={{header|Elena}}==
ELENA
<
import extensions;
public program()
{
string.splitBy
{
console.print(s,".")
}
}</
=={{header|Elixir}}==
<
tokens = String.split("Hello,How,Are,You,Today", ",")
IO.puts Enum.join(tokens, ".")
</syntaxhighlight>
=={{header|EMal}}==
<syntaxhighlight lang="emal">
text value = "Hello,How,Are,You,Today"
List tokens = value.split(",")
writeLine(tokens.join("."))
# single line version
writeLine("Hello,How,Are,You,Today".split(",").join("."))
</syntaxhighlight>
{{out}}
<pre>
Hello.How.Are.You.Today
Hello.How.Are.You.Today
</pre>
=={{header|Erlang}}==
<
-export([start/0]).
Line 1,240 ⟶ 1,731:
Lst = string:tokens("Hello,How,Are,You,Today",","),
io:fwrite("~s~n", [string:join(Lst,".")]),
ok.</
=={{header|Euphoria}}==
<
sequence out
integer first, delim
Line 1,264 ⟶ 1,755:
for i = 1 to length(s) do
puts(1, s[i] & ',')
end for</
=={{header|F_Sharp|F#}}==
<
=={{header|Factor}}==
<
=={{header|Falcon}}==
'''VBA/Python programmer's approach to this solution, not sure if it's the most falconic way'''
<
/* created by Aykayayciti Earl Lamont Montgomery
April 9th, 2018 */
Line 1,288 ⟶ 1,779:
> b
</syntaxhighlight>
{{out}}
<pre>
Line 1,299 ⟶ 1,790:
A string can be split on a given character, returning a list of the intervening strings.
<
class Main
{
Line 1,312 ⟶ 1,803:
}
}
</syntaxhighlight>
=={{header|Fennel}}==
{{trans|Lua}}
<syntaxhighlight lang="fennel">(fn string.split [self sep]
(let [pattern (string.format "([^%s]+)" sep)
fields {}]
(self:gsub pattern (fn [c] (tset fields (+ 1 (length fields)) c)))
fields))
(let [str "Hello,How,Are,You,Today"]
(print (table.concat (str:split ",") ".")))</syntaxhighlight>
=={{header|Forth}}==
There is no standard string split routine, but it is easily written. The results are saved temporarily to the dictionary.
<
here >r 2swap
begin
Line 1,334 ⟶ 1,836:
1 ?do dup 2@ type ." ." cell+ cell+ loop 2@ type ;
s" Hello,How,Are,You,Today" s" ," split .tokens \ Hello.How.Are.You.Today</
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
CHARACTER(23) :: str = "Hello,How,Are,You,Today"
Line 1,360 ⟶ 1,862:
END DO
END PROGRAM Example</
=={{header|Frink}}==
<
println[join[".", split[",", "Hello,How,Are,You,Today"]]]
</syntaxhighlight>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
window 1, @"Tokenize a string"
void local fn DoIt
CFStringRef string = @"Hello,How,Are,You,Today"
CFArrayRef tokens = fn StringComponentsSeparatedByString( string, @"," )
print fn ArrayComponentsJoinedByString( tokens, @"." )
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
Hello.How.Are.You.Today
</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=218e240236cdf1419a405abfed906ed3 Click this link to run this code]'''
<
Dim sString As String[] = Split("Hello,How,Are,You,Today")
Print sString.Join(".")
End</
Output:
<pre>
Line 1,381 ⟶ 1,902:
=={{header|GAP}}==
<
# [ "Hello", "How", "Are", "You", "Today" ]
JoinStringsWithSeparator(last, ".");
# "Hello.How.Are.You.Today"</
=={{header|Genie}}==
<
init
Line 1,394 ⟶ 1,915:
words:array of string[] = str.split(",")
joined:string = string.joinv(".", words)
print joined</
{{out}}
Line 1,402 ⟶ 1,923:
=={{header|Go}}==
<
import (
Line 1,412 ⟶ 1,933:
s := "Hello,How,Are,You,Today"
fmt.Println(strings.Join(strings.Split(s, ","), "."))
}</
=={{header|Groovy}}==
<
=={{header|Haskell}}==
'''Using Data.Text'''
<
import Data.Text (splitOn,intercalate)
import qualified Data.Text.IO as T (putStrLn)
main = T.putStrLn . intercalate "." $ splitOn "," "Hello,How,Are,You,Today"</
Output: Hello.How.Are.You.Today
Line 1,432 ⟶ 1,953:
The necessary operations are unfortunately not in the standard library (yet), but simple to write:
<
splitBy _ [] = []
splitBy f list = first : splitBy f (dropWhile f rest) where
Line 1,447 ⟶ 1,968:
-- using regular expression to split:
import Text.Regex
putStrLn $ joinWith "." $ splitRegex (mkRegex ",") $ "Hello,How,Are,You,Today"</
Tokenizing can also be realized by using unfoldr and break:
<
Hello
How
Are
You
Today</
* You need to import the modules Data.List and Control.Arrow
Line 1,461 ⟶ 1,982:
=={{header|HicEst}}==
<
nWords = INDEX(string, ',', 256) + 1
Line 1,473 ⟶ 1,994:
DO i = 1, nWords
WRITE(APPend) TRIM(CHAR(i, maxWordLength, list)), '.'
ENDDO</
=={{header|Icon}} and {{header|Unicon}}==
<
A := []
"Hello,How,Are,You,Today" ?
while put(A, 1(tab(upto(',')),=","))
put(A,tab(0))
}
every writes(!A,".")
write()
end</
{{out}}
<pre>
->ss
Hello.How.Are.You.Today.
->
</pre>
A Unicon-specific solution is:
<syntaxhighlight lang="unicon">import util
procedure main()
A := stringToList("Hello,How,Are,You,Today", ',')
every writes(!A,".")
write()
end</syntaxhighlight>
One wonders what the expected output should be with the input string ",,,,".
=={{header|Io}}==
<
=={{header|J}}==
<
] t=: <;._1 ',',s
+-----+---+---+---+-----+
Line 1,503 ⟶ 2,038:
'.' (I.','=s)}s NB. two steps combined
Hello.How.Are.You.Today</
Alternatively using the system library/script <tt>strings</tt>
<
',' splitstring s
+-----+---+---+---+-----+
Line 1,513 ⟶ 2,048:
'.' joinstring ',' splitstring s
Hello.How.Are.You.Today</
<tt>splitstring</tt> and <tt>joinstring</tt> also work with longer "delimiters":
<
"Hello","How","Are","You","Today"</
But, of course, this could be solved with simple string replacement:
<
Hello.How.Are.You.Today</
The task asks us to ''Separate the string "Hello,How,Are,You,Today" by commas into an array (or list) so that each element of it stores a different word.'' but for many purposes the original string is an adequate data structure. Note also that given a string, a list of "word start" indices and "word length" integers can be logically equivalent to having an "array of words" -- and, depending on implementation details may be a superior or inferior choice to some other representation. But, in current definition of this task, the concept of "word length" plays no useful role.
Line 1,528 ⟶ 2,063:
Note also that J provides several built-in concepts of parsing: split on leading delimiter, split on trailing delimiter, split J language words. Also, it's sometimes more efficient to append to a string than to prepend to it. So a common practice for parsing on an embedded delimiter is to append a copy of the delimiter to the string and then use the appended result:
<
Here '''fn''' is applied to each ',' delimited substring and the results are assembled into an array.
Or, factoring out the names:
<
=={{header|Java}}==
Line 1,544 ⟶ 2,079:
{{works with|Java|1.8+}}
<
System.out.println(String.join(".", toTokenize.split(",")));</
{{works with|Java|1.4+}}
<
String words[] = toTokenize.split(",");//splits on one comma, multiple commas yield multiple splits
Line 1,554 ⟶ 2,089:
for(int i=0; i<words.length; i++) {
System.out.print(words[i] + ".");
}</
The other way is to use StringTokenizer. It will skip any empty tokens. So if two commas are given in line, there will be an empty string in the array given by the split function, but no empty string with the StringTokenizer object. This method takes more code to use, but allows you to get tokens incrementally instead of all at once.
{{works with|Java|1.0+}}
<
StringTokenizer tokenizer = new StringTokenizer(toTokenize, ",");
while(tokenizer.hasMoreTokens()) {
System.out.print(tokenizer.nextToken() + ".");
}</
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">console.log(
"Hello,How,Are,You,Today"
.split(",")
.join(".")
);</syntaxhighlight>A more advanced program to tokenise strings:<syntaxhighlight lang="javascript" line="1">
const Tokeniser = (function () {
const numberRegex = /-?(\d+\.d+|\d+\.|\.\d+|\d+)((e|E)(\+|-)?\d+)?/g;
return {
settings: {
operators: ["<", ">", "=", "+", "-", "*", "/", "?", "!"],
separators: [",", ".", ";", ":", " ", "\t", "\n"],
groupers: ["(", ")", "[", "]", "{", "}", '"', '"', "'", "'"],
keepWhiteSpacesAsTokens: false,
trimTokens: true
},
isNumber: function (value) {
if (typeof value === "number") {
return true;
} else if (typeof value === "string") {
return numberRegex.test(value);
}
return false;
},
closeGrouper: function (grouper) {
if (this.settings.groupers.includes(grouper)) {
return this.settings.groupers[this.settings.groupers.indexOf(grouper) + 1];
}
return null;
},
tokenType: function (char) {
if (this.settings.operators.includes(char)) {
return "operator";
} else if (this.settings.separators.includes(char)) {
return "separator";
} else if (this.settings.groupers.includes(char)) {
return "grouper";
}
return "other";
},
parseString: function (str) {
if (typeof str !== "string") {
if (str === null) {
return "null";
} if (typeof str === "object") {
str = JSON.stringify(str);
} else {
str = str.toString();
}
}
let tokens = [], _tempToken = "";
for (let i = 0; i < str.length; i++) {
if (this.tokenType(_tempToken) !== this.tokenType(str[i]) || this.tokenType(str[i]) === "separator") {
if (_tempToken.trim() !== "") {
tokens.push(this.settings.trimTokens ? _tempToken.trim() : _tempToken);
} else if (this.settings.keepWhiteSpacesAsTokens) {
tokens.push(_tempToken);
}
_tempToken = str[i];
if (this.tokenType(_tempToken) === "separator") {
if (_tempToken.trim() !== "") {
tokens.push(this.settings.trimTokens ? _tempToken.trim() : _tempToken);
} else if (this.settings.keepWhiteSpacesAsTokens) {
tokens.push(_tempToken);
}
_tempToken = "";
}
} else {
_tempToken += str[i];
}
}
if (_tempToken.trim() !== "") {
tokens.push(this.settings.trimTokens ? _tempToken.trim() : _tempToken);
} else if (this.settings.keepWhiteSpacesAsTokens) {
tokens.push(_tempToken);
}
return tokens.filter((token) => token !== "");
}
};
})();
</syntaxhighlight>Output:<syntaxhighlight lang="javascript">
Tokeniser.parseString("Hello,How,Are,You,Today");
</syntaxhighlight>
=={{header|jq}}==
<
"Hello,How,Are,You,Today"
Hello.How.Are.You.Today</
=={{header|Jsish}}==
Being in the ECMAScript family, Jsi is blessed with many easy to use character, string and array manipulation routines.
<
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|Julia}}==
<syntaxhighlight lang="julia">
s = "Hello,How,Are,You,Today"
a = split(s, ",")
Line 1,592 ⟶ 2,208:
println("Splits into ", a)
println("Reconstitutes to \"", t, "\"")
</syntaxhighlight>
{{out}}
Line 1,602 ⟶ 2,218:
=={{header|K}}==
<
"." /: words</
{{out}}
Line 1,609 ⟶ 2,225:
"Hello.How.Are.You.Today"
</pre>
{{works with|ngn/k}}<syntaxhighlight lang=K>","\"Hello,How,Are,You,Today"
("Hello"
"How"
"Are"
"You"
"Today")</syntaxhighlight>
=={{header|Klingphix}}==
<
nl "End " input</
{{out}}
<pre>Hello.How.Are.You.Today.
Line 1,620 ⟶ 2,243:
=={{header|Kotlin}}==
{{works with|Kotlin|1.0b4}}
<
val input = "Hello,How,Are,You,Today"
println(input.split(',').joinToString("."))
}</
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh
# Tokenize a string
# # Variables:
#
string="Hello,How,Are,You,Today"
inputdelim=\, # a comma
outputdelim=\. # a period
# # Functions:
#
# # Function _tokenize(str, indelim, outdelim)
#
function _tokenize {
typeset _str ; _str="$1"
typeset _ind ; _ind="$2"
typeset _outd ; _outd="$3"
while [[ ${_str} != ${_str/${_ind}/${_outd}} ]]; do
_str=${_str/${_ind}/${_outd}}
done
echo "${_str}"
}
######
# main #
######
_tokenize "${string}" "${inputdelim}" "${outputdelim}"</syntaxhighlight>
{{out}}<pre>Hello.How.Are.You.Today</pre>
=={{header|LabVIEW}}==
Line 1,632 ⟶ 2,290:
=={{header|Lambdatalk}}==
<
{S.replace , by . in Hello,How,Are,You,Today}.
-> Hello.How.Are.You.Today.
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
$str = Hello,How,Are,You,Today
fn.println(fn.join(\., fn.split($str, \,)))
</syntaxhighlight>
=={{header|Lang5}}==
<
=={{header|LDPL}}==
<
DATA:
explode/words is text vector
Line 1,693 ⟶ 2,357:
add 1 and i in i
repeat
</syntaxhighlight>
=={{header|LFE}}==
<
> (set split (string:tokens "Hello,How,Are,You,Today" ","))
("Hello" "How" "Are" "You" "Today")
> (string:join split ".")
"Hello.How.Are.You.Today"
</syntaxhighlight>
=={{header|Lingo}}==
<
_player.itemDelimiter = ","
output = ""
Line 1,713 ⟶ 2,377:
delete the last char of output
put output
-- "Hello.How.Are.You.Today"</
=={{header|Logo}}==
{{works with|UCB Logo}}
<
output parse map [ifelse ? = :sep ["| |] [?]] :str
end</
This form is more robust, doing the right thing if there are embedded spaces.
<
if empty? :str [output lput :w :acc]
ifelse equal? first :str :by ~
[output (split butfirst :str :by lput :w :acc)] ~
[output (split butfirst :str :by :acc lput first :str :w)]
end</
<
[Hello How Are You Today]</
=={{header|Logtalk}}==
Using Logtalk built-in support for Definite Clause Grammars (DCGs) and representing the strings as atoms for readbility:
<
:- object(spliting).
Line 1,757 ⟶ 2,421:
:- end_object.
</syntaxhighlight>
{{out}}
<pre>
Line 1,767 ⟶ 2,431:
=={{header|Lua}}==
Split function callously stolen from the lua-users wiki
<
local sep, fields = sep or ":", {}
local pattern = string.format("([^%s]+)", sep)
Line 1,775 ⟶ 2,439:
local str = "Hello,How,Are,You,Today"
print(table.concat(str:split(","), "."))</
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Function Tokenize$(s){
Line 1,793 ⟶ 2,457:
}
Checkit
</syntaxhighlight>
=={{header|M4}}==
<
define(`set',`define(`$1[$2]',`$3')')
define(`get',`defn($1[$2])')
Line 1,806 ⟶ 2,470:
define(`show',
`ifelse(eval(j<n),1,`get(a,j).`'define(`j',incr(j))`'show')')
show</
{{out}}
Line 1,814 ⟶ 2,478:
=={{header|Maple}}==
<
{{Out|Output}}
<pre>"Hello.How.Are.You.Today"</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang="matlab">
s=strsplit('Hello,How,Are,You,Today',',')
fprintf(1,'%s.',s{:})
</syntaxhighlight>
{{out}}
Line 1,833 ⟶ 2,497:
=={{header|Maxima}}==
<
printf(true, "~{~a~^.~}~%", l)$</
A slightly different way
<syntaxhighlight lang="maxima">
split("Hello,How,Are,You,Today",",")$
simplode(%,".");
</syntaxhighlight>
{{out}}
<pre>
"Hello.How.Are.You.Today"
</pre>
=={{header|MAXScript}}==
<
for word in (filterString "Hello,How,Are,You,Today" ",") do
(
output += (word + ".")
)
format "%\n" output</
=={{header|Mercury}}==
<syntaxhighlight lang="text">
:- module string_tokenize.
:- interface.
Line 1,858 ⟶ 2,532:
Tokens = string.split_at_char((','), "Hello,How,Are,You,Today"),
io.write_list(Tokens, ".", io.write_string, !IO),
io.nl(!IO).</
=={{header|min}}==
{{works with|min|0.19.3}}
<
=={{header|MiniScript}}==
<
print tokens.join(".")</
=={{header|MMIX}}==
<
EOS IS 0
NL IS 10
Line 1,922 ⟶ 2,596:
LDBU t,tp
PBNZ t,2B % UNTIL EOB(uffer)
TRAP 0,Halt,0</
{{out}}
<pre>
Line 1,934 ⟶ 2,608:
=={{header|Modula-3}}==
<
IMPORT IO, TextConv;
Line 1,951 ⟶ 2,625:
END;
IO.Put("\n");
END Tokenize.</
=={{header|MUMPS}}==
<
NEW I,J,INP
SET INP="Hello,how,are,you,today"
Line 1,960 ⟶ 2,634:
NEW J FOR J=1:1:I WRITE INP(J) WRITE:J'=I "."
KILL I,J,INP // Kill is optional. "New" variables automatically are killed on "Quit"
QUIT</
In use:
Line 1,967 ⟶ 2,641:
=={{header|Nanoquery}}==
<
print word + "."
end</
{{out}}
<pre>Hello.How.Are.You.Today.</pre>
=={{header|Nemerle}}==
<
using System.Console;
using Nemerle.Utility.NString;
Line 1,987 ⟶ 2,661:
// a quick in place list comprehension takes care of that
}
}</
=={{header|NetRexx}}==
<
* 20.08.2012 Walter Pachl derived from REXX Version 3
**********************************************************************/
Line 2,001 ⟶ 2,675:
Say ss.word(i)'.'
End
Say 'End-of-list.'</
Output as in REXX version
=={{header|NewLISP}}==
<
=={{header|Nial}}==
Line 2,013 ⟶ 2,687:
Define Array with input string:
<
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|H|e|l|l|o|,|H|o|w|,|A|r|e|,|Y|o|u|,|T|o|d|a|y|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+</
Split string at the commas:
<
+-----------+-------+-------+-------+-----------+
|+-+-+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+-+-+|
||H|e|l|l|o|||H|o|w|||A|r|e|||Y|o|u|||T|o|d|a|y||
|+-+-+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+-+-+|
+-----------+-------+-------+-------+-----------+</
Join string with <code>.</code> and remove last <code>.</code>
<
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|H|e|l|l|o|.|H|o|w|.|A|r|e|.|Y|o|u|.|T|o|d|a|y|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+</
Less cluttered display, using <code>set "sketch;set "nodecor</code> display switches.
<
Hello,How,Are,You,Today
t:= s eachall = `, cut s
Line 2,043 ⟶ 2,717:
+-----+---+---+---+-----+
u:=front content (cart t `.)
Hello.How.Are.You.Today</syntaxhighlight>
Or as a one-liner:
<syntaxhighlight lang="nial">
front content (cart (s eachall = `, cut s) `.)
</syntaxhighlight>
=={{header|Nim}}==
<
let text = "Hello,How,Are,You,Today"
let tokens = text.split(',')
echo tokens.join(".")</
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|Objeck}}==
<
class Parse {
function : Main(args : String[]) ~ Nil {
Line 2,061 ⟶ 2,745:
};
}
}</
=={{header|Objective-C}}==
Line 2,068 ⟶ 2,752:
{{works with|Cocoa}}
<
NSArray *tokens = [text componentsSeparatedByString:@","];
NSString *result = [tokens componentsJoinedByString:@"."];
NSLog(result);</
=={{header|OCaml}}==
To split on a single-character separator:
<
String.concat "." words
</syntaxhighlight>
The function split_on_char has been introduced in OCaml 4.04. In previous versions, it could be implemented by:
<
let r = ref [] in
let j = ref (String.length s) in
Line 2,090 ⟶ 2,774:
end
done;
String.sub s 0 !j :: !r</
=={{header|Oforth}}==
<
{{out}}
Line 2,102 ⟶ 2,786:
=={{header|ooRexx}}==
<
do while text \= ''
parse var text word1 ',' text
call charout 'STDOUT:',word1'.'
end</
{{out}}
<pre>Hello.How.Are.You.Today.</pre>
=={{header|OpenEdge/Progress}}==
<
i_c AS CHAR
):
Line 2,134 ⟶ 2,818:
MESSAGE
tokenizeString( "Hello,How,Are,You,Today" )
VIEW-AS ALERT-BOX.</
{{out}}
<pre>
Line 2,147 ⟶ 2,831:
=={{header|Oz}}==
<
{System.printInfo T#"."}
end</
=={{header|PARI/GP}}==
Line 2,159 ⟶ 2,843:
{{Works with|PARI/GP|2.7.4 and above}}
<
\\ Tokenize a string str according to 1 character delimiter d. Return a list of tokens.
\\ Using ssubstr() from http://rosettacode.org/wiki/Substring#PARI.2FGP
Line 2,177 ⟶ 2,861:
print("3.",tokenize(",Hello,,How,Are,You,Today",","));
}
</
{{Output}}
Line 2,195 ⟶ 2,879:
{{Works with|PARI/GP|2.7.4 and above}}
<
\\ Tokenize a string str according to 1 character delimiter d. Return a list of tokens.
\\ Using ssubstr() from http://rosettacode.org/wiki/Substring#PARI.2FGP
Line 2,224 ⟶ 2,908:
print("7. 0 pp: ", stok("",","));
}
</
{{Output}}
Line 2,240 ⟶ 2,924:
=={{header|Pascal}}==
{{works with|Free_Pascal}}
<
{$mode objfpc}{$H+}
Line 2,264 ⟶ 2,948:
Tokens.Free;
end;
end.</
The result is:
Line 2,271 ⟶ 2,955:
=={{header|Perl}}==
<
CLI one-liner form:
<
which is a compact way of telling Perl to do
<
LINE: while (defined($_ = <ARGV>)) {
chomp $_;
Line 2,284 ⟶ 2,968:
continue {
die "-p destination: $!\n" unless print $_;
}</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Hello,How,Are,You,Today"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">","</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"."</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{Out}}
<pre>
Line 2,294 ⟶ 2,980:
=={{header|Phixmonti}}==
<
"Hello,How,Are,You,Today" "," " " subst split len for get print "." print endfor</
=={{header|PHP}}==
{{works with|PHP|5.x}}
<
$str = 'Hello,How,Are,You,Today';
echo implode('.', explode(',', $str));
?></
=={{header|Picat}}==
Using the built-in functions <code>split/2</code> and <code>join/2</code>.
<syntaxhighlight lang="picat">import util.
go =>
S = "Hello,How,Are,You,Today",
T = S.split(","),
println(T),
T.join(".").println(),
% As a one liner:
S.split(",").join(".").println().</syntaxhighlight>
{{out}}
<pre>[Hello,How,Are,You,Today]
Hello.How.Are.You.Today
Hello.How.Are.You.Today</pre>
=={{header|PicoLisp}}==
<
(split (chop "Hello,How,Are,You,Today") ",") )</
=={{header|Pike}}==
<
=={{header|PL/I}}==
<
declare s character (100) initial ('Hello,How,Are,You,Today');
declare n fixed binary (31);
Line 2,335 ⟶ 3,039:
put skip list (string(table));
end;
end;</
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|PL/M}}==
<syntaxhighlight lang="plm">100H:
/* CP/M CALLS */
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
/* SPLIT A STRING ON CHARACTER 'SEP'.
THE 'PARTS' ARRAY WILL CONTAIN POINTERS TO THE START OF EACH ELEMENT.
THE AMOUNT OF PARTS IS RETURNED.
*/
TOKENIZE: PROCEDURE (SEP, STR, PARTS) ADDRESS;
DECLARE SEP BYTE, (STR, PARTS) ADDRESS;
DECLARE (N, P BASED PARTS) ADDRESS;
DECLARE CH BASED STR BYTE;
N = 0;
LOOP:
P(N) = STR;
N = N + 1;
DO WHILE CH <> '$' AND CH <> SEP;
STR = STR + 1;
END;
IF CH = '$' THEN RETURN N;
CH = '$';
STR = STR + 1;
GO TO LOOP;
END TOKENIZE;
/* TEST ON THE GIVEN INPUT */
DECLARE HELLO (24) BYTE INITIAL ('HELLO,HOW,ARE,YOU,TODAY$');
DECLARE PARTS (10) ADDRESS;
DECLARE (I, LEN) ADDRESS;
LEN = TOKENIZE(',', .HELLO, .PARTS);
DO I = 0 TO LEN-1;
CALL PRINT(PARTS(I));
CALL PRINT(.'. $');
END;
CALL EXIT;
EOF;</syntaxhighlight>
{{out}}
<pre>HELLO. HOW. ARE. YOU. TODAY. </pre>
=={{header|Plain English}}==
<
Start up.
Split "Hello,How,Are,You,Today" into some string things given the comma byte.
Line 2,356 ⟶ 3,104:
If the string thing's next is not nil, append the byte to the string.
Put the string thing's next into the string thing.
Repeat.</
{{out}}
<pre>
Line 2,369 ⟶ 3,117:
First show the use of sysparse_string to break up a string and make a list of strings.
<
lvars list;
sysparse_string('the cat sat on the mat') -> list;
;;; print the list of strings
list =>
** [the cat sat on the mat]</
By giving it an extra parameter 'true' we can make it recognize numbers and produce a list of strings and numbers
<
sysparse_string('one 1 two 2 three 3 four 4', true) -> list;
;;; print the list of strings and numbers
Line 2,387 ⟶ 3,135:
** <true>
isinteger(list(2))=>
** <true></
Now show some uses of the built in procedure sys_parse_string, which allows more options:
<
true -> pop_pr_quotes;
;;;
Line 2,405 ⟶ 3,153:
;;; print the list of strings
strings =>
** ['Hello' 'How' 'Are' 'You' 'Today']</
If {% ... %} were used instead of [% ... %] the result would be
a vector (i.e. array) of strings rather than a list of strings.
<
;;; print the vector
strings =>
** {'Hello' 'How' 'Are' 'You' 'Today'}</
It is also possible to give sys_parse_string a 'conversion' procedure, which is applied to each of the tokens.
E.g. it could be used to produce a vector of numbers, using the conversion procedure 'strnumber', which converts a string to a number:
<
{% sys_parse_string('100 101 102 103 99.9 99.999', strnumber) %} -> numbers;
;;; the result is a vector containing integers and floats,
;;; which can be printed thus:
numbers =>
** {100 101 102 103 99.9 99.999}</
Using lower level pop-11 facilities to tokenise the string:
<
lvars str='Hello,How,Are,You,Today';
;;; Iterate over string
Line 2,444 ⟶ 3,192:
endif;
;;; Reverse the list
rev(ls) -> ls;</
Since the task requires to use array we convert list to array
<
destlist(ls);
;;; Build a vector from them
Line 2,456 ⟶ 3,204:
printf(ar(i), '%s.');
endfor;
printf('\n');</
We could use list directly for printing:
<
printf(i, '%s.');
endfor;</
so the conversion to vector is purely to satisfy task formulation.
Line 2,468 ⟶ 3,216:
=={{header|PowerShell}}==
{{works with|PowerShell|1}}
<
[string]::Join('.', $words)</
{{works with|PowerShell|2}}
<
$words -join '.'</
{{works with|PowerShell|2}}
The StringSplitOptions enumeration weeds out the return of empty elements.
<syntaxhighlight lang="powershell">
"Hello,How,Are,You,Today", ",,Hello,,Goodbye,," | ForEach-Object {($_.Split(',',[StringSplitOptions]::RemoveEmptyEntries)) -join "."}
</syntaxhighlight>
{{Out}}
<pre>
Line 2,488 ⟶ 3,236:
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<
splitup(Sep,[A|AL],B) --> [A], {\+ [A] = Sep }, splitup(Sep,AL,B).
splitup(Sep,[],[B|BL]) --> Sep, splitup(Sep,B,BL).
Line 2,496 ⟶ 3,244:
phrase(splitup(".",Tokens),Backtogether),
string_to_list(ABack,Backtogether),
writeln(ABack).</
{{out}}
<pre>
Line 2,508 ⟶ 3,256:
this can be accomplished in a few lines in the top level:
<
?- split_string("Hello,How,Are,You,Today", ",", "", Split),
| atomics_to_string(Split, ".", PeriodSeparated),
| writeln(PeriodSeparated).
Hello.How.Are.You.Today
</syntaxhighlight>
=={{header|Python}}==
{{works with|Python|2.5}}{{works with|Python|3.0}}
<
tokens = text.split(',')
print ('.'.join(tokens))</
Or if interpretation of the task description means you don't need to keep an intermediate array:
<
=={{header|Q}}==
<
"." sv words</
{{out}}
Line 2,534 ⟶ 3,282:
=={{header|QB64}}==
''CBTJD'': 2020/03/12
<
FOR na = 1 TO LEN(a$) ' | Start loop to count number of commas.
IF MID$(a$, na, 1) = "," THEN nc = nc + 1 ' | For each comma, increment nc.
Line 2,552 ⟶ 3,300:
PRINT LEFT$(tf$, LEN(tf$) - 1) ' | Print all but the last period of tf$.
END ' | Program end.
</syntaxhighlight>
'''Alternative method using word$ function:'''
----
''CBTJD'': 2020/03/12
<
DIM t$(LEN(a$) / 2) ' | Create an overestimated sized array.
FOR nd = 1 TO LEN(a$) ' | Start loop to find each comma.
Line 2,585 ⟶ 3,333:
DONE: ' | Label for bail destination of word count error check.
END FUNCTION ' | End of function.
</syntaxhighlight>
=={{header|Quackery}}==
<
witheach
[ dup char , = iff
Line 2,598 ⟶ 3,346:
[ witheach [ echo$ say "." ] ] is display ( [ --> )
$ "Hello,How,Are,You,Today" tokenise display</
{{Out}}
Line 2,605 ⟶ 3,353:
=={{header|R}}==
<
junk <- strsplit(text, split=",")
print(paste(unlist(junk), collapse="."))</
or the one liner
<
=={{header|Racket}}==
<
#lang racket
(string-join (string-split "Hello,How,Are,You,Today" ",") ".")
;; -> "Hello.How.Are.You.Today"
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|#22 "Thousand Oaks"}}
<syntaxhighlight lang="raku"
Or with function calls:
<syntaxhighlight lang="raku"
=={{header|Raven}}==
<
=={{header|REBOL}}==
<
tokens: parse original ","
dotted: "" repeat i tokens [append dotted rejoin [i "."]]
print ["Dotted: " dotted]</
{{out}}
Line 2,646 ⟶ 3,394:
=={{header|Red}}==
<
>> tokens: split str ","
>> probe tokens
Line 2,653 ⟶ 3,401:
>> periods: replace/all form tokens " " "." ;The word FORM converts the list series to a string removing quotes.
>> print periods ;then REPLACE/ALL spaces with period
Hello.How.Are.You.Today</
=={{header|Retro}}==
<syntaxhighlight lang="retro">{{
: char ( -$ ) " " ;
: tokenize ( $-$$ )
Line 2,668 ⟶ 3,416:
[ tokenize action dup 1 <> ] while drop
^buffer'get drop ;
}}</
This will suffice to split a string into an array of substrings. It is used like this:
<
"Hello,How,Are,You,Today" ', strings split</
Since the buffer' vocabulary creates a zero-terminated buffer, we can display it using the each@ combinator and a simple quote:
<
=={{header|REXX}}==
===version 1===
This REXX version doesn't append a period to the last word in the list.
<
original = 'Hello,How,Are,You,Today' /*some words separated by commas (,). */
say 'The input string:' original /*display original string ──► terminal.*/
Line 2,694 ⟶ 3,442:
say @.j || left(., j\==#) /*maybe append a period (.) to a word. */
end /*j*/ /* [↑] don't append a period if last. */
say center(' End─of─list ', 40, "═") /*display a (EOL) trailer for the list.*/</
{{out|output|text= when using the internal default input:}}
<pre>
Line 2,712 ⟶ 3,460:
Hello,Betty Sue,How,Are,You,Today
<
sss='Hello,How,Are,You,Today'
say 'input string='sss
Line 2,723 ⟶ 3,471:
say word(ss,i)dot
End
say 'End-of-list.'</
'''output''' is similar to REXX version 1.
=={{header|Ring}}==
<
see substr("Hello,How,Are,You,Today", ",", ".")
</syntaxhighlight>
=={{header|RPL}}==
The program below fully complies with the task requirements, e.g. the input string is converted to a list of words, then the list is converted to a string.
{{works with|Halcyon Calc|4.2.8}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪
"}" + "{" SWAP + STR→
1 OVER SIZE '''FOR''' j
DUP j GET →STR 2 OVER SIZE 1 - SUB j SWAP PUT
'''NEXT'''
"" 1 3 PICK SIZE '''FOR''' j
OVER j GET +
'''IF''' OVER SIZE j ≠ '''THEN''' "." + '''END'''
'''NEXT''' SWAP DROP
≫ '<span style="color:blue">'''TOKNZ'''</span>' STO
|
<span style="color:blue">'''TOKNZ'''</span> ''<span style="color:grey">( "word,word" → "word.word" )</span> ''
convert string into list (words being between quotes)
loop for each list item
convert it to a string, remove quotes at beginning and end
loop for each list item
add item to output string
if not last item, append "."
clean stack
return output string
|}
"Hello,How,Are,You,Today" <span style="color:blue">'''TOKNZ'''</span>
</pre>
'''Output:'''
<span style="color:grey"> 1:</span> "Hello.How.Are.You.Today"
If direct string-to-string conversion is allowed, then this one-liner for HP-48+ will do the job:
≪ 1 OVER SIZE '''FOR''' j '''IF''' DUP j DUP SUB "," == '''THEN''' j "." REPL '''END NEXT''' ≫ '<span style="color:blue">'''TOKNZ'''</span>' STO
=={{header|Ruby}}==
<
=={{header|Rust}}==
<
let s = "Hello,How,Are,You,Today";
let tokens: Vec<&str> = s.split(",").collect();
println!("{}", tokens.join("."));
}</
=={{header|S-lang}}==
<
print(strjoin(a, "."));</
{{out}}
Line 2,749 ⟶ 3,535:
=={{header|Scala}}==
<
=={{header|Scheme}}==
{{works with|Guile}}
<
(define s "Hello,How,Are,You,Today")
(define words (map match:substring (list-matches "[^,]+" s)))
Line 2,760 ⟶ 3,546:
(display (list-ref words n))
(if (< n (- (length words) 1))
(display ".")))</
(with SRFI 13)
<
(define words (string-tokenize s (char-set-complement (char-set #\,))))
(define t (string-join words "."))</
{{works with|Gauche Scheme}}
<
(string-join
(string-split "Hello,How,Are,You,Today" #\,)
".")) </
{{output}}
<pre>
Line 2,778 ⟶ 3,564:
=={{header|Seed7}}==
<
tokens := split("Hello,How,Are,You,Today", ",");</
=={{header|Self}}==
<
((s splitOn: ',') joinUsing: '.') printLine.
</syntaxhighlight>
=={{header|Sidef}}==
<
=={{header|Simula}}==
<
CLASS TEXTARRAY(N); INTEGER N;
Line 2,840 ⟶ 3,626:
END.
</syntaxhighlight>
{{out}}
<pre>HELLO.HOW.ARE.YOU.TODAY.</pre>
=={{header|Slate}}==
<
=={{header|Slope}}==
<syntaxhighlight lang="slope">(display
(list->string
(string->list
"Hello,How,Are,You,Today"
",")
"."))</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|Smalltalk}}==
<
array := 'Hello,How,Are,You,Today' subStrings: $,.
array fold: [:concatenation :string | concatenation, '.', string ]</
Some implementations also have a ''join:'' convenience method that allows the following shorter solution:
<
The solution displaying a trailing period would be:
<
array := 'Hello,How,Are,You,Today' subStrings: $,.
array inject: '' into: [:concatenation :string | concatenation, string, '.' ]</
=={{header|SNOBOL4}}==
Line 2,866 ⟶ 3,662:
For this task, it's convenient to define Perl-style split( ) and join( ) functions.
<
split t = table()
sp1 str pos(0) (break(chs) | rem) $ t<i = i + 1>
Line 2,882 ⟶ 3,678:
* # Test and display
output = join('.',split(',','Hello,How,Are,You,Today'))
end</
{{out}}
Line 2,890 ⟶ 3,686:
=={{header|Standard ML}}==
<
val main = (String.concatWith ".") o splitter;</
Test:
<
val it = "Hello.How.Are.You.Today" : string</
=={{header|Swift}}==
{{works with|Swift|3.x}}
<
let tokens = text.components(separatedBy: ",") // for single or multi-character separator
print(tokens)
let result = tokens.joined(separator: ".")
print(result)</
{{works with|Swift|2.x}}
<
let tokens = text.characters.split(",").map{String($0)} // for single-character separator
print(tokens)
let result = tokens.joinWithSeparator(".")
print(result)</
{{works with|Swift|1.x}}
<
let tokens = split(text, { $0 == "," }) // for single-character separator
println(tokens)
let result = ".".join(tokens)
println(result)</
For multi-character separators:<
let text = "Hello,How,Are,You,Today"
let tokens = text.componentsSeparatedByString(",")
print(tokens)</
=={{header|Tcl}}==
Generating a list form a string by splitting on a comma:
<
Joining the elements of a list by a period:
<
Thus the whole thing would look like this:
<
If you'd like to retain the list in a variable with the name "words", it would only be marginally more complex:
<
(In general, the <tt>regexp</tt> command is also used in Tcl for tokenization of strings, but this example does not need that level of complexity.)
Line 2,945 ⟶ 3,741:
<code>tr</code> knows nothing about arrays, so this solution only changes each comma to a period.
<
=={{header|Transd}}==
<syntaxhighlight lang="Scheme">#lang transd
MainModule: {
_start: (lambda locals: s "Hello,How,Are,You,Today"
(textout (join (split s ",") "."))
)
}</syntaxhighlight>
{{out}}
<pre>
Hello.How.Are.You.Today
</pre>
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
SET string="Hello,How,Are,You,Today"
SET string=SPLIT (string,":,:")
SET string=JOIN (string,".")
</syntaxhighlight>
=={{header|TXR}}==
Line 2,960 ⟶ 3,769:
sequences of non-commas.
<
@(coll)@{token /[^,]+/}@(end)
@(output)
@(rep)@token.@(last)@token@(end)
@(end)</
Different approach. Collect tokens, each of
Line 2,970 ⟶ 3,779:
before a comma, or else extends to the end of the line.
<
@(coll)@(maybe)@token,@(or)@token@(end)@(end)
@(output)
@(rep)@token.@(last)@token@(end)
@(end)</
Using TXR Lisp:
<
Hello.How.Are.You.Today</
=={{header|UNIX Shell}}==
{{works with|Bourne Shell}}
<
(IFS=,
printf '%s.' $string
echo)</
----
{{works with|Bourne Again SHell}}
{{works with|Public Domain Korn SHell|5.2.14}}
<
stripchar-l ()
#removes the specified character from the left side of the string
Line 3,049 ⟶ 3,858:
join "$( split "$list" "$input_delimiter" )" \
"$contains_a_space" "$output_delimiter";
}</
''Example''
<
Hello.How.Are.You.Today </
----
Line 3,062 ⟶ 3,871:
{{works with|ksh93}}
{{works with|zsh}}
<syntaxhighlight lang="sh">
string1="Hello,How,Are,You,Today"
elements_quantity=$(echo $string1|tr "," "\n"|wc -l)
Line 3,075 ⟶ 3,884:
# or to cheat
echo "Hello,How,Are,You,Today"|tr "," "."</
=={{header|UnixPipes}}==
{{works with|Bourne Shell}}
<
(IFS=, read -r A B; echo "$A".; test -n "$B" && (echo "$B" | token))
}
echo "Hello,How,Are,You" | token</
=={{header|Ursa}}==
<
set text "Hello,How,Are,You,Today"
decl string<> tokens
Line 3,093 ⟶ 3,902:
out tokens<i> "." console
end for
out endl console</
=={{header|Ursala}}==
Line 3,101 ⟶ 3,910:
second order function parameterized by the delimiter. Character
literals are preceded by a backquote.
<
token_list = sep`, 'Hello,How,Are,You,Today'
Line 3,107 ⟶ 3,916:
#cast %s
main = mat`. token_list</
{{out}}
<pre>
Line 3,114 ⟶ 3,923:
=={{header|Vala}}==
<
string s = "Hello,How,Are,You,Today";
print(@"$(string.joinv(".", s.split(",")))");
}</
{{out}}
<pre>Hello.How.Are.You.Today</pre>
=={{header|VBA}}==
<
Dim temp() As String
temp = Tokenize("Hello,How,Are,You,Today", ",")
Line 3,134 ⟶ 3,943:
Private Sub Display(arr() As String, sep As String)
Debug.Print Join(arr, sep)
End Sub</
{{Out}}
<pre>Hello How Are You Today</pre>
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
s = "Hello,How,Are,You,Today"
WScript.StdOut.Write Join(Split(s,","),".")
</syntaxhighlight>
{{Out}}
<pre>Hello.How.Are.You.Today</pre>
Line 3,152 ⟶ 3,961:
The contents of each text register is then displayed to user, separated by a period.
<
Ins_Text("Hello,How,Are,You,Today")
Line 3,171 ⟶ 3,980:
}
Buf_Quit(OK)</
=={{header|V (Vlang)}}==
<syntaxhighlight lang="go">// Tokenize a string, in V (Vlang)
// Tectonics: v run tokenize-a-string.v
module main
// starts here
pub fn main() {
println("Hello,How,Are,You,Today".split(',').join('.'))
}</syntaxhighlight>
{{out}}
<pre>prompt$ v run rosetta/tokenize-a-string.v
Hello.How.Are.You.Today</pre>
=={{header|WinBatch}}==
<
result = ''
BoxOpen('WinBatch Tokenizing Example', '')
Line 3,183 ⟶ 4,005:
next
display(10, 'End of Program', 'Dialog and program will close momentarily.')
BoxShut()</
{{out}}
Line 3,189 ⟶ 4,011:
=={{header|Wortel}}==
<
Returns
<pre>"Hello.How.Are.You.Today"</pre>
=={{header|Wren}}==
<
var t = s.split(",").join(".") + "."
System.print(t)</
{{out}}
Line 3,204 ⟶ 4,026:
=={{header|XPath 2.0}}==
<
{{out}}
Line 3,210 ⟶ 4,032:
=={{header|XPL0}}==
<
include c:\cxpl\codes;
int I, J, K, Char;
Line 3,229 ⟶ 4,051:
for K:= 4 downto 0 do [Text(0, addr Array(K,0)); ChOut(0, ^.)];
CrLf(0);
]</
The 'addr' operator is used to fetch the 32-bit address of Array rather
Line 3,240 ⟶ 4,062:
=={{header|Yabasic}}==
<
n = token("Hello. How are you today?", s$(), ".? ")
Line 3,248 ⟶ 4,070:
if i < n print ".";
next
print</
=={{header|Zig}}==
<syntaxhighlight lang="zig">const std = @import("std");
pub fn main() void {
const string = "Hello,How,Are,You,Today";
var tokens = std.mem.split(u8, string, ",");
std.debug.print("{s}", .{tokens.next().?});
while (tokens.next()) |token| {
std.debug.print(".{s}", .{token});
}
}</syntaxhighlight>
=={{header|zkl}}==
<
Hello.How.Are.You.Today</
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: tokenize_a_string
input: "Hello,How,Are,You,Today"
output: "Hello.How.Are.You.Today"
</syntaxhighlight>
=={{header|Zoea Visual}}==
[http://zoea.co.uk/examples/zv-rc/Tokenize_string.png Tokenize a string]
=={{header|Zsh}}==
<
tokens=(${(s:,:)str})
print ${(j:.:)tokens}</
Or, using SH_SPLIT_WORD:
<
IFS=, echo ${(j:.:)${=str}}</
{{omit from|PARI/GP|No real capacity for string manipulation}}
|