Tokenize a string: Difference between revisions

From Rosetta Code
Content added Content deleted
No edit summary
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(298 intermediate revisions by more than 100 users not shown)
Line 1: Line 1:
{{task|String manipulation}}
{{task|String manipulation}}
[[Category:Simple]]
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. Display the words to the 'user', in the simplest manner possible, separated by a period. To simplify, you may display a trailing period.

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.

Display the words to the 'user', in the simplest manner possible, separated by a period.

To simplify, you may display a trailing period.


{{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}}==
<syntaxhighlight lang="360asm">* Tokenize a string - 08/06/2018
TOKSTR CSECT
USING TOKSTR,R13 base register
B 72(R15) skip savearea
DC 17F'0' savearea
SAVE (14,12) save previous context
ST R13,4(R15) link backward
ST R15,8(R13) link forward
LR R13,R15 set addressability
MVC N,=A(1) n=1
LA R7,1 i1=1
LA R6,1 i=1
DO WHILE=(C,R6,LE,LENS) do i=1 to length(s);
LA R4,S-1 @s-1
AR R4,R6 +i
MVC C,0(R4) c=substr(s,i,1)
IF CLI,C,EQ,C',' THEN if c=',' then do
BAL R14,TOK call tok
LR R2,R8 i2
SR R2,R7 i2-i1
LA R2,1(R2) i2-i1+1
L R1,N n
SLA R1,1 *2
STH R2,TALEN-2(R1) talen(n)=i2-i1+1
L R2,N n
LA R2,1(R2) n+1
ST R2,N n=n+1
LA R7,1(R6) i1=i+1
ENDIF , endif
LA R6,1(R6) i++
ENDDO , enddo i
BAL R14,TOK call tok
LR R2,R8 i2
SR R2,R7 i2-i1
LA R2,1(R2) i2-i1+1
L R1,N n
SLA R1,1 *2
STH R2,TALEN-2(R1) talen(n)=i2-i1+1
LA R11,PG pgi=@pg
LA R6,1 i=1
DO WHILE=(C,R6,LE,N) do i=1 to n
LR R1,R6 i
SLA R1,1 *2
LH R10,TALEN-2(R1) l=talen(i)
LR R1,R6 i
SLA R1,3 *8
LA R4,TABLE-8(R1) @table(i)
LR R2,R10 l
BCTR R2,0 ~
EX R2,MVCX output table(i) length(l)
AR R11,R10 pgi=pgi+l
IF C,R6,NE,N THEN if i^=n then
MVC 0(1,R11),=C'.' output '.'
LA R11,1(R11) pgi=pgi+1
ENDIF , endif
LA R6,1(R6) i++
ENDDO , enddo i
XPRNT PG,L'PG print
L R13,4(0,R13) restore previous savearea pointer
RETURN (14,12),RC=0 restore registers from calling sav
TOK LR R5,R6 i <--
BCTR R5,0 i-1 |
LR R8,R5 i2=i-1
SR R5,R7 i2-i1
LA R5,1(R5) l=i2-i1+1 source length
L R1,N n
SLA R1,3 *8
LA R2,TABLE-8(R1) @table(n)
LA R4,S-1 @s-1
AR R4,R7 @s+i1-1
LA R3,8 target length
MVCL R2,R4 table(n)=substr(s,i1,i2-i1+1) |
BR R14 End TOK subroutine <--
MVCX MVC 0(0,R11),0(R4) output table(i)
S DC CL80'Hello,How,Are,You,Today' <== input string ==
LENS DC F'23' length(s) <==
TABLE DC 8CL8' ' table(8)
TALEN DC 8H'0' talen(8)
C DS CL1 char
N DS F number of tokens
PG DC CL80' ' buffer
YREGS
END TOKSTR</syntaxhighlight>
{{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 */

/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ NBPOSTESECLAT, 20

/*******************************************/
/* Initialized data */
/*******************************************/
.data
szMessFinal: .asciz "Words are : \n"
szString: .asciz "Hello,How,Are,You,Today"
szMessError: .asciz "Error tokenize !!\n"
szCarriageReturn: .asciz "\n"
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main:
ldr x0,qAdrszString // string address
mov x1,',' // separator
bl stTokenize
cmp x0,-1 // error ?
beq 99f
mov x2,x0 // table address
ldr x0,qAdrszMessFinal // display message
bl affichageMess
ldr x4,[x2] // number of areas
add x2,x2,8 // first area
mov x3,0 // loop counter
mov x0,x2
1: // display loop
ldr x0,[x2,x3, lsl 3] // address area
bl affichageMess
ldr x0,qAdrszCarriageReturn // display carriage return
bl affichageMess
add x3,x3,1 // counter + 1
cmp x3,x4 // end ?
blt 1b // no -> loop
b 100f
99: // display error message
ldr x0,qAdrszMessError
bl affichageMess
100: // standard end of the program
mov x0,0 // return code
mov x8,EXIT // request to exit program
svc 0 // perform the system call
qAdrszString: .quad szString
//qAdrszFinalString: .quad szFinalString
qAdrszMessFinal: .quad szMessFinal
qAdrszMessError: .quad szMessError
qAdrszCarriageReturn: .quad szCarriageReturn

/*******************************************************************/
/* Separate string by separator into an array */
/* areas are store on the heap Linux */
/*******************************************************************/
/* x0 contains string address */
/* x1 contains separator character (, or . or : ) */
/* x0 returns table address with first item = number areas */
/* and other items contains pointer of each string */
stTokenize:
stp x1,lr,[sp,-16]! // save registers
mov x16,x0
mov x9,x1 // save separator
mov x14,0
1: // compute length string for place reservation on the heap
ldrb w12,[x0,x14]
cbz x12, 2f
add x14,x14,1
b 1b
2:
ldr x12,qTailleTable
add x15,x12,x14
and x15,x15,0xFFFFFFFFFFFFFFF0
add x15,x15,16 // align word on the heap
// place reservation on the heap
mov x0,0 // heap address
mov x8,BRK // call system linux 'brk'
svc 0 // call system
cmp x0,-1 // error call system
beq 100f
mov x14,x0 // save address heap begin = begin array
add x0,x0,x15 // reserve x15 byte on the heap
mov x8,BRK // call system linux 'brk'
svc 0
cmp x0,-1
beq 100f
// string copy on the heap
add x13,x14,x12 // behind the array
mov x0,x16
mov x1,x13
3: // loop copy string
ldrb w12,[x0],1 // read one byte and increment pointer one byte
strb w12,[x1],1 // store one byte and increment pointer one byte
cbnz x12,3b // end of string ? no -> loop
mov x0,#0
str x0,[x14]
str x13,[x14,8]
mov x12,#1 // areas counter
4: // loop load string character
ldrb w0,[x13]
cbz x0,5f // end string
cmp x0,x9 // separator ?
cinc x13,x13,ne // no -> next location
bne 4b // and loop
strb wzr,[x13] // store zero final of string
add x13,x13,1 // next character
add x12,x12,1 // areas counter + 1
str x13,[x14,x12, lsl #3] // store address area in the table at index x2
b 4b // and loop
5:
str x12,[x14] // store number areas
mov x0,x14 // returns array address
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qTailleTable: .quad 8 * NBPOSTESECLAT

/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
{{Output}}
<pre>
Words are :
Hello
How
Are
You
Today
</pre>

=={{header|ACL2}}==
<syntaxhighlight lang="lisp">(defun split-at (xs delim)
(if (or (endp xs) (eql (first xs) delim))
(mv nil (rest xs))
(mv-let (before after)
(split-at (rest xs) delim)
(mv (cons (first xs) before) after))))

(defun split (xs delim)
(if (endp xs)
nil
(mv-let (before after)
(split-at xs delim)
(cons before (split after delim)))))

(defun css->strs (css)
(if (endp css)
nil
(cons (coerce (first css) 'string)
(css->strs (rest css)))))

(defun split-str (str delim)
(css->strs (split (coerce str 'list) delim)))

(defun print-with (strs delim)
(if (endp strs)
(cw "~%")
(progn$ (cw (first strs))
(cw (coerce (list delim) 'string))
(print-with (rest strs) delim))))</syntaxhighlight>

{{out}}
<pre>&gt; (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}}==
=={{header|ActionScript}}==
<lang actionscript>var hello:String = "Hello,How,Are,You,Today";
<syntaxhighlight lang="actionscript">var hello:String = "Hello,How,Are,You,Today";
var tokens:Array = hello.split(",");
var tokens:Array = hello.split(",");
trace(tokens.join("."));
trace(tokens.join("."));


// Or as a one-liner
// Or as a one-liner
trace("Hello,How,Are,You,Today".split(",").join("."));</lang>
trace("Hello,How,Are,You,Today".split(",").join("."));</syntaxhighlight>


=={{header|Ada}}==
=={{header|Ada}}==
<lang ada>with Ada.Strings.Fixed; use Ada.Strings.Fixed;
<syntaxhighlight lang="ada">with Ada.Text_IO, Ada.Containers.Indefinite_Vectors, Ada.Strings.Fixed, Ada.Strings.Maps;
use Ada.Text_IO, Ada.Containers, Ada.Strings, Ada.Strings.Fixed, Ada.Strings.Maps;
with Ada.Text_Io; use Ada.Text_Io;


procedure Parse_Commas is
procedure Tokenize is
package String_Vectors is new Indefinite_Vectors (Positive, String);
Source_String : String := "Hello,How,Are,You,Today";
use String_Vectors;
Index_List : array(1..256) of Natural;
Next_Index : Natural := 1;
Input : String := "Hello,How,Are,You,Today";
Start : Positive := Input'First;
Finish : Natural := 0;
Output : Vector := Empty_Vector;
begin
begin
while Start <= Input'Last loop
Index_List(Next_Index) := 1;
Find_Token (Input, To_Set (','), Start, Outside, Start, Finish);
while Index_List(Next_Index) < Source_String'Last loop
Next_Index := Next_Index + 1;
exit when Start > Finish;
Output.Append (Input (Start .. Finish));
Index_List(Next_Index) := 1 + Index(Source_String(Index_List(Next_Index - 1)..Source_String'Last), ",");
if Index_List(Next_Index) = 1 then
Start := Finish + 1;
Index_List(Next_Index) := Source_String'Last + 2;
end if;
Put(Source_String(Index_List(Next_Index - 1)..Index_List(Next_Index)-2) & ".");
end loop;
end loop;
for S of Output loop
end Parse_Commas;</lang>
Put (S & ".");
end loop;
end Tokenize;</syntaxhighlight>

=={{header|ALGOL 68}}==
=={{header|ALGOL 68}}==
<lang algol68>main:(
<syntaxhighlight lang="algol68">main:(


OP +:= = (REF FLEX[]STRING in out, STRING item)VOID:(
OP +:= = (REF FLEX[]STRING in out, STRING item)VOID:(
Line 52: Line 559:
out
out
);
);

PROC char split = (REF STRING beetles, STRING chars)[]STRING: (
PROC char split = (REF STRING beetles, STRING chars)[]STRING: (
""" Split beetles where character is found in chars """;
""" Split beetles where character is found in chars """;
Line 78: Line 585:
printf(($g"."$, string split(beetles, ", "),$l$));
printf(($g"."$, string split(beetles, ", "),$l$));
printf(($g"."$, char split(beetles, ", "),$l$))
printf(($g"."$, char split(beetles, ", "),$l$))
)</lang>
)</syntaxhighlight>
{{out}}
Output:<pre>
<pre>
John Lennon.Paul McCartney.George Harrison.Ringo Starr.
John.Lennon..Paul.McCartney..George.Harrison..Ringo.Starr.
John Lennon.Paul McCartney.George Harrison.Ringo Starr.
John.Lennon..Paul.McCartney..George.Harrison..Ringo.Starr.
</pre>
</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}}==
<syntaxhighlight lang="apl"> '.',⍨¨ ','(≠⊆⊢)'abc,123,X' ⍝ [1] Do the split: ','(≠⊆⊢)'abc,123,X'; [2] append the periods: '.',⍨¨
abc. 123. X. ⍝ 3 strings (char vectors), each with a period at the end.
</syntaxhighlight>

=={{header|AppleScript}}==

<syntaxhighlight lang="applescript">on run
intercalate(".", splitOn(",", "Hello,How,Are,You,Today"))
end run
-- splitOn :: String -> String -> [String]
on splitOn(strDelim, strMain)
set {dlm, my text item delimiters} to {my text item delimiters, strDelim}
set lstParts to text items of strMain
set my text item delimiters to dlm
return lstParts
end splitOn
-- intercalate :: String -> [String] -> String
on intercalate(strText, lstText)
set {dlm, my text item delimiters} to {my text item delimiters, strText}
set strJoined to lstText as text
set my text item delimiters to dlm
return strJoined
end intercalate</syntaxhighlight>
{{Out}}
<pre>Hello.How.Are.You.Today</pre>

Or,

<syntaxhighlight lang="applescript">set my text item delimiters to ","
set tokens to the text items of "Hello,How,Are,You,Today"

set my text item delimiters to "."
log tokens as text</syntaxhighlight>

{{Out}}

<pre>Hello.How.Are.You.Today</pre>

=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">

/* ARM assembly Raspberry PI */
/* program strTokenize.s */

/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall

.equ NBPOSTESECLAT, 20

/* Initialized data */
.data
szMessFinal: .asciz "Words are : \n"

szString: .asciz "Hello,How,Are,You,Today"
szMessError: .asciz "Error tokenize !!\n"
szCarriageReturn: .asciz "\n"

/* UnInitialized data */
.bss

/* code section */
.text
.global main
main:
ldr r0,iAdrszString @ string address
mov r1,#',' @ separator
bl stTokenize
cmp r0,#-1 @ error ?
beq 99f
mov r2,r0 @ table address
ldr r0,iAdrszMessFinal @ display message
bl affichageMess
ldr r4,[r2] @ number of areas
add r2,#4 @ first area
mov r3,#0 @ loop counter
1: @ display loop
ldr r0,[r2,r3, lsl #2] @ address area
bl affichageMess
ldr r0,iAdrszCarriageReturn @ display carriage return
bl affichageMess
add r3,#1 @ counter + 1
cmp r3,r4 @ end ?
blt 1b @ no -> loop

b 100f
99: @ display error message
ldr r0,iAdrszMessError
bl affichageMess

100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc 0 @ perform the system call
iAdrszString: .int szString
iAdrszFinalString: .int szFinalString
iAdrszMessFinal: .int szMessFinal
iAdrszMessError: .int szMessError
iAdrszCarriageReturn: .int szCarriageReturn
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registers
mov r2,#0 @ counter length */
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call systeme
pop {r0,r1,r2,r7,lr} @ restaur des 2 registres
bx lr @ return
/*******************************************************************/
/* Separate string by separator into an array */
/* areas are store on the heap Linux */
/*******************************************************************/
/* r0 contains string address */
/* r1 contains separator character (, or . or : ) */
/* r0 returns table address with first item = number areas */
/* and other items contains pointer of each string */
stTokenize:
push {r1-r8,lr} @ save des registres
mov r6,r0
mov r8,r1 @ save separator
bl strLength @ length string for place reservation on the heap
mov r4,r0
ldr r5,iTailleTable
add r5,r0
and r5,#0xFFFFFFFC
add r5,#4 @ align word on the heap
@ place reservation on the heap
mov r0,#0 @ heap address
mov r7, #0x2D @ call system linux 'brk'
svc #0 @ call system
cmp r0,#-1 @ error call system
beq 100f
mov r3,r0 @ save address heap begin
add r0,r5 @ reserve r5 byte on the heap
mov r7, #0x2D @ call system linux 'brk'
svc #0
cmp r0,#-1
beq 100f
@ string copy on the heap
mov r0,r6
mov r1,r3
1: @ loop copy string
ldrb r2,[r0],#1 @ read one byte and increment pointer one byte
strb r2,[r1],#1 @ store one byte and increment pointer one byte
cmp r2,#0 @ end of string ?
bne 1b @ no -> loop

add r4,r3 @ r4 contains address table begin
mov r0,#0
str r0,[r4]
str r3,[r4,#4]
mov r2,#1 @ areas counter
2: @ loop load string character
ldrb r0,[r3]
cmp r0,#0
beq 3f @ end string
cmp r0,r8 @ separator ?
addne r3,#1 @ no -> next location
bne 2b @ and loop
mov r0,#0 @ store zero final of string
strb r0,[r3]
add r3,#1 @ next character
add r2,#1 @ areas counter + 1
str r3,[r4,r2, lsl #2] @ store address area in the table at index r2
b 2b @ and loop
3:
str r2,[r4] @ returns number areas
mov r0,r4
100:
pop {r1-r8,lr}
bx lr
iTailleTable: .int 4 * NBPOSTESECLAT
/***************************************************/
/* calcul size string */
/***************************************************/
/* r0 string address */
/* r0 returns size string */
strLength:
push {r1,r2,lr}
mov r1,#0 @ init counter
1:
ldrb r2,[r0,r1] @ load byte of string index r1
cmp r2,#0 @ end string ?
addne r1,#1 @ no -> +1 counter
bne 1b @ and loop

100:
mov r0,r1
pop {r1,r2,lr}
bx lr
</syntaxhighlight>

=={{header|Arturo}}==
<syntaxhighlight lang="rebol">str: "Hello,How,Are,You,Today"

print join.with:"." split.by:"," str</syntaxhighlight>

{{out}}

<pre>Hello.How.Are.You.Today</pre>

=={{header|Astro}}==
<syntaxhighlight lang="python">let text = 'Hello,How,Are,You,Today'
let tokens = text.split(||,||)
print tokens.join(with: '.')</syntaxhighlight>

=={{header|AutoHotkey}}==
=={{header|AutoHotkey}}==
<lang AutoHotkey>string := "Hello,How,Are,You,Today"
<syntaxhighlight lang="autohotkey">string := "Hello,How,Are,You,Today"
stringsplit, string, string, `,
stringsplit, string, string, `,
loop, % string0
loop, % string0
{
{
msgbox % string%A_Index%
msgbox % string%A_Index%
}</lang>
}</syntaxhighlight>

=={{header|AWK}}==
=={{header|AWK}}==


<lang awk>BEGIN {
<syntaxhighlight lang="awk">BEGIN {
s = "Hello,How,Are,You,Today"
s = "Hello,How,Are,You,Today"
split(s, arr, ",")
split(s, arr, ",")
Line 99: Line 928:
}
}
print
print
}</lang>
}</syntaxhighlight>


A more ''idiomatic'' way for AWK is
A more ''idiomatic'' way for AWK is


<lang awk>BEGIN { FS = "," }
<syntaxhighlight lang="awk">BEGIN { FS = "," }
{
{
for(i=1; i <= NF; i++) printf $i ".";
for(i=1; i <= NF; i++) printf $i ".";
print ""
print ""
}</lang>
}</syntaxhighlight>


which "tokenize" each line of input and this is achieved by using "," as field separator
which "tokenize" each line of input and this is achieved by using "," as field separator


=={{header|Batch File}}==
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<lang dos>@echo off
<syntaxhighlight lang="applesoftbasic">100 T$ = "HELLO,HOW,ARE,YOU,TODAY"
setlocal enabledelayedexpansion
110 GOSUB 200"TOKENIZE
call :tokenize %1 res
120 FOR I = 1 TO N
echo %res%
130 PRINT A$(I) "." ;
goto :eof
140 NEXT
150 PRINT
160 END


200 IF N = 0 THEN DIM A$(256)
:tokenize
set str=%~1
210 N = 1
220 A$(N) = "
:loop
230 FOR TI = 1 TO LEN(T$)
for %%i in (%str%) do set %2=!%2!.%%i
240 C$ = MID$(T$, TI, 1)
set %2=!%2:~1!
250 T = C$ = ","
goto :eof</lang>
260 IF T THEN C$ = "
270 N = N + T
280 IF T THEN A$(N) = C$
290 A$(N) = A$(N) + C$
300 NEXT TI
310 RETURN</syntaxhighlight>


==={{header|BaCon}}===
''Demo''
BaCon includes extensive support for ''delimited strings''.
<lang dos>>tokenize.cmd "Hello,How,Are,You,Today"
<syntaxhighlight lang="bacon">OPTION BASE 1
Hello.How.Are.You.Today</lang>


string$ = "Hello,How,Are,You,Today"
=={{header|BASIC}}==

{{works with|QBasic}}
' 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}}
<syntaxhighlight lang="bbcbasic"> INSTALL @lib$+"STRINGLIB"
text$ = "Hello,How,Are,You,Today"
n% = FN_split(text$, ",", array$())
FOR i% = 0 TO n%-1
PRINT array$(i%) "." ;
NEXT
PRINT</syntaxhighlight>

==={{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.
<syntaxhighlight lang="commodorebasic">10 REM TOKENIZE A STRING ... ROSETTACODE.ORG
20 T$ = "HELLO,HOW,ARE,YOU,TODAY"
30 GOSUB 200, TOKENIZE
40 FOR I = 1 TO N
50 PRINT A$(I) "." ;
60 NEXT
70 PRINT
80 END
200 IF N = 0 THEN DIM A$(256)
210 N = 1
220 A$(N) = ""
230 FOR L = 1 TO LEN(T$)
240 C$ = MID$(T$, L, 1)
250 IF C$<>"," THEN A$(N) = A$(N) + C$: GOTO 270
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}}===
<syntaxhighlight lang="lb">'Note that Liberty Basic's array usage can reach element #10 before having to DIM the array
For i = 0 To 4
array$(i) = Word$("Hello,How,Are,You,Today", (i + 1), ",")
array$ = array$ + array$(i) + "."
Next i

Print Left$(array$, (Len(array$) - 1))</syntaxhighlight>

==={{header|MSX Basic}}===
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.)

<syntaxhighlight lang="powerbasic">FUNCTION PBMAIN () AS LONG
DIM parseMe AS STRING
parseMe = "Hello,How,Are,You,Today"

REDIM parsed(PARSECOUNT(parseMe) - 1) AS STRING
PARSE parseMe, parsed() 'comma is default delimiter

DIM L0 AS LONG, outP AS STRING
outP = parsed(0)
FOR L0 = 1 TO UBOUND(parsed) 'could reuse parsecount instead of ubound
outP = outP & "." & parsed(L0)
NEXT

MSGBOX outP
END FUNCTION</syntaxhighlight>

==={{header|PureBasic}}===

'''As described
<syntaxhighlight lang="purebasic">NewList MyStrings.s()

For i=1 To 5
AddElement(MyStrings())
MyStrings()=StringField("Hello,How,Are,You,Today",i,",")
Next i

ForEach MyStrings()
Print(MyStrings()+".")
Next</syntaxhighlight>

'''Still, easier would be
<syntaxhighlight lang="purebasic">Print(ReplaceString("Hello,How,Are,You,Today",",","."))</syntaxhighlight>


==={{header|QBasic}}===
<lang qbasic>DIM parseMe AS STRING
<syntaxhighlight lang="qbasic">DIM parseMe AS STRING
parseMe = "Hello,How,Are,You,Today"
parseMe = "Hello,How,Are,You,Today"


Line 176: Line 1,144:
PRINT "."; parsed(L0);
PRINT "."; parsed(L0);
NEXT
NEXT
END IF</lang>
END IF</syntaxhighlight>


=={{header|BBC BASIC}}==
==={{header|Run BASIC}}===
<syntaxhighlight lang="runbasic">text$ = "Hello,How,Are,You,Today"
{{works with|BBC BASIC for Windows}}
FOR i = 1 to 5
<lang bbcbasic> INSTALL @lib$+"STRINGLIB"
textArray$(i) = word$(text$,i,",")
print textArray$(i);" ";
text$ = "Hello,How,Are,You,Today"
NEXT</syntaxhighlight>
n% = FN_split(text$, ",", array$())

FOR i% = 0 TO n%-1
==={{header|VBScript}}===
PRINT array$(i%) "." ;
====One liner====
NEXT
<syntaxhighlight lang="vb">WScript.Echo Join(Split("Hello,How,Are,You,Today", ","), ".")</syntaxhighlight>
PRINT</lang>

In fact, the Visual Basic solution (below) could have done the same, as Join() is available.

==={{header|Visual Basic}}===
{{trans|PowerBASIC}}

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.

<syntaxhighlight lang="vb">Sub Main()
Dim parseMe As String, parsed As Variant
parseMe = "Hello,How,Are,You,Today"

parsed = Split(parseMe, ",")

Dim L0 As Long, outP As String
outP = parsed(0)
For L0 = 1 To UBound(parsed)
outP = outP & "." & parsed(L0)
Next

MsgBox outP
End Sub</syntaxhighlight>

=={{header|Batch File}}==
<syntaxhighlight lang="dos">@echo off
setlocal enabledelayedexpansion
call :tokenize %1 res
echo %res%
goto :eof

:tokenize
set str=%~1
:loop
for %%i in (%str%) do set %2=!%2!.%%i
set %2=!%2:~1!
goto :eof</syntaxhighlight>

''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}}==
=={{header|Bracmat}}==
Solution that employs string pattern matching to spot the commas
Solution that employs string pattern matching to spot the commas
<lang bracmat>( "Hello,How,Are,You,Today":?String
<syntaxhighlight lang="bracmat">( "Hello,How,Are,You,Today":?String
& :?ReverseList
& :?ReverseList
& whl
& whl
Line 203: Line 1,219:
)
)
& out$!List
& out$!List
)</syntaxhighlight>
)
</lang>
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.
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.
<lang bracmat>( get$("Hello,How,Are,You,Today",MEM):?CommaseparatedList
<syntaxhighlight lang="bracmat">( get$("Hello,How,Are,You,Today",MEM):?CommaseparatedList
& :?ReverseList
& :?ReverseList
& whl
& whl
Line 218: Line 1,233:
)
)
& out$!List
& out$!List
)</syntaxhighlight>
)

</lang>
=={{header|C}}==
=={{header|C}}==
{{works with|ANSI C}}
{{works with|ANSI C}}
Line 227: Line 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()''.
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()''.


<lang c>#include<string.h>
<syntaxhighlight lang="c">#include<string.h>
#include<stdio.h>
#include<stdio.h>
#include<stdlib.h>
#include<stdlib.h>
Line 248: Line 1,263:


return 0;
return 0;
}</lang>
}</syntaxhighlight>


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.
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.
<lang c>#include<stdio.h>
<syntaxhighlight lang="c">#include<stdio.h>


typedef (void *callbackfunc)(const char *);
typedef void (*callbackfunc)(const char *);


void doprint(const char *s) {
void doprint(const char *s) {
Line 259: Line 1,274:
}
}


void tokenize(char *s, char delim, callbackfunc *cb) {
void tokenize(char *s, char delim, callbackfunc cb) {
char *olds = s;
char *olds = s;
char olddelim = delim;
char olddelim = delim;
Line 276: Line 1,291:
tokenize(array, ',', doprint);
tokenize(array, ',', doprint);
return 0;
return 0;
}</lang>
}</syntaxhighlight>


=={{header|C sharp|C#}}==
=={{header|C sharp|C#}}==
<lang csharp>string str = "Hello,How,Are,You,Today";
<syntaxhighlight lang="csharp">string str = "Hello,How,Are,You,Today";
// or Regex.Split ( "Hello,How,Are,You,Today", "," );
// or Regex.Split ( "Hello,How,Are,You,Today", "," );
// (Regex is in System.Text.RegularExpressions namespace
// (Regex is in System.Text.RegularExpressions namespace)
string[] strings = str.Split(',');
string[] strings = str.Split(',');
foreach (string s in strings)
Console.WriteLine(String.Join(".", strings));
</syntaxhighlight>
{
Console.WriteLine (s + ".");
}</lang>


=={{header|C++}}==
=={{header|C++}}==
{{works with|ANSI C++}}


{{libheader|STL}}
{{works with|C++98}}
std::getline() is typically used to tokenize strings on a single-character delimiter


<syntaxhighlight lang="cpp">#include <string>
This is not the most efficient method as it involves redundant copies in the background, but it is very easy to use. In most cases it will be a good choice as long as it is not used as an inner loop in a performance critical system.
#include <sstream>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
int main()
{
std::string s = "Hello,How,Are,You,Today";
std::vector<std::string> v;
std::istringstream buf(s);
for(std::string token; getline(buf, token, ','); )
v.push_back(token);
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."));
std::cout << '\n';
}</syntaxhighlight>


{{works with|C++98}}
Note doxygen tags in comments before function, describing details of interface.
C++ allows the user to redefine what is considered whitespace. If the delimiter is whitespace, tokenization becomes effortless.


<lang cpp>#include <string>
<syntaxhighlight lang="cpp">#include <string>
#include <locale>
#include <sstream>
#include <vector>
#include <vector>
#include <iterator>
/// \brief convert input string into vector of string tokens
#include <iostream>
///
#include <algorithm>
/// \note consecutive delimiters will be treated as single delimiter
struct comma_ws : std::ctype<char> {
/// \note delimiters are _not_ included in return data
static const mask* make_table() {
///
static std::vector<mask> v(classic_table(), classic_table() + table_size);
/// \param input string to be parsed
v[','] |= space; // comma will be classified as whitespace
/// \param delims list of delimiters.
return &v[0];
}
comma_ws(std::size_t refs = 0) : ctype<char>(make_table(), false, refs) {}
};
int main()
{
std::string s = "Hello,How,Are,You,Today";
std::istringstream buf(s);
buf.imbue(std::locale(buf.getloc(), new comma_ws));
std::istream_iterator<std::string> beg(buf), end;
std::vector<std::string> v(beg, end);
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."));
std::cout << '\n';
}</syntaxhighlight>


{{works with|C++98}}
std::vector<std::string> tokenize_str(const std::string & str,
{{libheader|boost}}
const std::string & delims=", \t")
The boost library has multiple options for easy tokenization.

<syntaxhighlight lang="cpp">#include <string>
#include <vector>
#include <iterator>
#include <algorithm>
#include <iostream>
#include <boost/tokenizer.hpp>
int main()
{
{
std::string s = "Hello,How,Are,You,Today";
using namespace std;
boost::tokenizer<> tok(s);
// Skip delims at beginning, find start of first token
std::vector<std::string> v(tok.begin(), tok.end());
string::size_type lastPos = str.find_first_not_of(delims, 0);
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."))
// Find next delimiter @ end of token
std::cout << '\n';
string::size_type pos = str.find_first_of(delims, lastPos);
}</syntaxhighlight>


{{works with|C++23}}
// output vector
C++20 and C++23 drastically improve the ergonomics of simple manipulation of ranges.
vector<string> tokens;


<syntaxhighlight lang="cpp">#include <string>
while (string::npos != pos || string::npos != lastPos)
#include <ranges>
{
#include <iostream>
// Found a token, add it to the vector.
int main() {
tokens.push_back(str.substr(lastPos, pos - lastPos));
std::string s = "Hello,How,Are,You,Today";
// Skip delims. Note the "not_of". this is beginning of token
s = s // Assign the final string back to the string variable
lastPos = str.find_first_not_of(delims, pos);
| std::views::split(',') // Produce a range of the comma separated words
// Find next delimiter at end of token.
| std::views::join_with('.') // Concatenate the words into a single range of characters
pos = str.find_first_of(delims, lastPos);
| std::ranges::to<std::string>(); // Convert the range of characters into a regular string
}
std::cout << s;
}</syntaxhighlight>


=={{header|Ceylon}}==
return tokens;
{{works with|Ceylon 1.2}}
}</lang>
<syntaxhighlight lang="ceylon">shared void tokenizeAString() {
value input = "Hello,How,Are,You,Today";
value tokens = input.split(','.equals);
print(".".join(tokens));
}</syntaxhighlight>


=={{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.
here is sample usage code:


=={{header|Clojure}}==
<lang cpp>#include <iostream>
Using native Clojure functions and Java Interop:
int main() {
<syntaxhighlight lang="clojure">(apply str (interpose "." (.split #"," "Hello,How,Are,You,Today")))</syntaxhighlight>
using namespace std;
string s("Hello,How,Are,You,Today");


Using the clojure.string library:
vector<string> v(tokenize_str(s));
<syntaxhighlight lang="clojure">(clojure.string/join "." (clojure.string/split "Hello,How,Are,You,Today" #","))</syntaxhighlight>


=={{header|CLU}}==
for (unsigned i = 0; i < v.size(); i++)
<syntaxhighlight lang="clu">% This iterator splits the string on a given character,
cout << v[i] << ".";
% and returns each substring in order.
tokenize = iter (s: string, c: char) yields (string)
cout << endl;
while ~string$empty(s) do
return 0;
next: int := string$indexc(c, s)
}</lang>
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.

environment division.
configuration section.
repository.
function all intrinsic.

data division.
working-storage section.
01 period constant as ".".
01 cmma constant as ",".

01 start-with.
05 value "Hello,How,Are,You,Today".

01 items.
05 item pic x(6) occurs 5 times.

procedure division.
tokenize-main.
unstring start-with delimited by cmma
into item(1) item(2) item(3) item(4) item(5)

display trim(item(1)) period trim(item(2)) period
trim(item(3)) period trim(item(4)) period
trim(item(5))

goback.
end program tokenize.
</syntaxhighlight>

{{out}}
<pre>
prompt$ cobc -xj tokenize.cob
Hello.How.Are.You.Today
</pre>


=={{header|CoffeeScript}}==
=={{header|CoffeeScript}}==


<lang coffeescript>
<syntaxhighlight lang="coffeescript">
arr = "Hello,How,Are,You,Today".split ","
arr = "Hello,How,Are,You,Today".split ","
console.log arr.join "."
console.log arr.join "."
</syntaxhighlight>
</lang>

=={{header|ColdFusion}}==
=== Classic tag based CFML ===
<syntaxhighlight lang="cfm">
<cfoutput>
<cfset wordListTag = "Hello,How,Are,You,Today">
#Replace( wordListTag, ",", ".", "all" )#
</cfoutput>
</syntaxhighlight>
{{Output}}
<pre>
"Hello.How.Are.You.Today"
</pre>

=== Script Based CFML ===
<syntaxhighlight lang="cfm"><cfscript>
wordList = "Hello,How,Are,You,Today";
splitList = replace( wordList, ",", ".", "all" );
writeOutput( splitList );
</cfscript></syntaxhighlight>
{{Output}}
<pre>
"Hello.How.Are.You.Today"
</pre>


=={{header|Common Lisp}}==
=={{header|Common Lisp}}==
Line 360: Line 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.
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.


<lang lisp>(defun comma-split (string)
<syntaxhighlight lang="lisp">(defun comma-split (string)
(loop :for start := 0 :then (1+ finish)
(loop for start = 0 then (1+ finish)
:for finish := (position #\, string :start start)
for finish = (position #\, string :start start)
:collecting (subseq string start finish)
collecting (subseq string start finish)
:until (null finish)))
until (null finish)))


(defun write-with-periods (strings)
(defun write-with-periods (strings)
(format t "~{~A~^.~}" strings))</lang>
(format t "~{~A~^.~}" strings))</syntaxhighlight>


=={{header|Clojure}}==
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
<lang lisp>(apply str (interpose "." (seq (.split #"," "Hello,How,Are,You,Today"))))</lang>
include "strings.coh";


# Tokenize a string. Note: the string is modified in place.
=={{header|D}}==
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;


<lang d>import std.stdio, std.string;
# The string
var string: [uint8] := "Hello,How,Are,You,Today";


# Make a mutable copy
void main() {
var buf: uint8[64];
writeln("Hello,How,Are,You,Today".split(",").join("."));
CopyString(string, &buf[0]);
}</lang>

Output:
# 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}}==
<syntaxhighlight lang="d">void main() {
import std.stdio, std.string;

"Hello,How,Are,You,Today".split(',').join('.').writeln;
}</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today</pre>
<pre>Hello.How.Are.You.Today</pre>


=={{header|Delphi}}==
=={{header|Delphi}}==
=== Using String.split ===
{{libheader| System.SysUtils}}
<syntaxhighlight lang="delphi">
program Tokenize_a_string;

{$APPTYPE CONSOLE}

uses
System.SysUtils;

var
Words: TArray<string>;

begin
Words := 'Hello,How,Are,You,Today'.Split([',']);
Writeln(string.Join(#10, Words));

Readln;
end.

</syntaxhighlight>


=== Using TStringList ===
<lang Delphi>
<syntaxhighlight lang="delphi">
program TokenizeString;
program TokenizeString;


Line 417: Line 1,650:


end.
end.
</syntaxhighlight>
</lang>


The result is:
The result is:


<syntaxhighlight lang="delphi">
<lang Delphi>
Hello
Hello
How
How
Line 427: Line 1,660:
You
You
Today
Today
</syntaxhighlight>
</lang>

=={{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}}==
<syntaxhighlight lang="dejavu">!print join "." split "Hello,How,Are,You,Today" ","</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today</pre>


=={{header|E}}==
=={{header|E}}==
<lang e>".".rjoin("Hello,How,Are,You,Today".split(","))</lang>
<syntaxhighlight lang="e">".".rjoin("Hello,How,Are,You,Today".split(","))</syntaxhighlight>

=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
s$ = "Hello,How,Are,You,Today"
a$[] = strsplit s$ ","
for s$ in a$[]
write s$ & "."
.
</syntaxhighlight>

=={{header|Elena}}==
ELENA 6.x:
<syntaxhighlight lang="elena">import system'routines;
import extensions;
public program()
{
auto string := "Hello,How,Are,You,Today";
string.splitBy(",").forEach::(s)
{
console.print(s,".")
}
}</syntaxhighlight>

=={{header|Elixir}}==
<syntaxhighlight lang="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}}==
=={{header|Erlang}}==
<lang erlang>-module(tok).
<syntaxhighlight lang="erlang">-module(tok).
-export([start/0]).
-export([start/0]).


Line 439: Line 1,731:
Lst = string:tokens("Hello,How,Are,You,Today",","),
Lst = string:tokens("Hello,How,Are,You,Today",","),
io:fwrite("~s~n", [string:join(Lst,".")]),
io:fwrite("~s~n", [string:join(Lst,".")]),
ok.</lang>
ok.</syntaxhighlight>


=={{header|Euphoria}}==
=={{header|Euphoria}}==
<lang euphoria>function split(sequence s, integer c)
<syntaxhighlight lang="euphoria">function split(sequence s, integer c)
sequence out
sequence out
integer first, delim
integer first, delim
Line 463: Line 1,755:
for i = 1 to length(s) do
for i = 1 to length(s) do
puts(1, s[i] & ',')
puts(1, s[i] & ',')
end for</lang>
end for</syntaxhighlight>

=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">System.String.Join(".", "Hello,How,Are,You,Today".Split(','))</syntaxhighlight>


=={{header|Factor}}==
=={{header|Factor}}==
<lang factor>"Hello,How,Are,You,Today" "," split "." join print</lang>
<syntaxhighlight lang="factor">"Hello,How,Are,You,Today" "," split "." join print</syntaxhighlight>

=={{header|Falcon}}==
'''VBA/Python programmer's approach to this solution, not sure if it's the most falconic way'''
<syntaxhighlight lang="falcon">
/* created by Aykayayciti Earl Lamont Montgomery
April 9th, 2018 */

a = []
a = strSplit("Hello,How,Are,You,Today", ",")
index = 0
start = 0
b = ""
for index in [ start : len(a)-1 : 1 ]
b = b + a[index] + "."
end

> b
</syntaxhighlight>
{{out}}
<pre>
Hello.How.Are.You.
[Finished in 0.2s]
</pre>


=={{header|Fantom}}==
=={{header|Fantom}}==
Line 472: Line 1,790:
A string can be split on a given character, returning a list of the intervening strings.
A string can be split on a given character, returning a list of the intervening strings.


<lang fantom>
<syntaxhighlight lang="fantom">
class Main
class Main
{
{
Line 485: Line 1,803:
}
}
}
}
</syntaxhighlight>
</lang>

=={{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}}==
=={{header|Forth}}==
There is no standard string split routine, but it is easily written. The results are saved temporarily to the dictionary.
There is no standard string split routine, but it is easily written. The results are saved temporarily to the dictionary.


<lang forth>: split ( str len separator len -- tokens count )
<syntaxhighlight lang="forth">: split ( str len separator len -- tokens count )
here >r 2swap
here >r 2swap
begin
begin
Line 507: Line 1,836:
1 ?do dup 2@ type ." ." cell+ cell+ loop 2@ type ;
1 ?do dup 2@ type ." ." cell+ cell+ loop 2@ type ;


s" Hello,How,Are,You,Today" s" ," split .tokens \ Hello.How.Are.You.Today</lang>
s" Hello,How,Are,You,Today" s" ," split .tokens \ Hello.How.Are.You.Today</syntaxhighlight>


=={{header|Fortran}}==
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
{{works with|Fortran|90 and later}}
<lang fortran>PROGRAM Example
<syntaxhighlight lang="fortran">PROGRAM Example


CHARACTER(23) :: str = "Hello,How,Are,You,Today"
CHARACTER(23) :: str = "Hello,How,Are,You,Today"
Line 533: Line 1,862:
END DO
END DO
END PROGRAM Example</lang>
END PROGRAM Example</syntaxhighlight>


=={{header|Free Pascal/Lazarus}}==
=={{header|Frink}}==
<syntaxhighlight lang="frink">
<lang pascal>
println[join[".", split[",", "Hello,How,Are,You,Today"]]]
program TokenizeString;
</syntaxhighlight>


=={{header|FutureBasic}}==
{$mode objfpc}{$H+}
<syntaxhighlight lang="futurebasic">
window 1, @"Tokenize a string"


void local fn DoIt
const
CHelloStr = 'Hello,How,Are,You,Today';
CFStringRef string = @"Hello,How,Are,You,Today"
CFArrayRef tokens = fn StringComponentsSeparatedByString( string, @"," )
var
print fn ArrayComponentsJoinedByString( tokens, @"." )
I: Integer;
end fn
VResult: string = '';

begin
fn DoIt
for I := 1 to Length(CHelloStr) do

begin
HandleEvents
if CHelloStr[I] = ',' then
</syntaxhighlight>
VResult += LineEnding
{{out}}
else
<pre>
VResult += CHelloStr[I];
Hello.How.Are.You.Today
end;
</pre>
WriteLn(VResult);

end;
=={{header|Gambas}}==
</lang>
'''[https://gambas-playground.proko.eu/?gist=218e240236cdf1419a405abfed906ed3 Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Dim sString As String[] = Split("Hello,How,Are,You,Today")

Print sString.Join(".")

End</syntaxhighlight>
Output:
<pre>
Hello.How.Are.You.Today
</pre>


The result is:
<lang pascal>
Hello
How
Are
You
Today
</lang>
'''Credits''': [http://code.google.com/p/lazsolutions/ silvioprog], --[[Special:Contributions/201.92.16.65|201.92.16.65]] 15:10, 8 January 2012 (UTC)
=={{header|GAP}}==
=={{header|GAP}}==
<lang gap>SplitString("Hello,How,Are,You,Today", ",");
<syntaxhighlight lang="gap">SplitString("Hello,How,Are,You,Today", ",");
# [ "Hello", "How", "Are", "You", "Today" ]
# [ "Hello", "How", "Are", "You", "Today" ]


JoinStringsWithSeparator(last, ".");
JoinStringsWithSeparator(last, ".");
# "Hello.How.Are.You.Today"</lang>
# "Hello.How.Are.You.Today"</syntaxhighlight>

=={{header|Genie}}==
<syntaxhighlight lang="genie">[indent=4]

init
str:string = "Hello,How,Are,You,Today"
words:array of string[] = str.split(",")
joined:string = string.joinv(".", words)
print joined</syntaxhighlight>

{{out}}
<pre>prompt$ valac tokenize.gs
prompt$ ./tokenize
Hello.How.Are.You.Today</pre>


=={{header|Go}}==
=={{header|Go}}==
<lang go>package main
<syntaxhighlight lang="go">package main


import (
import (
Line 585: Line 1,933:
s := "Hello,How,Are,You,Today"
s := "Hello,How,Are,You,Today"
fmt.Println(strings.Join(strings.Split(s, ","), "."))
fmt.Println(strings.Join(strings.Split(s, ","), "."))
}</lang>
}</syntaxhighlight>

=={{header|Groovy}}==
<syntaxhighlight lang="groovy">println 'Hello,How,Are,You,Today'.split(',').join('.')</syntaxhighlight>


=={{header|Haskell}}==
=={{header|Haskell}}==
'''Using Data.Text'''

<syntaxhighlight lang="haskell">{-# OPTIONS_GHC -XOverloadedStrings #-}
import Data.Text (splitOn,intercalate)
import qualified Data.Text.IO as T (putStrLn)

main = T.putStrLn . intercalate "." $ splitOn "," "Hello,How,Are,You,Today"</syntaxhighlight>

Output: Hello.How.Are.You.Today

'''Alternate Solution'''


The necessary operations are unfortunately not in the standard library (yet), but simple to write:
The necessary operations are unfortunately not in the standard library (yet), but simple to write:


<lang haskell>splitBy :: (a -> Bool) -> [a] -> [[a]]
<syntaxhighlight lang="haskell">splitBy :: (a -> Bool) -> [a] -> [[a]]
splitBy _ [] = []
splitBy _ [] = []
splitBy f list = first : splitBy f (dropWhile f rest) where
splitBy f list = first : splitBy f (dropWhile f rest) where
Line 606: Line 1,968:
-- using regular expression to split:
-- using regular expression to split:
import Text.Regex
import Text.Regex
putStrLn $ joinWith "." $ splitRegex (mkRegex ",") $ "Hello,How,Are,You,Today"</lang>
putStrLn $ joinWith "." $ splitRegex (mkRegex ",") $ "Hello,How,Are,You,Today"</syntaxhighlight>


Tokenizing can also be realized by using unfoldr and break:
Tokenizing can also be realized by using unfoldr and break:
<lang Haskell>*Main> mapM_ putStrLn $ takeWhile (not.null) $ unfoldr (Just . second(drop 1). break (==',')) "Hello,How,Are,You,Today"
<syntaxhighlight lang="haskell">*Main> mapM_ putStrLn $ takeWhile (not.null) $ unfoldr (Just . second(drop 1). break (==',')) "Hello,How,Are,You,Today"
Hello
Hello
How
How
Are
Are
You
You
Today</lang>
Today</syntaxhighlight>
* You need to import the modules Data.List and Control.Arrow
* You need to import the modules Data.List and Control.Arrow


As special cases, splitting / joining by white space and by newlines are provided by the Prelude functions <tt>words</tt> / <tt>unwords</tt> and <tt>lines</tt> / <tt>unlines</tt>, respectively.
As special cases, splitting / joining by white space and by newlines are provided by the Prelude functions <code>words</code> / <code>unwords</code> and <code>lines</code> / <code>unlines</code>, respectively.

=={{header|Groovy}}==
<lang groovy>println 'Hello,How,Are,You,Today'.split(',').join('.')</lang>


=={{header|HicEst}}==
=={{header|HicEst}}==
<lang hicest>CHARACTER string="Hello,How,Are,You,Today", list
<syntaxhighlight lang="hicest">CHARACTER string="Hello,How,Are,You,Today", list


nWords = INDEX(string, ',', 256) + 1
nWords = INDEX(string, ',', 256) + 1
Line 635: Line 1,994:
DO i = 1, nWords
DO i = 1, nWords
WRITE(APPend) TRIM(CHAR(i, maxWordLength, list)), '.'
WRITE(APPend) TRIM(CHAR(i, maxWordLength, list)), '.'
ENDDO</lang>
ENDDO</syntaxhighlight>


=={{header|Icon}} and {{header|Unicon}}==
=={{header|Icon}} and {{header|Unicon}}==
<lang icon>procedure main()
<syntaxhighlight lang="icon">procedure main()
A := []
A := []
"Hello,How,Are,You,Today" ? while put(A, 1(tab(upto(',')|0),=","))
"Hello,How,Are,You,Today" ? {
while put(A, 1(tab(upto(',')),=","))
put(A,tab(0))
}
every writes(!A,".")
every writes(!A,".")
write()
write()
end</lang>
end</syntaxhighlight>


{{out}}
Output:
<pre>->ss
<pre>
->ss
Hello.How.Are.You.
Hello.How.Are.You.Today.
->
->
</pre>
</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|Io}}==
<lang io>"Hello,How,Are,You,Today" split(",") join(".") println</lang>
<syntaxhighlight lang="io">"Hello,How,Are,You,Today" split(",") join(".") println</syntaxhighlight>


=={{header|J}}==
=={{header|J}}==
<lang j> s=: 'Hello,How,Are,You,Today'
<syntaxhighlight lang="j"> s=: 'Hello,How,Are,You,Today'
] t=: <;._1 ',',s
] t=: <;._1 ',',s
+-----+---+---+---+-----+
+-----+---+---+---+-----+
Line 664: Line 2,038:


'.' (I.','=s)}s NB. two steps combined
'.' (I.','=s)}s NB. two steps combined
Hello.How.Are.You.Today</lang>
Hello.How.Are.You.Today</syntaxhighlight>


Alternatively using the system library/script <tt>strings</tt>
Alternatively using the system library/script <tt>strings</tt>
<lang j> require 'strings'
<syntaxhighlight lang="j"> require 'strings'
',' splitstring s
',' splitstring s
+-----+---+---+---+-----+
+-----+---+---+---+-----+
Line 674: Line 2,048:


'.' joinstring ',' splitstring s
'.' joinstring ',' splitstring s
Hello.How.Are.You.Today</lang>
Hello.How.Are.You.Today</syntaxhighlight>


<tt>splitstring</tt> and <tt>joinstring</tt> also work with longer "delimiters":
<tt>splitstring</tt> and <tt>joinstring</tt> also work with longer "delimiters":
<lang j> '"'([ ,~ ,) '","' joinstring ',' splitstring s
<syntaxhighlight lang="j"> '"'([ ,~ ,) '","' joinstring ',' splitstring s
"Hello","How","Are","You","Today"</lang>
"Hello","How","Are","You","Today"</syntaxhighlight>

But, of course, this could be solved with simple string replacement:

<syntaxhighlight lang="j"> rplc&',.' s
Hello.How.Are.You.Today</syntaxhighlight>

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.

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:

<syntaxhighlight lang="j"> fn;._2 string,','</syntaxhighlight>

Here '''fn''' is applied to each ',' delimited substring and the results are assembled into an array.

Or, factoring out the names:
<syntaxhighlight lang="j"> fn ((;._2)(@(,&','))) string</syntaxhighlight>


=={{header|Java}}==
=={{header|Java}}==
Line 686: Line 2,076:


The first is by splitting the String into an array of Strings. The separator is actually a regular expression so you could do very powerful things with this, but make sure to escape any characters with special meaning in regex.
The first is by splitting the String into an array of Strings. The separator is actually a regular expression so you could do very powerful things with this, but make sure to escape any characters with special meaning in regex.

{{works with|Java|1.8+}}

<syntaxhighlight lang="java5">String toTokenize = "Hello,How,Are,You,Today";
System.out.println(String.join(".", toTokenize.split(",")));</syntaxhighlight>


{{works with|Java|1.4+}}
{{works with|Java|1.4+}}
<lang java5>String toTokenize = "Hello,How,Are,You,Today";
<syntaxhighlight lang="java5">String toTokenize = "Hello,How,Are,You,Today";


String words[] = toTokenize.split(",");//splits on one comma, multiple commas yield multiple splits
String words[] = toTokenize.split(",");//splits on one comma, multiple commas yield multiple splits
Line 694: Line 2,089:
for(int i=0; i<words.length; i++) {
for(int i=0; i<words.length; i++) {
System.out.print(words[i] + ".");
System.out.print(words[i] + ".");
}</lang>
}</syntaxhighlight>


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.
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+}}
{{works with|Java|1.0+}}
<lang java5>String toTokenize = "Hello,How,Are,You,Today";
<syntaxhighlight lang="java5">String toTokenize = "Hello,How,Are,You,Today";


StringTokenizer tokenizer = new StringTokenizer(toTokenize, ",");
StringTokenizer tokenizer = new StringTokenizer(toTokenize, ",");
while(tokenizer.hasMoreTokens()) {
while(tokenizer.hasMoreTokens()) {
System.out.print(tokenizer.nextToken() + ".");
System.out.print(tokenizer.nextToken() + ".");
}</lang>
}</syntaxhighlight>


=={{header|JavaScript}}==
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">console.log(
{{works with|Firefox|2.0}}
"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");


<lang javascript>alert( "Hello,How,Are,You,Today".split(",").join(".") );</lang>
// -> ['Hello', ',', 'How', ',', 'Are', ',', 'You', ',', 'Today']
</syntaxhighlight>


=={{header|Liberty BASIC}}==
=={{header|jq}}==
<syntaxhighlight lang="jq">split(",") | join(".")</syntaxhighlight>Example:<syntaxhighlight lang="sh">$ jq -r 'split(",") | join(".")'
<lang lb>'Note that Liberty Basic's array usage can reach element #10 before having to DIM the array
"Hello,How,Are,You,Today"
For i = 0 To 4
array$(i) = Word$("Hello,How,Are,You,Today", (i + 1), ",")
Hello.How.Are.You.Today</syntaxhighlight>

array$ = array$ + array$(i) + "."
=={{header|Jsish}}==
Next i
Being in the ECMAScript family, Jsi is blessed with many easy to use character, string and array manipulation routines.

<syntaxhighlight lang="javascript">puts('Hello,How,Are,You,Today'.split(',').join('.'))</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today</pre>

=={{header|Julia}}==
<syntaxhighlight lang="julia">
s = "Hello,How,Are,You,Today"
a = split(s, ",")
t = join(a, ".")

println("The string \"", s, "\"")
println("Splits into ", a)
println("Reconstitutes to \"", t, "\"")
</syntaxhighlight>

{{out}}
<pre>
The string "Hello,How,Are,You,Today"
Splits into SubString{ASCIIString}["Hello","How","Are","You","Today"]
Reconstitutes to "Hello.How.Are.You.Today"
</pre>

=={{header|K}}==
<syntaxhighlight lang="k">words: "," \: "Hello,How,Are,You,Today"
"." /: words</syntaxhighlight>

{{out}}
<pre>
"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}}==
<syntaxhighlight lang="klingphix">( "Hello,How,Are,You,Today" "," ) split len [ get print "." print ] for

nl "End " input</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today.
End</pre>

=={{header|Kotlin}}==
{{works with|Kotlin|1.0b4}}
<syntaxhighlight lang="scala">fun main(args: Array<String>) {
val input = "Hello,How,Are,You,Today"
println(input.split(',').joinToString("."))
}</syntaxhighlight>
{{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}}==
To tokenize the string, we use the Search/Split String function to split the string by its first comma. Add the beginning (up to, but not including the comma) to the end of the array, remove the first comma from the rest of the string, and pass it back through the shift register to the loop's next iteration. This is repeated until the string is empty. Printing is a simple matter of concatenation.<br/>
{{VI solution|LabVIEW_Tokenize_a_string.png}}

=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{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}}==
<syntaxhighlight lang="lang5">'Hello,How,Are,You,Today ', split '. join .</syntaxhighlight>

=={{header|LDPL}}==
<syntaxhighlight lang="ldpl">
DATA:
explode/words is text vector
explode/index is number
explode/string is text
explode/length is number
explode/stringlength is number
explode/current-token is text
explode/char is text
explode/separator is text
i is number
PROCEDURE:
# Ask for a sentence
display "Enter a sentence: "
accept explode/string

# Declare explode Subprocedure
# Splits a text into a text vector by a certain delimiter
# Input parameters:
# - explode/string: the string to explode (destroyed)
# - explode/separator: the character used to separate the string (preserved)
# Output parameters:
# - explode/words: vector of splitted words
# - explode/length: length of explode/words
sub-procedure explode
join explode/string and explode/separator in explode/string
store length of explode/string in explode/stringlength
store 0 in explode/index
store 0 in explode/length
store "" in explode/current-token
while explode/index is less than explode/stringlength do
get character at explode/index from explode/string in explode/char
if explode/char is equal to explode/separator then
store explode/current-token in explode/words:explode/length
add explode/length and 1 in explode/length
store "" in explode/current-token
else
join explode/current-token and explode/char in explode/current-token
end if
add explode/index and 1 in explode/index
repeat
subtract 1 from explode/length in explode/length
end sub-procedure

# Separate the entered string
store " " in explode/separator
call sub-procedure explode
while i is less than or equal to explode/length do
display explode/words:i crlf
add 1 and i in i
repeat
</syntaxhighlight>

=={{header|LFE}}==

<syntaxhighlight lang="lisp">
> (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}}==
Print Left$(array$, (Len(array$) - 1))</lang>
<syntaxhighlight lang="lingo">input = "Hello,How,Are,You,Today"
_player.itemDelimiter = ","
output = ""
repeat with i = 1 to input.item.count
put input.item[i]&"." after output
end repeat
delete the last char of output
put output
-- "Hello.How.Are.You.Today"</syntaxhighlight>


=={{header|Logo}}==
=={{header|Logo}}==
{{works with|UCB Logo}}
{{works with|UCB Logo}}
<lang logo>to split :str :sep
<syntaxhighlight lang="logo">to split :str :sep
output parse map [ifelse ? = :sep ["| |] [?]] :str
output parse map [ifelse ? = :sep ["| |] [?]] :str
end</lang>
end</syntaxhighlight>


This form is more robust, doing the right thing if there are embedded spaces.
This form is more robust, doing the right thing if there are embedded spaces.
<lang logo>to split :str :by [:acc []] [:w "||]
<syntaxhighlight lang="logo">to split :str :by [:acc []] [:w "||]
if empty? :str [output lput :w :acc]
if empty? :str [output lput :w :acc]
ifelse equal? first :str :by ~
ifelse equal? first :str :by ~
[output (split butfirst :str :by lput :w :acc)] ~
[output (split butfirst :str :by lput :w :acc)] ~
[output (split butfirst :str :by :acc lput first :str :w)]
[output (split butfirst :str :by :acc lput first :str :w)]
end</lang>
end</syntaxhighlight>


<lang logo>? show split "Hello,How,Are,You,Today ",
<syntaxhighlight lang="logo">? show split "Hello,How,Are,You,Today ",
[Hello How Are You Today]</lang>
[Hello How Are You Today]</syntaxhighlight>
=={{header|Lua}}==
<lang lua>require"re"


=={{header|Logtalk}}==
record = re.compile[[
Using Logtalk built-in support for Definite Clause Grammars (DCGs) and representing the strings as atoms for readbility:
record <- ( <field> (',' <field>)* ) -> {} (%nl / !.)
<syntaxhighlight lang="logtalk">
field <- <escaped> / <nonescaped>
:- object(spliting).
nonescaped <- { [^,"%nl]* }
escaped <- '"' {~ ([^"] / '""' -> '"')* ~} '"'
]]


:- public(convert/2).
print(unpack(record:match"hello,how,are,you,today"))</lang>
:- mode(convert(+atom, -atom), one).
A different solution using the string-library of Lua:
<lang lua>str = "Hello,How,Are,You,Today"


convert(StringIn, StringOut) :-
tokens = {}
atom_chars(StringIn, CharactersIn),
for w in string.gmatch( str, "(%a+)" ) do
phrase(split(',', Tokens), CharactersIn),
tokens[#tokens+1] = w
phrase(split('.', Tokens), CharactersOut),
end
atom_chars(StringOut, CharactersOut).


split(Separator, [t([Character| Characters])| Tokens]) -->
for i = 1, #tokens do
[Character], {Character \== Separator}, split(Separator, [t(Characters)| Tokens]).
print( tokens[i] )
split(Separator, [t([])| Tokens]) -->
end</lang>
[Separator], split(Separator, Tokens).
split(_, [t([])]) -->
[].
% the look-ahead in the next rule prevents adding a spurious separator at the end
split(_, []), [Character] -->
[Character].


:- end_object.
</syntaxhighlight>
{{out}}
<pre>
| ?- spliting::convert('Hello,How,Are,You,Today', Converted).
Converted = 'Hello.How.Are.You.Today'
yes
</pre>


=={{header|Mathematica}}==
=={{header|Lua}}==
Split function callously stolen from the lua-users wiki
<lang Mathematica>Row[Riffle[StringSplit["Hello,How,Are,You,Today", ","], "."]]</lang>
<syntaxhighlight lang="lua">function string:split (sep)
local sep, fields = sep or ":", {}
local pattern = string.format("([^%s]+)", sep)
self:gsub(pattern, function(c) fields[#fields+1] = c end)
return fields
end

local str = "Hello,How,Are,You,Today"
print(table.concat(str:split(","), "."))</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today</pre>

=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Function Tokenize$(s){
\\ letter$ pop a string from stack of values
\\ shift 2 swap top two values on stack of values
fold1=lambda m=1 ->{
shift 2 :if m=1 then m=0:drop: push letter$ else push letter$+"."+letter$
}
=s#fold$(fold1)
}
Print Tokenize$(piece$("Hello,How,Are,You,Today",",")) ="Hello.How.Are.You.Today" ' true
}
Checkit
</syntaxhighlight>


=={{header|M4}}==
=={{header|M4}}==
<lang M4>define(`s',`Hello,How,Are,You,Today')
<syntaxhighlight lang="m4">define(`s',`Hello,How,Are,You,Today')
define(`set',`define(`$1[$2]',`$3')')
define(`set',`define(`$1[$2]',`$3')')
define(`get',`defn($1[$2])')
define(`get',`defn($1[$2])')
Line 774: Line 2,470:
define(`show',
define(`show',
`ifelse(eval(j<n),1,`get(a,j).`'define(`j',incr(j))`'show')')
`ifelse(eval(j<n),1,`get(a,j).`'define(`j',incr(j))`'show')')
show</lang>
show</syntaxhighlight>


{{out}}
Output:
<pre>
<pre>
Hello.How.Are.You.Today.
Hello.How.Are.You.Today.
</pre>
</pre>


=={{header|MATLAB}}==
=={{header|Maple}}==
<syntaxhighlight lang="maple">StringTools:-Join(StringTools:-Split("Hello,How,Are,You,Today", ","),".");</syntaxhighlight>
<lang MATLAB>function tokenizeString(string,delimeter)
{{Out|Output}}
<pre>"Hello.How.Are.You.Today"</pre>


=={{header|Mathematica}}/{{header|Wolfram Language}}==
tokens = {};
<syntaxhighlight lang="mathematica">StringJoin@StringSplit["Hello,How,Are,You,Today", "," -> "."]</syntaxhighlight>
while not(isempty(string))
[tokens{end+1},string] = strtok(string,delimeter);
end
for i = (1:numel(tokens)-1)
fprintf([tokens{i} '.'])
end
fprintf([tokens{end} '\n'])
end</lang>


=={{header|MATLAB}} / {{header|Octave}}==
Output:
<syntaxhighlight lang="matlab">
<lang MATLAB>>> tokenizeString('Hello,How,Are,You,Today',',')
Hello.How.Are.You.Today</lang>
s=strsplit('Hello,How,Are,You,Today',',')
fprintf(1,'%s.',s{:})
</syntaxhighlight>

{{out}}
<pre>
Hello.How.Are.You.Today.
</pre>

=={{header|Maxima}}==
<syntaxhighlight lang="maxima">l: split("Hello,How,Are,You,Today", ",")$
printf(true, "~{~a~^.~}~%", l)$</syntaxhighlight>

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}}==
=={{header|MAXScript}}==
<lang maxscript>output = ""
<syntaxhighlight lang="maxscript">output = ""
for word in (filterString "Hello,How,Are,You,Today" ",") do
for word in (filterString "Hello,How,Are,You,Today" ",") do
(
(
output += (word + ".")
output += (word + ".")
)
)
format "%\n" output</lang>
format "%\n" output</syntaxhighlight>

=={{header|Mercury}}==
<syntaxhighlight lang="text">
:- module string_tokenize.
:- interface.

:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.
:- import_module list, string.

main(!IO) :-
Tokens = string.split_at_char((','), "Hello,How,Are,You,Today"),
io.write_list(Tokens, ".", io.write_string, !IO),
io.nl(!IO).</syntaxhighlight>

=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang="min">"Hello,How,Are,You,Today" "," split "." join print</syntaxhighlight>

=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">tokens = "Hello,How,Are,You,Today".split(",")
print tokens.join(".")</syntaxhighlight>


=={{header|MMIX}}==
=={{header|MMIX}}==
<lang mmix>sep IS ','
<syntaxhighlight lang="mmix">sep IS ','
EOS IS 0
EOS IS 0
NL IS 10
NL IS 10
Line 863: Line 2,596:
LDBU t,tp
LDBU t,tp
PBNZ t,2B % UNTIL EOB(uffer)
PBNZ t,2B % UNTIL EOB(uffer)
TRAP 0,Halt,0</lang>
TRAP 0,Halt,0</syntaxhighlight>
{{out}}
Output:
<pre>
<pre>~/MIX/MMIX/Progs> mmix tokenizing
~/MIX/MMIX/Progs> mmix tokenizing
Hello
Hello
How
How
Are
Are
You
You
Today</pre>
Today
</pre>


=={{header|Modula-3}}==
=={{header|Modula-3}}==
<lang modula3>MODULE Tokenize EXPORTS Main;
<syntaxhighlight lang="modula3">MODULE Tokenize EXPORTS Main;


IMPORT IO, TextConv;
IMPORT IO, TextConv;
Line 890: Line 2,625:
END;
END;
IO.Put("\n");
IO.Put("\n");
END Tokenize.</lang>
END Tokenize.</syntaxhighlight>

=={{header|MUMPS}}==
=={{header|MUMPS}}==
<lang MUMPS>TOKENS
<syntaxhighlight lang="mumps">TOKENS
NEW I,J,INP
NEW I,J,INP
SET INP="Hello,how,are,you,today"
SET INP="Hello,how,are,you,today"
Line 898: Line 2,634:
NEW J FOR J=1:1:I WRITE INP(J) WRITE:J'=I "."
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"
KILL I,J,INP // Kill is optional. "New" variables automatically are killed on "Quit"
QUIT</lang>
QUIT</syntaxhighlight>


In use:<pre>USER>D TOKENS^ROSETTA
In use:
USER>D TOKENS^ROSETTA
Hello.how.are.you.today</pre>
Hello.how.are.you.today

=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">for word in "Hello,How,Are,You,Today".split(",")
print word + "."
end</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today.</pre>


=={{header|Nemerle}}==
=={{header|Nemerle}}==
<lang Nemerle>using System;
<syntaxhighlight lang="nemerle">using System;
using System.Console;
using System.Console;
using Nemerle.Utility.NString;
using Nemerle.Utility.NString;
Line 917: Line 2,661:
// a quick in place list comprehension takes care of that
// a quick in place list comprehension takes care of that
}
}
}</lang>
}</syntaxhighlight>

=={{header|NetRexx}}==
<syntaxhighlight lang="netrexx">/*NetRexx program *****************************************************
* 20.08.2012 Walter Pachl derived from REXX Version 3
**********************************************************************/
sss='Hello,How,Are,You,Today'
Say 'input string='sss
Say ''
Say 'Words in the string:'
ss =sss.translate(' ',',')
Loop i=1 To ss.words()
Say ss.word(i)'.'
End
Say 'End-of-list.'</syntaxhighlight>
Output as in REXX version

=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">(print (join (parse "Hello,How,Are,You,Today" ",") "."))</syntaxhighlight>

=={{header|Nial}}==

Example for <b>Q'Nial7</b>, using <code>set "nodecor</code> and <code>set "diagram</code> switches for better display of the array structure:

Define Array with input string:

<syntaxhighlight lang="nial"> s := 'Hello,How,Are,You,Today'
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|H|e|l|l|o|,|H|o|w|,|A|r|e|,|Y|o|u|,|T|o|d|a|y|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+</syntaxhighlight>

Split string at the commas:

<syntaxhighlight lang="nial"> t := s eachall = `, cut s
+-----------+-------+-------+-------+-----------+
|+-+-+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+-+-+|
||H|e|l|l|o|||H|o|w|||A|r|e|||Y|o|u|||T|o|d|a|y||
|+-+-+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+-+-+|
+-----------+-------+-------+-------+-----------+</syntaxhighlight>

Join string with <code>.</code> and remove last <code>.</code>

<syntaxhighlight lang="nial"> u := front content (cart t `.)
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|H|e|l|l|o|.|H|o|w|.|A|r|e|.|Y|o|u|.|T|o|d|a|y|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+</syntaxhighlight>

Less cluttered display, using <code>set "sketch;set "nodecor</code> display switches.

<syntaxhighlight lang="nial"> s:='Hello,How,Are,You,Today'
Hello,How,Are,You,Today
t:= s eachall = `, cut s
+-----+---+---+---+-----+
|Hello|How|Are|You|Today|
+-----+---+---+---+-----+
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}}==
<syntaxhighlight lang="nim">import strutils

let text = "Hello,How,Are,You,Today"
let tokens = text.split(',')
echo tokens.join(".")</syntaxhighlight>

{{out}}
<pre>Hello.How.Are.You.Today</pre>

=={{header|Objeck}}==
<syntaxhighlight lang="objeck">
class Parse {
function : Main(args : String[]) ~ Nil {
tokens := "Hello,How,Are,You,Today"->Split(",");
each(i : tokens) {
tokens[i]->PrintLine();
};
}
}</syntaxhighlight>


=={{header|Objective-C}}==
=={{header|Objective-C}}==
Line 924: Line 2,752:
{{works with|Cocoa}}
{{works with|Cocoa}}


<lang objc>NSString *text = @"Hello,How,Are,You,Today";
<syntaxhighlight lang="objc">NSString *text = @"Hello,How,Are,You,Today";
NSArray *tokens = [text componentsSeparatedByString:@","];
NSArray *tokens = [text componentsSeparatedByString:@","];
NSString *result = [tokens componentsJoinedByString:@"."];
NSString *result = [tokens componentsJoinedByString:@"."];
NSLog(result);</lang>
NSLog(result);</syntaxhighlight>

=={{header|Objeck}}==
<lang objeck>
bundle Default {
class Parse {
function : Main(args : String[]) ~ Nil {
tokens := "Hello,How,Are,You,Today"->Split(",");
each(i : tokens) {
tokens[i]->PrintLine();
};
}
}
}
</lang>


=={{header|OCaml}}==
=={{header|OCaml}}==
To split on a single-character separator:
To split on a single-character separator:
<syntaxhighlight lang="ocaml">let words = String.split_on_char ',' "Hello,How,Are,You,Today" in
<lang ocaml>let rec split_char sep str =
String.concat "." words
try
</syntaxhighlight>
let i = String.index str sep in
String.sub str 0 i ::
split_char sep (String.sub str (i+1) (String.length str - i - 1))
with Not_found ->
[str]</lang>


The function split_on_char has been introduced in OCaml 4.04. In previous versions, it could be implemented by:
Or the [[:Category:Recursion|tail-recursive]] equivalent:


<syntaxhighlight lang="ocaml">let split_on_char sep s =
<lang ocaml>(* [try .. with] structures break tail-recursion,
let r = ref [] in
so we externalise it in a sub-function *)
let j = ref (String.length s) in
let string_index str c =
try Some(String.index str c)
for i = String.length s - 1 downto 0 do
if s.[i] = sep then begin
with Not_found -> None
r := String.sub s (i + 1) (!j - i - 1) :: !r;
j := i
end
done;
String.sub s 0 !j :: !r</syntaxhighlight>


=={{header|Oforth}}==
let split_char sep str =
let rec aux acc str =
match string_index str sep with
| Some i ->
let this = String.sub str 0 i
and next = String.sub str (i+1) (String.length str - i - 1) in
aux (this::acc) next
| None ->
List.rev(str::acc)
in
aux [] str
;;</lang>


<syntaxhighlight lang="oforth">"Hello,How,Are,You,Today" wordsWith(',') println</syntaxhighlight>
But both of these will process extraneous String.sub (so one string alloc) to generate the "rest of the string" each time to pass to the next call. For N tokens there will be (N - 2) unneeded allocs. To resolve this here is a version which keeps track of the index in the string we will look next:


{{out}}
<lang ocaml>let split_char sep str =
<pre>
let string_index_from i =
[Hello, How, Are, You, Today]
try Some (String.index_from str i sep)
</pre>
with Not_found -> None
in
let rec aux i acc = match string_index_from i with
| Some i' ->
let w = String.sub str i (i' - i) in
aux (succ i') (w::acc)
| None ->
let w = String.sub str i (String.length str - i) in
List.rev (w::acc)
in
aux 0 []</lang>

Splitting on a string separator using the regular expressions library:
<lang ocaml>#load "str.cma";;
let split_str sep str =
Str.split (Str.regexp_string sep) str</lang>


=={{header|ooRexx}}==
There is already a library function for joining:
<syntaxhighlight lang="oorexx">text='Hello,How,Are,You,Today'
<lang ocaml>String.concat sep strings</lang>
do while text \= ''
parse var text word1 ',' text
call charout 'STDOUT:',word1'.'
end</syntaxhighlight>
{{out}}
<pre>Hello.How.Are.You.Today.</pre>


=={{header|OpenEdge/Progress}}==
=={{header|OpenEdge/Progress}}==
<lang progress>FUNCTION tokenizeString RETURNS CHAR (
<syntaxhighlight lang="progress">FUNCTION tokenizeString RETURNS CHAR (
i_c AS CHAR
i_c AS CHAR
):
):
Line 1,023: Line 2,818:
MESSAGE
MESSAGE
tokenizeString( "Hello,How,Are,You,Today" )
tokenizeString( "Hello,How,Are,You,Today" )
VIEW-AS ALERT-BOX.</lang>
VIEW-AS ALERT-BOX.</syntaxhighlight>
{{out}}
Output:
<pre>
<pre>
---------------------------
---------------------------
Message
Message
---------------------------
---------------------------
Hello.How.Are.You.Today
Hello.How.Are.You.Today
---------------------------
---------------------------
OK
OK
---------------------------
---------------------------
</pre>
</pre>


=={{header|Oz}}==
=={{header|Oz}}==
<lang oz>for T in {String.tokens "Hello,How,Are,You,Today" &,} do
<syntaxhighlight lang="oz">for T in {String.tokens "Hello,How,Are,You,Today" &,} do
{System.printInfo T#"."}
{System.printInfo T#"."}
end</lang>
end</syntaxhighlight>

=={{header|PARI/GP}}==
===Version #1.===
Simple version, like the most custom ones here (for this task). This version has 1 character delimiter,
which is not allowed in the beginning and at the end of string, in addition, double, triple, etc., delimiters
are not allowed too.

{{Works with|PARI/GP|2.7.4 and above}}

<syntaxhighlight lang="parigp">
\\ 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
\\ tokenize() 3/5/16 aev
tokenize(str,d)={
my(str=Str(str,d),vt=Vecsmall(str),d1=sasc(d),Lr=List(),sn=#str,v1,p1=1);
for(i=p1,sn, v1=vt[i]; if(v1==d1, listput(Lr,ssubstr(str,p1,i-p1)); p1=i+1));
return(Lr);
}

{
\\ TEST
print(" *** Testing tokenize from Version #1:");
print("1.", tokenize("Hello,How,Are,You,Today",","));
\\ BOTH 2 & 3 are NOT OK!!
print("2.",tokenize("Hello,How,Are,You,Today,",","));
print("3.",tokenize(",Hello,,How,Are,You,Today",","));
}
</syntaxhighlight>

{{Output}}
<pre>
*** Testing tokenize from Version #1:
1.List(["Hello", "How", "Are", "You", "Today"])
2.List(["Hello", "How", "Are", "You", "Today", ","])
3.List([",Hello,,How,Are,You,Today,", "Hello", ",How,Are,You,Today,", "How", "Ar
e", "You", "Today"])
</pre>

===Version #2.===
Advanced version. Delimiter is allowed in any place. In addition, multiple delimiters are allowed too.
This is really useful for considering omitted data.
This version can be used for positional parameters processing, or for processing data from tables with string rows.

{{Works with|PARI/GP|2.7.4 and above}}

<syntaxhighlight lang="parigp">
\\ 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
\\ stok() 3/5/16 aev
stok(str,d)={
my(d1c=ssubstr(d,1,1),str=Str(str,d1c),vt=Vecsmall(str),d1=sasc(d1c),
Lr=List(),sn=#str,v1,p1=1,vo=32);
if(sn==1, return(List(""))); if(vt[sn-1]==d1,sn--);
for(i=1,sn, v1=vt[i];
if(v1!=d1, vo=v1; next);
if(vo==d1||i==1, listput(Lr,""); p1=i+1; vo=v1; next);
if(i-p1>0, listput(Lr,ssubstr(str,p1,i-p1)); p1=i+1);
vo=v1;
);
return(Lr);
}

{
\\ TEST
print(" *** Testing stok from Version #2:");
\\ pp - positional parameter(s)
print("1. 5 pp: ", stok("Hello,How,Are,You,Today",","));
print("2. 5 pp: ", stok("Hello,How,Are,You,Today,",","));
print("3. 9 pp: ", stok(",,Hello,,,How,Are,You,Today",","));
print("4. 6 pp: ", stok(",,,,,,",","));
print("5. 1 pp: ", stok(",",","));
print("6. 1 pp: ", stok("Hello-o-o??",","));
print("7. 0 pp: ", stok("",","));
}
</syntaxhighlight>

{{Output}}
<pre>
*** Testing stok from Version #2:
1. 5 pp: List(["Hello", "How", "Are", "You", "Today"])
2. 5 pp: List(["Hello", "How", "Are", "You", "Today"])
3. 9 pp: List(["", "", "Hello", "", "", "How", "Are", "You", "Today"])
4. 6 pp: List(["", "", "", "", "", ""])
5. 1 pp: List([""])
6. 1 pp: List(["Hello-o-o??"])
7. 0 pp: List([""])
</pre>


=={{header|Pascal}}==
=={{header|Pascal}}==
{{works with|Free_Pascal}}
See [[Tokenize_a_string#Delphi | Delphi]]
<syntaxhighlight lang="pascal">program TokenizeString;

{$mode objfpc}{$H+}

uses
SysUtils, Classes;
const
TestString = 'Hello,How,Are,You,Today';
var
Tokens: TStringList;
I: Integer;
begin
// Uses FCL facilities, "harder" algorithm not implemented
Tokens := TStringList.Create;
try
Tokens.Delimiter := ',';
Tokens.DelimitedText := TestString;
Tokens.Delimiter := '.'; // For example
// To standard Output
WriteLn(Format('Tokenize from: "%s"', [TestString]));
WriteLn(Format('to: "%s"',[Tokens.DelimitedText]));
finally
Tokens.Free;
end;
end.</syntaxhighlight>

The result is:
Tokenize from: "Hello,How,Are,You,Today"
to: "Hello.How.Are.You.Today"


=={{header|Perl}}==
=={{header|Perl}}==
<lang perl>print join('.', split /,/, 'Hello,How,Are,You,Today'), "\n";</lang>
<syntaxhighlight lang="perl">print join('.', split /,/, 'Hello,How,Are,You,Today'), "\n";</syntaxhighlight>
CLI one-liner form:
<syntaxhighlight lang="perl">echo "Hello,How,Are,You,Today" | perl -aplF/,/ -e '$" = "."; $_ = "@F";'</syntaxhighlight>
which is a compact way of telling Perl to do
<syntaxhighlight lang="perl">BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined($_ = <ARGV>)) {
chomp $_;
our(@F) = split(/,/, $_, 0);
$" = '.';
$_ = "@F";
}
continue {
die "-p destination: $!\n" unless print $_;
}</syntaxhighlight>


=={{header|Perl 6}}==
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
{{works with|Rakudo|#22 "Thousand Oaks"}}
<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>
<lang perl6>'Hello,How,Are,You,Today'.split(',').join('.').say;</lang>
<!--</syntaxhighlight>-->
{{Out}}
<pre>
"Hello.How.Are.You.Today"
</pre>


=={{header|PicoLisp}}==
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">/# "Hello,How,Are,You,Today" "," "." subst print #/
<lang PicoLisp>(mapcar pack
(split (chop "Hello,How,Are,You,Today") ",") )</lang>
"Hello,How,Are,You,Today" "," " " subst split len for get print "." print endfor</syntaxhighlight>
=={{header|Pike}}==
<lang pike>("Hello,How,Are,You,Today" / ",") * ".";</lang>


=={{header|PHP}}==
=={{header|PHP}}==
{{works with|PHP|5.x}}
{{works with|PHP|5.x}}


<lang php><?php
<syntaxhighlight lang="php"><?php
$str = 'Hello,How,Are,You,Today';
$str = 'Hello,How,Are,You,Today';
echo implode('.', explode(',', $str));
echo implode('.', explode(',', $str));
?></lang>
?></syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="picolisp">(mapcar pack
(split (chop "Hello,How,Are,You,Today") ",") )</syntaxhighlight>

=={{header|Pike}}==
<syntaxhighlight lang="pike">("Hello,How,Are,You,Today" / ",") * ".";</syntaxhighlight>


=={{header|PL/I}}==
=={{header|PL/I}}==
<syntaxhighlight lang="pli">tok: Proc Options(main);
<lang PL/I>
declare s character (100) initial ('Hello,How,Are,You,Today');
declare s character (100) initial ('Hello,How,Are,You,Today');
declare n fixed binary (31);
declare n fixed binary (31);
Line 1,087: Line 3,039:
put skip list (string(table));
put skip list (string(table));
end;
end;
end;</syntaxhighlight>
</lang>
{{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}}==
<syntaxhighlight lang="plainenglish">To run:
Start up.
Split "Hello,How,Are,You,Today" into some string things given the comma byte.
Join the string things with the period byte giving a string.
Destroy the string things.
Write the string on the console.
Wait for the escape key.
Shut down.

To join some string things with a byte giving a string:
Get a string thing from the string things.
Loop.
If the string thing is nil, exit.
Append the string thing's string to the string.
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.</syntaxhighlight>
{{out}}
<pre>
Hello.How.Are.You.Today
</pre>


=={{header|Pop11}}==
=={{header|Pop11}}==
Line 1,096: Line 3,117:
First show the use of sysparse_string to break up a string and make a list of strings.
First show the use of sysparse_string to break up a string and make a list of strings.


<lang pop11>;;; Make a list of strings from a string using space as separator
<syntaxhighlight lang="pop11">;;; Make a list of strings from a string using space as separator
lvars list;
lvars list;
sysparse_string('the cat sat on the mat') -> list;
sysparse_string('the cat sat on the mat') -> list;
;;; print the list of strings
;;; print the list of strings
list =>
list =>
** [the cat sat on the mat]</lang>
** [the cat sat on the mat]</syntaxhighlight>


By giving it an extra parameter 'true' we can make it recognize numbers and produce a list of strings and numbers
By giving it an extra parameter 'true' we can make it recognize numbers and produce a list of strings and numbers


<lang pop11>lvars list;
<syntaxhighlight lang="pop11">lvars list;
sysparse_string('one 1 two 2 three 3 four 4', true) -> list;
sysparse_string('one 1 two 2 three 3 four 4', true) -> list;
;;; print the list of strings and numbers
;;; print the list of strings and numbers
Line 1,114: Line 3,135:
** <true>
** <true>
isinteger(list(2))=>
isinteger(list(2))=>
** <true></lang>
** <true></syntaxhighlight>


Now show some uses of the built in procedure sys_parse_string, which allows more options:
Now show some uses of the built in procedure sys_parse_string, which allows more options:


<lang pop11>;;; Make pop-11 print strings with quotes
<syntaxhighlight lang="pop11">;;; Make pop-11 print strings with quotes
true -> pop_pr_quotes;
true -> pop_pr_quotes;
;;;
;;;
Line 1,132: Line 3,153:
;;; print the list of strings
;;; print the list of strings
strings =>
strings =>
** ['Hello' 'How' 'Are' 'You' 'Today']</lang>
** ['Hello' 'How' 'Are' 'You' 'Today']</syntaxhighlight>


If {% ... %} were used instead of [% ... %] the result would be
If {% ... %} were used instead of [% ... %] the result would be
a vector (i.e. array) of strings rather than a list of strings.
a vector (i.e. array) of strings rather than a list of strings.


<lang pop11>{% sys_parse_string(str, `,`) %} -> strings;
<syntaxhighlight lang="pop11">{% sys_parse_string(str, `,`) %} -> strings;
;;; print the vector
;;; print the vector
strings =>
strings =>
** {'Hello' 'How' 'Are' 'You' 'Today'}</lang>
** {'Hello' 'How' 'Are' 'You' 'Today'}</syntaxhighlight>
It is also possible to give sys_parse_string a 'conversion' procedure, which is applied to each of the tokens.
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:
E.g. it could be used to produce a vector of numbers, using the conversion procedure 'strnumber', which converts a string to a number:


<lang pop11>lvars numbers;
<syntaxhighlight lang="pop11">lvars numbers;
{% sys_parse_string('100 101 102 103 99.9 99.999', strnumber) %} -> numbers;
{% sys_parse_string('100 101 102 103 99.9 99.999', strnumber) %} -> numbers;
;;; the result is a vector containing integers and floats,
;;; the result is a vector containing integers and floats,
;;; which can be printed thus:
;;; which can be printed thus:
numbers =>
numbers =>
** {100 101 102 103 99.9 99.999}</lang>
** {100 101 102 103 99.9 99.999}</syntaxhighlight>


Using lower level pop-11 facilities to tokenise the string:
Using lower level pop-11 facilities to tokenise the string:


<lang pop11>;;; Declare and initialize variables
<syntaxhighlight lang="pop11">;;; Declare and initialize variables
lvars str='Hello,How,Are,You,Today';
lvars str='Hello,How,Are,You,Today';
;;; Iterate over string
;;; Iterate over string
Line 1,171: Line 3,192:
endif;
endif;
;;; Reverse the list
;;; Reverse the list
rev(ls) -> ls;</lang>
rev(ls) -> ls;</syntaxhighlight>


Since the task requires to use array we convert list to array
Since the task requires to use array we convert list to array


<lang pop11>;;; Put list elements and lenght on the stack
<syntaxhighlight lang="pop11">;;; Put list elements and lenght on the stack
destlist(ls);
destlist(ls);
;;; Build a vector from them
;;; Build a vector from them
Line 1,183: Line 3,204:
printf(ar(i), '%s.');
printf(ar(i), '%s.');
endfor;
endfor;
printf('\n');</lang>
printf('\n');</syntaxhighlight>


We could use list directly for printing:
We could use list directly for printing:


<lang pop11>for i in ls do
<syntaxhighlight lang="pop11">for i in ls do
printf(i, '%s.');
printf(i, '%s.');
endfor;</lang>
endfor;</syntaxhighlight>


so the conversion to vector is purely to satisfy task formulation.
so the conversion to vector is purely to satisfy task formulation.

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

<lang powerbasic>FUNCTION PBMAIN () AS LONG
DIM parseMe AS STRING
parseMe = "Hello,How,Are,You,Today"

REDIM parsed(PARSECOUNT(parseMe) - 1) AS STRING
PARSE parseMe, parsed() 'comma is default delimiter

DIM L0 AS LONG, outP AS STRING
outP = parsed(0)
FOR L0 = 1 TO UBOUND(parsed) 'could reuse parsecount instead of ubound
outP = outP & "." & parsed(L0)
NEXT

MSGBOX outP
END FUNCTION</lang>


=={{header|PowerShell}}==
=={{header|PowerShell}}==
{{works with|PowerShell|1}}
{{works with|PowerShell|1}}
<lang powershell>$words = "Hello,How,Are,You,Today".Split(',')
<syntaxhighlight lang="powershell">$words = "Hello,How,Are,You,Today".Split(',')
[string]::Join('.', $words)</lang>
[string]::Join('.', $words)</syntaxhighlight>


{{works with|PowerShell|2}}
{{works with|PowerShell|2}}
<lang powershell>$words = "Hello,How,Are,You,Today" -split ','
<syntaxhighlight lang="powershell">$words = "Hello,How,Are,You,Today" -split ','
$words -join '.'</lang>
$words -join '.'</syntaxhighlight>


{{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>
Hello.How.Are.You.Today
Hello.Goodbye
</pre>


=={{header|Prolog}}==
=={{header|Prolog}}==
{{works with|SWI Prolog}}
{{works with|SWI Prolog}}
<lang prolog>splitup(Sep,[token(B)|BL]) --> splitup(Sep,B,BL).
<syntaxhighlight lang="prolog">splitup(Sep,[token(B)|BL]) --> splitup(Sep,B,BL).
splitup(Sep,[A|AL],B) --> [A], {\+ [A] = Sep }, splitup(Sep,AL,B).
splitup(Sep,[A|AL],B) --> [A], {\+ [A] = Sep }, splitup(Sep,AL,B).
splitup(Sep,[],[B|BL]) --> Sep, splitup(Sep,B,BL).
splitup(Sep,[],[B|BL]) --> Sep, splitup(Sep,B,BL).
Line 1,233: Line 3,244:
phrase(splitup(".",Tokens),Backtogether),
phrase(splitup(".",Tokens),Backtogether),
string_to_list(ABack,Backtogether),
string_to_list(ABack,Backtogether),
writeln(ABack).</lang>
writeln(ABack).</syntaxhighlight>
{{out}}
Output:
<pre>?- start.
<pre>
?- start.
Hello.How.Are.You.Today</pre>
Hello.How.Are.You.Today
</pre>


{{works with|SWI Prolog 7}}
=={{header|PureBasic}}==


Using the SWI Prolog string data type and accompanying predicates,
'''As described
this can be accomplished in a few lines in the top level:
<lang PureBasic>NewList MyStrings.s()


<syntaxhighlight lang="prolog">
For i=1 To 5
?- split_string("Hello,How,Are,You,Today", ",", "", Split),
AddElement(MyStrings())
| atomics_to_string(Split, ".", PeriodSeparated),
MyStrings()=StringField("Hello,How,Are,You,Today",i,",")
| writeln(PeriodSeparated).
Next i
Hello.How.Are.You.Today

</syntaxhighlight>
ForEach MyStrings()
Print(MyStrings()+".")
Next</lang>

'''Still, easier would be
<lang PureBasic>Print(ReplaceString("Hello,How,Are,You,Today",",","."))</lang>


=={{header|Python}}==
=={{header|Python}}==
{{works with|Python|2.5}}{{works with|Python|3.0}}
{{works with|Python|2.5}}{{works with|Python|3.0}}


<lang python>text = "Hello,How,Are,You,Today"
<syntaxhighlight lang="python">text = "Hello,How,Are,You,Today"
tokens = text.split(',')
tokens = text.split(',')
print ('.'.join(tokens))</lang>
print ('.'.join(tokens))</syntaxhighlight>


Or if interpretation of the task description means you don't need to keep an intermediate array:
Or if interpretation of the task description means you don't need to keep an intermediate array:
<lang python>print ('.'.join('Hello,How,Are,You,Today'.split(',')))</lang>
<syntaxhighlight lang="python">print ('.'.join('Hello,How,Are,You,Today'.split(',')))</syntaxhighlight>

=={{header|Q}}==
<syntaxhighlight lang="q">words: "," vs "Hello,How,Are,You,Today"
"." sv words</syntaxhighlight>

{{out}}
<pre>"Hello.How.Are.You.Today"</pre>

=={{header|QB64}}==
''CBTJD'': 2020/03/12
<syntaxhighlight lang="vb">a$ = "Hello,How,Are,You,Today" ' | Initialize original string.
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.
NEXT ' | End of loop.
DIM t$(nc) ' | Dim t$ array with total number of commas (nc). Array base is 0.
FOR nb = 1 TO LEN(a$) ' | Start loop to find each word.
c$ = MID$(a$, nb, 1) ' | Look at each character in the string.
IF c$ = "," THEN ' | If the character is a comma, increase the t$ array for the next word.
t = t + 1 ' | t = token word count. Starts at 0 because array base is 0.
ELSE ' | Or...
t$(t) = t$(t) + c$ ' | Add each character to the current token (t$) word.
END IF ' | End of decision tree.
NEXT ' | End of loop.
FOR nd = 0 TO t ' | Start loop to create final desired output.
tf$ = tf$ + t$(nd) + "." ' | Add each token word from t$ followed by a period to the final tf$.
NEXT ' | End of loop.
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
<syntaxhighlight lang="vb">a$ = "Hello,How,Are,You,Today" ' | Initialize original string.
DIM t$(LEN(a$) / 2) ' | Create an overestimated sized array.
FOR nd = 1 TO LEN(a$) ' | Start loop to find each comma.
IF MID$(a$, nd, 1) = "," THEN ' | If a comma is found...
tc = tc + 1 ' | Increment tc for each found comma.
t$(tc) = word$(a$, tc, ",") ' | Assign tc word to t$(tc) array.
END IF ' | End decision tree.
NEXT ' | End loop.
t$(tc + 1) = word$(a$, tc + 1, ",") ' | Assign last word to next array position.
ft$ = t$(1) ' | Start final return string ft$ with first array value.
FOR ne = 2 TO tc + 1 ' | Start loop to add periods and array values.
ft$ = ft$ + "." + t$(ne) ' | Concatenate a period with subsequent array values.
NEXT ' | End loop.
PRINT ft$ ' | Print final return string ft$.

FUNCTION word$ (inSTG$, inDEC, inPRM$) ' | word$ function accepts original string, word number, and separator.
inSTG$ = inSTG$ + inPRM$ ' | Add a separator to the end of the original string.
FOR na = 1 TO LEN(inSTG$) ' | Start loop to count total number of separators.
IF MID$(inSTG$, na, 1) = inPRM$ THEN nc = nc + 1 ' | If separator found, increment nc.
NEXT ' | End loop.
IF inDEC > nc THEN word$ = "": GOTO DONE ' | If requested word number (inDEC) is greater than total words (nc), bail.
FOR nd = 1 TO inDEC ' | Start loop to find requested numbered word.
last = st ' | Remember the position of the last separator.
st = INSTR(last + 1, inSTG$, inPRM$) ' | Find the next separator.
NEXT ' | End loop.
word$ = MID$(inSTG$, last + 1, st - last - 1) ' | Return requested word.
DONE: ' | Label for bail destination of word count error check.
END FUNCTION ' | End of function.
</syntaxhighlight>

=={{header|Quackery}}==

<syntaxhighlight lang="quackery"> [ [] [] rot
witheach
[ dup char , = iff
[ drop nested join [] ]
else join ]
nested join ] is tokenise ( $ --> [ )
[ witheach [ echo$ say "." ] ] is display ( [ --> )
$ "Hello,How,Are,You,Today" tokenise display</syntaxhighlight>

{{Out}}

<pre>Hello.How.Are.You.Today.</pre>


=={{header|R}}==
=={{header|R}}==
<lang R>text <- "Hello,How,Are,You,Today"
<syntaxhighlight lang="r">text <- "Hello,How,Are,You,Today"
junk <- strsplit(text, split=",")
junk <- strsplit(text, split=",")
print(paste(unlist(junk), collapse="."))</lang>
print(paste(unlist(junk), collapse="."))</syntaxhighlight>


or the one liner
or the one liner


<lang R>paste(unlist(strsplit(text, split=",")), collapse=".")</lang>
<syntaxhighlight lang="r">paste(unlist(strsplit(text, split=",")), collapse=".")</syntaxhighlight>


=={{header|Racket}}==

<syntaxhighlight lang="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" line>'Hello,How,Are,You,Today'.split(',').join('.').say;</syntaxhighlight>

Or with function calls:

<syntaxhighlight lang="raku" line>say join '.', split ',', 'Hello,How,Are,You,Today';</syntaxhighlight>


=={{header|Raven}}==
=={{header|Raven}}==
<lang raven>'Hello,How,Are,You,Today' ',' split '.' join print</lang>
<syntaxhighlight lang="raven">'Hello,How,Are,You,Today' ',' split '.' join print</syntaxhighlight>


=={{header|REBOL}}==
=={{header|REBOL}}==
<lang REBOL>print ["Original:" original: "Hello,How,Are,You,Today"]
<syntaxhighlight lang="rebol">print ["Original:" original: "Hello,How,Are,You,Today"]
tokens: parse original ","
tokens: parse original ","
dotted: "" repeat i tokens [append dotted rejoin [i "."]]
dotted: "" repeat i tokens [append dotted rejoin [i "."]]
print ["Dotted: " dotted]</lang>
print ["Dotted: " dotted]</syntaxhighlight>


{{out}}
Output:
<pre>
Original: Hello,How,Are,You,Today
Dotted: Hello.How.Are.You.Today.
</pre>


=={{header|Red}}==
<pre>Original: Hello,How,Are,You,Today
Dotted: Hello.How.Are.You.Today.</pre>
<syntaxhighlight lang="red">str: "Hello,How,Are,You,Today"
>> tokens: split str ","
>> probe tokens
["Hello" "How" "Are" "You" "Today"]


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


=={{header|Retro}}==
=={{header|Retro}}==
<syntaxhighlight lang="retro">{{
<lang Retro>{{
: char ( -$ ) " " ;
: char ( -$ ) " " ;
: tokenize ( $-$$ )
: tokenize ( $-$$ )
Line 1,303: Line 3,416:
[ tokenize action dup 1 <> ] while drop
[ tokenize action dup 1 <> ] while drop
^buffer'get drop ;
^buffer'get drop ;
}}</lang>
}}</syntaxhighlight>


This will suffice to split a string into an array of substrings. It is used like this:
This will suffice to split a string into an array of substrings. It is used like this:


<lang Retro>create strings 100 allot
<syntaxhighlight lang="retro">create strings 100 allot
"Hello,How,Are,You,Today" ', strings split</lang>
"Hello,How,Are,You,Today" ', strings split</syntaxhighlight>


Since the buffer' vocabulary creates a zero-terminated buffer, we can display it using the each@ combinator and a simple quote:
Since the buffer' vocabulary creates a zero-terminated buffer, we can display it using the each@ combinator and a simple quote:


<lang Retro>strings [ @ "%s." puts ] ^types'STRING each@</lang>
<syntaxhighlight lang="retro">strings [ @ "%s." puts ] ^types'STRING each@</syntaxhighlight>


=={{header|REXX}}==
=={{header|REXX}}==
===version 1===
===version 1===
This REXX version doesn't append a period to the last word in the list.
<lang rexx>sss='Hello,How,Are,You,Today' /*words seperated by commas. */
<syntaxhighlight lang="rexx">/*REXX program separates a string of comma─delimited words, and echoes them ──► terminal*/
say 'input string='sss /*echo the string to console. */
original = 'Hello,How,Are,You,Today' /*some words separated by commas (,). */
say
new=sss /*make a copy of the string. */
say 'The input string:' original /*display original string ──► terminal.*/
new= original /*make a copy of the string. */

do items=1 until new=='' /*keep going until SSS is empty.*/
do #=1 until new=='' /*keep processing until NEW is empty.*/
parse var new a.items ',' new /*parse words delinated by comma*/
parse var new @.# ',' new /*parse words delineated by a comma (,)*/
end /*#*/ /* [↑] the new array is named @. */
end
say /* NEW is destructively parsed. [↑] */

say 'Words in the string:' /*Display a header for the list.*/
say center(' Words in the string ', 40, "═") /*display a nice header for the list. */
do j=1 for # /*display all the words (one per line),*/

do k=1 for items /*Now, display all the words. */
say @.j || left(., j\==#) /*maybe append a period (.) to a word. */
say a.k'.' /*append a period to the word. */
end /*j*/ /* [↑] don't append a period if last. */
say center(' End─of─list ', 40, "═") /*display a (EOL) trailer for the list.*/</syntaxhighlight>
end
{{out|output|text=&nbsp; when using the internal default input:}}

say 'End-of-list.' /*Display a trailer for the list*/</lang>
Output:
<pre>
<pre>
input string=Hello,How,Are,You,Today
The input string: Hello,How,Are,You,Today


Words in the string:
═════════ Words in the string ══════════
Hello.
Hello.
How.
How.
Are.
Are.
You.
You.
Today.
Today
═════════════ End─of─list ══════════════
End-of-list.
</pre>
</pre>


===version 2===
===version 2===
This REXX version won't work if any of the words have an embedded blank (or possible a tab character) in them, as in:
<lang rexx>sss='Hello,How,Are,You,Today' /*words seperated by commas. */
say 'input string='sss /*echo the string to console. */
say
say 'Words in the string:' /*Display a header for the list. */


Hello,Betty Sue,How,Are,You,Today
do until sss=='' /*keep going until SSS is empty. */
<syntaxhighlight lang="rexx">/*REXX program to separate a string of comma-delimited words and echo */
parse var sss x ',' sss /*parse words delinated by comma.*/
sss='Hello,How,Are,You,Today'
say x'.' /*show a word appended with a '.'*/
say 'input string='sss
end
say ''
say 'Words in the string:'
ss =translate(sss,' ',',')
dot='.'
Do i=1 To words(ss)
If i=words(ss) Then dot=''
say word(ss,i)dot
End
say 'End-of-list.'</syntaxhighlight>
'''output''' is similar to REXX version 1.


=={{header|Ring}}==
say 'End-of-list.' /*Display a trailer for the list.*/</lang>
<syntaxhighlight lang="ring">
Output is identical to Version 1.
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|Ruby}}==
<lang ruby>puts "Hello,How,Are,You,Today".split(',').join('.')</lang>
<syntaxhighlight lang="ruby">puts "Hello,How,Are,You,Today".split(',').join('.')</syntaxhighlight>

=={{header|Rust}}==
<syntaxhighlight lang="rust">fn main() {
let s = "Hello,How,Are,You,Today";
let tokens: Vec<&str> = s.split(",").collect();
println!("{}", tokens.join("."));
}</syntaxhighlight>

=={{header|S-lang}}==
<syntaxhighlight lang="s-lang">variable a = strchop("Hello,How,Are,You,Today", ',', 0);
print(strjoin(a, "."));</syntaxhighlight>

{{out}}
<pre>"Hello.How.Are.You.Today"</pre>


=={{header|Scala}}==
=={{header|Scala}}==
<lang scala>println("Hello,How,Are,You,Today" split "," mkString ".")</lang>
<syntaxhighlight lang="scala">println("Hello,How,Are,You,Today" split "," mkString ".")</syntaxhighlight>


=={{header|Scheme}}==
=={{header|Scheme}}==
{{works with|Guile}}
{{works with|Guile}}
<lang scheme>(use-modules (ice-9 regex))
<syntaxhighlight lang="scheme">(use-modules (ice-9 regex))
(define s "Hello,How,Are,You,Today")
(define s "Hello,How,Are,You,Today")
(define words (map match:substring (list-matches "[^,]+" s)))
(define words (map match:substring (list-matches "[^,]+" s)))
Line 1,374: Line 3,546:
(display (list-ref words n))
(display (list-ref words n))
(if (< n (- (length words) 1))
(if (< n (- (length words) 1))
(display ".")))</lang>
(display ".")))</syntaxhighlight>


(with SRFI 13)
(with SRFI 13)
<lang scheme>(define s "Hello,How,Are,You,Today")
<syntaxhighlight lang="scheme">(define s "Hello,How,Are,You,Today")
(define words (string-tokenize s (char-set-complement (char-set #\,))))
(define words (string-tokenize s (char-set-complement (char-set #\,))))
(define t (string-join words "."))</lang>
(define t (string-join words "."))</syntaxhighlight>

{{works with|Gauche Scheme}}
<syntaxhighlight lang="scheme">(print
(string-join
(string-split "Hello,How,Are,You,Today" #\,)
".")) </syntaxhighlight>
{{output}}
<pre>
Hello.How.Are.You.Today
</pre>


=={{header|Seed7}}==
=={{header|Seed7}}==
<lang seed7>var array string: tokens is 0 times "";
<syntaxhighlight lang="seed7">var array string: tokens is 0 times "";

tokens := split("Hello,How,Are,You,Today", ",");</syntaxhighlight>

=={{header|Self}}==
<syntaxhighlight lang="self">| s = 'Hello,How,Are,You,Today' |
((s splitOn: ',') joinUsing: '.') printLine.
</syntaxhighlight>

=={{header|Sidef}}==
<syntaxhighlight lang="ruby">'Hello,How,Are,You,Today'.split(',').join('.').say;</syntaxhighlight>
=={{header|Simula}}==
<syntaxhighlight lang="simula">BEGIN

CLASS TEXTARRAY(N); INTEGER N;
BEGIN
TEXT ARRAY ARR(1:N);
END TEXTARRAY;

REF(TEXTARRAY) PROCEDURE SPLIT(T,DELIM); TEXT T; CHARACTER DELIM;
BEGIN
INTEGER N, I, LPOS;
REF(TEXTARRAY) A;

N := 1;
T.SETPOS(1);
WHILE T.MORE DO
IF T.GETCHAR = DELIM THEN
N := N+1;
A :- NEW TEXTARRAY(N);

I := 0;
LPOS := 1;
T.SETPOS(LPOS);
WHILE T.MORE DO
IF T.GETCHAR = DELIM THEN
BEGIN
I := I+1;
A.ARR(I) :- T.SUB(LPOS,T.POS-LPOS-1);
LPOS := T.POS;
END;
I := I+1;
A.ARR(I) :- T.SUB(LPOS,T.LENGTH-LPOS+1);
SPLIT :- A;
END SPLIT;

BEGIN
TEXT S;
REF(TEXTARRAY) TA;
INTEGER I;

S :- "HELLO,HOW,ARE,YOU,TODAY";
TA :- SPLIT(S,',');
FOR I := 1 STEP 1 UNTIL TA.N DO
BEGIN
OUTTEXT(TA.ARR(I));
OUTCHAR('.');
END;
OUTIMAGE;
END;


END.
tokens := split("Hello,How,Are,You,Today", ",");</lang>
</syntaxhighlight>
{{out}}
<pre>HELLO.HOW.ARE.YOU.TODAY.</pre>


=={{header|Slate}}==
=={{header|Slate}}==
<lang slate>('Hello,How,Are,You,Today' splitWith: $,) join &separator: '.'.</lang>
<syntaxhighlight lang="slate">('Hello,How,Are,You,Today' splitWith: $,) join &separator: '.'.</syntaxhighlight>

=={{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}}==
=={{header|Smalltalk}}==
<lang smalltalk>|array |
<syntaxhighlight lang="smalltalk">|array |
array := 'Hello,How,Are,You,Today' subStrings: $,.
array := 'Hello,How,Are,You,Today' subStrings: $,.
array fold: [:concatenation :string | concatenation, '.', string ]</lang>
array fold: [:concatenation :string | concatenation, '.', string ]</syntaxhighlight>


Some implementations also have a ''join:'' convenience method that allows the following shorter solution:
Some implementations also have a ''join:'' convenience method that allows the following shorter solution:


<lang smalltalk>('Hello,How,Are,You,Today' subStrings: $,) join: '.'</lang>
<syntaxhighlight lang="smalltalk">('Hello,How,Are,You,Today' subStrings: $,) join: '.'</syntaxhighlight>


The solution displaying a trailing period would be:
The solution displaying a trailing period would be:


<lang smalltalk>|array |
<syntaxhighlight lang="smalltalk">|array |
array := 'Hello,How,Are,You,Today' subStrings: $,.
array := 'Hello,How,Are,You,Today' subStrings: $,.
array inject: '' into: [:concatenation :string | concatenation, string, '.' ]</lang>
array inject: '' into: [:concatenation :string | concatenation, string, '.' ]</syntaxhighlight>


=={{header|SNOBOL4}}==
=={{header|SNOBOL4}}==
Line 1,408: Line 3,662:
For this task, it's convenient to define Perl-style split( ) and join( ) functions.
For this task, it's convenient to define Perl-style split( ) and join( ) functions.


<lang SNOBOL4> define('split(chs,str)i,j,t,w2') :(split_end)
<syntaxhighlight lang="snobol4"> define('split(chs,str)i,j,t,w2') :(split_end)
split t = table()
split t = table()
sp1 str pos(0) (break(chs) | rem) $ t<i = i + 1>
sp1 str pos(0) (break(chs) | rem) $ t<i = i + 1>
Line 1,424: Line 3,678:
* # Test and display
* # Test and display
output = join('.',split(',','Hello,How,Are,You,Today'))
output = join('.',split(',','Hello,How,Are,You,Today'))
end</lang>
end</syntaxhighlight>


{{out}}
Output:
<pre>
<pre>Hello.How.Are.You.Today</pre>
Hello.How.Are.You.Today
</pre>


=={{header|Standard ML}}==
=={{header|Standard ML}}==
<lang sml>val splitter = String.tokens (fn c => c = #",");
<syntaxhighlight lang="sml">val splitter = String.tokens (fn c => c = #",");
val main = (String.concatWith ".") o splitter;</lang>
val main = (String.concatWith ".") o splitter;</syntaxhighlight>


Test:
Test:


<lang sml>- main "Hello,How,Are,You,Today"
<syntaxhighlight lang="sml">- main "Hello,How,Are,You,Today"
val it = "Hello.How.Are.You.Today" : string</lang>
val it = "Hello.How.Are.You.Today" : string</syntaxhighlight>

=={{header|Swift}}==

{{works with|Swift|3.x}}
<syntaxhighlight lang="swift">let text = "Hello,How,Are,You,Today"
let tokens = text.components(separatedBy: ",") // for single or multi-character separator
print(tokens)
let result = tokens.joined(separator: ".")
print(result)</syntaxhighlight>

{{works with|Swift|2.x}}
<syntaxhighlight lang="swift">let text = "Hello,How,Are,You,Today"
let tokens = text.characters.split(",").map{String($0)} // for single-character separator
print(tokens)
let result = tokens.joinWithSeparator(".")
print(result)</syntaxhighlight>

{{works with|Swift|1.x}}
<syntaxhighlight lang="swift">let text = "Hello,How,Are,You,Today"
let tokens = split(text, { $0 == "," }) // for single-character separator
println(tokens)
let result = ".".join(tokens)
println(result)</syntaxhighlight>

For multi-character separators:<syntaxhighlight lang="swift">import Foundation

let text = "Hello,How,Are,You,Today"
let tokens = text.componentsSeparatedByString(",")
print(tokens)</syntaxhighlight>


=={{header|Tcl}}==
=={{header|Tcl}}==
Generating a list form a string by splitting on a comma:
Generating a list form a string by splitting on a comma:
<lang tcl>split $string ","</lang>
<syntaxhighlight lang="tcl">split $string ","</syntaxhighlight>


Joining the elements of a list by a period:
Joining the elements of a list by a period:
<lang tcl>join $list "."</lang>
<syntaxhighlight lang="tcl">join $list "."</syntaxhighlight>


Thus the whole thing would look like this:
Thus the whole thing would look like this:
<lang tcl>puts [join [split "Hello,How,Are,You,Today" ","] "."]</lang>
<syntaxhighlight lang="tcl">puts [join [split "Hello,How,Are,You,Today" ","] "."]</syntaxhighlight>


If you'd like to retain the list in a variable with the name "words", it would only be marginally more complex:
If you'd like to retain the list in a variable with the name "words", it would only be marginally more complex:
<lang tcl>puts [join [set words [split "Hello,How,Are,You,Today" ","]] "."]</lang>
<syntaxhighlight lang="tcl">puts [join [set words [split "Hello,How,Are,You,Today" ","]] "."]</syntaxhighlight>


(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.)
(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 1,456: Line 3,741:
<code>tr</code> knows nothing about arrays, so this solution only changes each comma to a period.
<code>tr</code> knows nothing about arrays, so this solution only changes each comma to a period.


<lang bash>echo 'Hello,How,Are,You,Today' | tr ',' '.'</lang>
<syntaxhighlight lang="bash">echo 'Hello,How,Are,You,Today' | tr ',' '.'</syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
SET string="Hello,How,Are,You,Today"
SET string=SPLIT (string,":,:")
SET string=JOIN (string,".")
</syntaxhighlight>


=={{header|TXR}}==
=={{header|TXR}}==
Line 1,463: Line 3,769:
sequences of non-commas.
sequences of non-commas.


<lang txr>@(next :list "Hello,How,Are,You,Today")
<syntaxhighlight lang="txr">@(next :list "Hello,How,Are,You,Today")
@(coll)@{token /[^,]+/}@(end)
@(coll)@{token /[^,]+/}@(end)
@(output)
@(output)
@(rep)@token.@(last)@token@(end)
@(rep)@token.@(last)@token@(end)
@(end)</lang>
@(end)</syntaxhighlight>


Different approach. Collect tokens, each of
Different approach. Collect tokens, each of
Line 1,473: Line 3,779:
before a comma, or else extends to the end of the line.
before a comma, or else extends to the end of the line.


<lang txr>@(next :list "Hello,How,Are,You,Today")
<syntaxhighlight lang="txr">@(next :list "Hello,How,Are,You,Today")
@(coll)@(maybe)@token,@(or)@token@(end)@(end)
@(coll)@(maybe)@token,@(or)@token@(end)@(end)
@(output)
@(output)
@(rep)@token.@(last)@token@(end)
@(rep)@token.@(last)@token@(end)
@(end)</lang>
@(end)</syntaxhighlight>


Using TXR Lisp:
Using TXR Lisp:


<lang txr>@(bind result @(cat-str (split-str "Hello,How,Are,You,Today" ",") "."))</lang>
<syntaxhighlight lang="bash">txr -p '(cat-str (split-str "Hello,How,Are,You,Today" ",") ".")'
Hello.How.Are.You.Today</syntaxhighlight>

<pre>$ txr tok.txr
result="Hello.How.Are.You.Today"</pre>

=={{header|TUSCRIPT}}==
<lang tuscript>
$$ MODE TUSCRIPT
SET string="Hello,How,Are,You,Today"
SET string=SPLIT (string,":,:")
SET string=JOIN (string,".")
</lang>

=={{header|UnixPipes}}==
{{works with|Bourne Shell}}
<lang bash>token() {
(IFS=, read -r A B; echo "$A".; test -n "$B" && (echo "$B" | token))
}

echo "Hello,How,Are,You" | token</lang>


=={{header|UNIX Shell}}==
=={{header|UNIX Shell}}==
{{works with|Bourne Shell}}
{{works with|Bourne Shell}}
<lang bash>string='Hello,How,Are,You,Today'
<syntaxhighlight lang="bash">string='Hello,How,Are,You,Today'


(IFS=,
(IFS=,
printf '%s.' $string
printf '%s.' $string
echo)</lang>
echo)</syntaxhighlight>


----
----
{{works with|Bourne Again SHell}}
{{works with|Bourne Again SHell}}
{{works with|Public Domain Korn SHell|5.2.14}}
{{works with|Public Domain Korn SHell|5.2.14}}
<lang bash>#! /bin/bash
<syntaxhighlight lang="bash">#! /bin/bash
stripchar-l ()
stripchar-l ()
#removes the specified character from the left side of the string
#removes the specified character from the left side of the string
Line 1,570: Line 3,858:
join "$( split "$list" "$input_delimiter" )" \
join "$( split "$list" "$input_delimiter" )" \
"$contains_a_space" "$output_delimiter";
"$contains_a_space" "$output_delimiter";
}</lang>
}</syntaxhighlight>


''Example''
''Example''


<lang bash> strtokenize "Hello,How,Are,You,Today" "," "."
<syntaxhighlight lang="bash"> strtokenize "Hello,How,Are,You,Today" "," "."
Hello.How.Are.You.Today </lang>
Hello.How.Are.You.Today </syntaxhighlight>

----
{{works with|Almquist Shell}}
{{works with|bash}}
{{works with|pdksh}}
{{works with|ksh93}}
{{works with|zsh}}
<syntaxhighlight lang="sh">
string1="Hello,How,Are,You,Today"
elements_quantity=$(echo $string1|tr "," "\n"|wc -l)

present_element=1
while [ $present_element -le $elements_quantity ];do
echo $string1|cut -d "," -f $present_element|tr -d "\n"
if [ $present_element -lt $elements_quantity ];then echo -n ".";fi
present_element=$(expr $present_element + 1)
done
echo

# or to cheat
echo "Hello,How,Are,You,Today"|tr "," "."</syntaxhighlight>

=={{header|UnixPipes}}==
{{works with|Bourne Shell}}
<syntaxhighlight lang="bash">token() {
(IFS=, read -r A B; echo "$A".; test -n "$B" && (echo "$B" | token))
}

echo "Hello,How,Are,You" | token</syntaxhighlight>

=={{header|Ursa}}==
<syntaxhighlight lang="ursa">decl string text
set text "Hello,How,Are,You,Today"
decl string<> tokens
set tokens (split text ",")
for (decl int i) (< i (size tokens)) (inc i)
out tokens<i> "." console
end for
out endl console</syntaxhighlight>


=={{header|Ursala}}==
=={{header|Ursala}}==
Line 1,583: Line 3,910:
second order function parameterized by the delimiter. Character
second order function parameterized by the delimiter. Character
literals are preceded by a backquote.
literals are preceded by a backquote.
<lang Ursala>#import std
<syntaxhighlight lang="ursala">#import std


token_list = sep`, 'Hello,How,Are,You,Today'
token_list = sep`, 'Hello,How,Are,You,Today'
Line 1,589: Line 3,916:
#cast %s
#cast %s


main = mat`. token_list</lang>
main = mat`. token_list</syntaxhighlight>
{{out}}
output:
<pre>
<pre>'Hello.How.Are.You.Today'</pre>
'Hello.How.Are.You.Today'
</pre>


=={{header|Vala}}==
=={{header|Vala}}==
<syntaxhighlight lang="vala">void main() {
<lang vala>
string s = "Hello,How,Are,You,Today";
// declare test string
print(@"$(string.joinv(".", s.split(",")))");
string s = "Hello,How,Are,You,Today";
}</syntaxhighlight>
// create array of strings, could use var words instead if desired
{{out}}
string[] words = s.split(",");
<pre>Hello.How.Are.You.Today</pre>
// create string by joining array of strings with .
string joined = string.joinv(".", words);
</lang>


=={{header|VBScript}}==
=={{header|VBA}}==
<syntaxhighlight lang="vb">Sub Main()
====One liner====
Dim temp() As String
<lang vb>wscript.echo Join( Split( "Hello,How,Are,You,Today", "," ), "." )</lang>
temp = Tokenize("Hello,How,Are,You,Today", ",")
Display temp, Space(5)
End Sub


Private Function Tokenize(strS As String, sep As String) As String()
In fact, the following Visual Basic could have done the same, as Join() is available.
Tokenize = Split(strS, sep)
End Function


Private Sub Display(arr() As String, sep As String)
=={{header|Visual Basic}}==
Debug.Print Join(arr, sep)
{{trans|PowerBASIC}}
End Sub</syntaxhighlight>
{{Out}}
<pre>Hello How Are You Today</pre>


=={{header|VBScript}}==
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.
<syntaxhighlight lang="vb">

s = "Hello,How,Are,You,Today"
<lang vb>Sub Main()
WScript.StdOut.Write Join(Split(s,","),".")
Dim parseMe As String, parsed As Variant
</syntaxhighlight>
parseMe = "Hello,How,Are,You,Today"
{{Out}}

<pre>Hello.How.Are.You.Today</pre>
parsed = Split(parseMe, ",")

Dim L0 As Long, outP As String
outP = parsed(0)
For L0 = 1 To UBound(parsed)
outP = outP & "." & parsed(L0)
Next

MsgBox outP
End Sub</lang>


=={{header|Vedit macro language}}==
=={{header|Vedit macro language}}==
Line 1,635: Line 3,961:
The contents of each text register is then displayed to user, separated by a period.
The contents of each text register is then displayed to user, separated by a period.


<lang vedit>Buf_Switch(Buf_Free)
<syntaxhighlight lang="vedit">Buf_Switch(Buf_Free)
Ins_Text("Hello,How,Are,You,Today")
Ins_Text("Hello,How,Are,You,Today")


Line 1,654: Line 3,980:
}
}


Buf_Quit(OK)</lang>
Buf_Quit(OK)</syntaxhighlight>

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

<syntaxhighlight lang="winbatch">text = 'Hello,How,Are,You,Today'
result = ''
BoxOpen('WinBatch Tokenizing Example', '')
for ix = 1 to itemcount(text,',')
result = result : itemextract(ix, text, ',') : '.'
BoxText(result)
next
display(10, 'End of Program', 'Dialog and program will close momentarily.')
BoxShut()</syntaxhighlight>

{{out}}
Hello.How.Are.You.Today.

=={{header|Wortel}}==
<syntaxhighlight lang="wortel">@join "." @split "," "Hello,How,Are,You,Today"</syntaxhighlight>
Returns
<pre>"Hello.How.Are.You.Today"</pre>

=={{header|Wren}}==
<syntaxhighlight lang="wren">var s = "Hello,How,Are,You,Today"
var t = s.split(",").join(".") + "."
System.print(t)</syntaxhighlight>

{{out}}
<pre>
Hello.How.Are.You.Today.
</pre>

=={{header|XPath 2.0}}==
<syntaxhighlight lang="xpath">string-join(tokenize("Hello,How,Are,You,Today", ","), ".")</syntaxhighlight>

{{out}}
Hello.How.Are.You.Today

=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">string 0;
include c:\cxpl\codes;
int I, J, K, Char;
char String, Array(5,6); \5 words and 5 maximum chars + terminating 0

[String:= "Hello,How,Are,You,Today";
I:= 0; K:= 0;
repeat J:= 0;
loop [Char:= String(I);
I:= I+1;
if Char=^, or Char=0 then quit;
Array(K,J):= Char;
J:= J+1;
];
Array(K,J):= 0; \terminate word
K:= K+1; \next word in array
until K>=5;
for K:= 4 downto 0 do [Text(0, addr Array(K,0)); ChOut(0, ^.)];
CrLf(0);
]</syntaxhighlight>

The 'addr' operator is used to fetch the 32-bit address of Array rather
than a byte from the character array.

Output (done in reverse order to emphasize the tokens are indeed separate):
<pre>
Today.You.Are.How.Hello.
</pre>

=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">dim s$(1)

n = token("Hello. How are you today?", s$(), ".? ")

for i = 1 to n
print s$(i);
if i < n print ".";
next
print</syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="zkl">"Hello,How,Are,You,Today".split(",").concat(".").println();
Hello.How.Are.You.Today</syntaxhighlight>

=={{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}}==
=={{header|Zsh}}==
<lang zsh>str='Hello,How,Are,You,Today'
<syntaxhighlight lang="zsh">str='Hello,How,Are,You,Today'
tokens=(${(s:,:)str})
tokens=(${(s:,:)str})
print ${(j:.:)tokens}</lang>
print ${(j:.:)tokens}</syntaxhighlight>


Or, using SH_SPLIT_WORD:
Or, using SH_SPLIT_WORD:


<lang zsh>str='Hello,How,Are,You,Today'
<syntaxhighlight lang="zsh">str='Hello,How,Are,You,Today'
IFS=, echo ${(j:.:)${=str}}</lang>
IFS=, echo ${(j:.:)${=str}}</syntaxhighlight>



{{omit from|PARI/GP|No real capacity for string manipulation}}
{{omit from|PARI/GP|No real capacity for string manipulation}}

Latest revision as of 14:45, 14 February 2024

Task
Tokenize a string
You are encouraged to solve this task according to the task description, using any language you may know.

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.

Display the words to the 'user', in the simplest manner possible, separated by a period.

To simplify, you may display a trailing period.


Other tasks related to string operations:
Metrics
Counting
Remove/replace
Anagrams/Derangements/shuffling
Find/Search/Determine
Formatting
Song lyrics/poems/Mad Libs/phrases
Tokenize
Sequences



11l

Translation of: Python
V text = ‘Hello,How,Are,You,Today’
V tokens = text.split(‘,’)
print(tokens.join(‘.’))
Output:
Hello.How.Are.You.Today

360 Assembly

*        Tokenize a string -       08/06/2018
TOKSTR   CSECT
         USING  TOKSTR,R13         base register
         B      72(R15)            skip savearea
         DC     17F'0'             savearea
         SAVE   (14,12)            save previous context
         ST     R13,4(R15)         link backward
         ST     R15,8(R13)         link forward
         LR     R13,R15            set addressability
         MVC    N,=A(1)            n=1
         LA     R7,1               i1=1
         LA     R6,1               i=1
       DO WHILE=(C,R6,LE,LENS)     do i=1 to length(s);
         LA     R4,S-1             @s-1
         AR     R4,R6              +i
         MVC    C,0(R4)            c=substr(s,i,1)
       IF CLI,C,EQ,C',' THEN       if c=',' then do
         BAL    R14,TOK              call tok
         LR     R2,R8                i2
         SR     R2,R7                i2-i1
         LA     R2,1(R2)             i2-i1+1
         L      R1,N                 n
         SLA    R1,1                 *2
         STH    R2,TALEN-2(R1)       talen(n)=i2-i1+1
         L      R2,N                 n
         LA     R2,1(R2)             n+1
         ST     R2,N                 n=n+1
         LA     R7,1(R6)             i1=i+1
       ENDIF    ,                    endif 
         LA     R6,1(R6)             i++
       ENDDO    ,                  enddo i
         BAL    R14,TOK            call tok
         LR     R2,R8              i2
         SR     R2,R7              i2-i1
         LA     R2,1(R2)           i2-i1+1
         L      R1,N               n
         SLA    R1,1               *2
         STH    R2,TALEN-2(R1)     talen(n)=i2-i1+1
         LA     R11,PG             pgi=@pg
         LA     R6,1               i=1
       DO WHILE=(C,R6,LE,N)        do i=1 to n
         LR     R1,R6                i
         SLA    R1,1                 *2
         LH     R10,TALEN-2(R1)      l=talen(i)
         LR     R1,R6                i
         SLA    R1,3                 *8
         LA     R4,TABLE-8(R1)       @table(i)
         LR     R2,R10               l
         BCTR   R2,0                 ~
         EX     R2,MVCX              output table(i) length(l)
         AR     R11,R10              pgi=pgi+l
       IF C,R6,NE,N THEN             if i^=n then 
         MVC    0(1,R11),=C'.'         output '.'
         LA     R11,1(R11)             pgi=pgi+1
       ENDIF    ,                    endif 
         LA     R6,1(R6)             i++
       ENDDO    ,                  enddo i
         XPRNT  PG,L'PG            print
         L      R13,4(0,R13)       restore previous savearea pointer
         RETURN (14,12),RC=0       restore registers from calling sav
TOK      LR     R5,R6              i                              <--
         BCTR   R5,0               i-1                              |
         LR     R8,R5              i2=i-1
         SR     R5,R7              i2-i1
         LA     R5,1(R5)           l=i2-i1+1  source length
         L      R1,N               n
         SLA    R1,3               *8
         LA     R2,TABLE-8(R1)     @table(n)
         LA     R4,S-1             @s-1
         AR     R4,R7              @s+i1-1
         LA     R3,8               target length
         MVCL   R2,R4              table(n)=substr(s,i1,i2-i1+1)    |
         BR     R14                End TOK subroutine             <--
MVCX     MVC    0(0,R11),0(R4)     output table(i)
S        DC     CL80'Hello,How,Are,You,Today'  <== input string ==
LENS     DC     F'23'              length(s)   <==
TABLE    DC     8CL8' '            table(8)
TALEN    DC     8H'0'              talen(8) 
C        DS     CL1                char
N        DS     F                  number of tokens
PG       DC     CL80' '            buffer
         YREGS
         END    TOKSTR
Output:
Hello.How.Are.You.Today

8080 Assembly

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	$
Output:
Hello. How. Are. You. Today.

8086 Assembly

	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
Output:
Hello. How. Are. You. Today.

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program strTokenize64.s   */

/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
 
.equ NBPOSTESECLAT,          20

/*******************************************/
/* Initialized data                        */
/*******************************************/
.data
szMessFinal:         .asciz "Words are : \n"
 
szString:            .asciz "Hello,How,Are,You,Today"
szMessError:         .asciz "Error tokenize !!\n"
szCarriageReturn:    .asciz "\n"
/*******************************************/
/* UnInitialized data                      */
/*******************************************/
.bss 
/*******************************************/
/*  code section                           */
/*******************************************/
.text
.global main 
main: 
    ldr x0,qAdrszString                           // string address 
    mov x1,','                                    // separator
    bl stTokenize
    cmp x0,-1                                     // error ?
    beq 99f
    mov x2,x0                                     // table address
    ldr x0,qAdrszMessFinal                        // display message
    bl affichageMess
    ldr x4,[x2]                                   // number of areas
    add x2,x2,8                                   // first area
    mov x3,0                                      // loop counter
    mov x0,x2
1:                                                // display loop 
    ldr x0,[x2,x3, lsl 3]                         // address area
    bl affichageMess
    ldr x0,qAdrszCarriageReturn                   // display carriage return
    bl affichageMess
    add x3,x3,1                                  // counter + 1
    cmp x3,x4                                     // end ?
    blt 1b                                        // no -> loop
 
    b 100f
99:                                               // display error message
    ldr x0,qAdrszMessError
    bl affichageMess
 
100:                                              // standard end of the program
    mov x0,0                                       // return code
    mov x8,EXIT                                   // request to exit program
    svc 0                                         // perform the system call
qAdrszString:             .quad szString
//qAdrszFinalString:        .quad szFinalString
qAdrszMessFinal:          .quad szMessFinal
qAdrszMessError:          .quad szMessError
qAdrszCarriageReturn:     .quad szCarriageReturn

/*******************************************************************/	   
/* Separate string by separator into an array                     */
/* areas are store on the heap Linux                               */
/*******************************************************************/	  
/* x0 contains string address */
/* x1 contains separator character (, or . or : )    */
/* x0 returns table address with first item = number areas */
/* and other items contains pointer of each string     */
stTokenize:
    stp x1,lr,[sp,-16]!           // save  registers
    mov x16,x0
    mov x9,x1                     // save separator
    mov x14,0          
1:                                // compute length string for place reservation on the heap
    ldrb w12,[x0,x14]
    cbz x12, 2f
    add x14,x14,1
    b 1b
2:
    ldr x12,qTailleTable
    add x15,x12,x14
    and x15,x15,0xFFFFFFFFFFFFFFF0
    add x15,x15,16                 // align word on the heap
                                  // place reservation on the heap 
    mov x0,0                      // heap address
    mov x8,BRK                    // call system linux 'brk'
    svc 0                         // call system
    cmp x0,-1                     // error call system
    beq 100f
    mov x14,x0                    // save address  heap begin = begin array
    add x0,x0,x15                 // reserve x15 byte on the heap
    mov x8,BRK                    // call system linux 'brk'
    svc 0
    cmp x0,-1
    beq 100f
                                  // string copy on the heap
    add x13,x14,x12               // behind the array 
    mov x0,x16
    mov x1,x13
3:                                // loop copy string
    ldrb w12,[x0],1               // read one byte and increment pointer one byte
    strb w12,[x1],1               // store one byte and increment pointer one byte
    cbnz x12,3b                   // end of string ? no -> loop 
 
    mov x0,#0
    str x0,[x14]
    str x13,[x14,8]
    mov x12,#1                     // areas counter
4:                                // loop load string character 
    ldrb w0,[x13]
    cbz x0,5f                     // end string 
    cmp x0,x9                     // separator ?
    cinc x13,x13,ne               // no -> next location 
    bne 4b                        // and loop
    strb wzr,[x13]                // store zero final of string
    add x13,x13,1                 // next character
    add x12,x12,1                 // areas counter + 1
    str x13,[x14,x12, lsl #3]     // store address area in the table at index x2
    b 4b                          // and loop
 
5:
    str x12,[x14]                 // store number areas
    mov x0,x14                    // returns array address
100:
    ldp x1,lr,[sp],16             // restaur  2 registers
    ret                           // return to address lr x30
qTailleTable:      .quad 8 * NBPOSTESECLAT

/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
Output:
Words are :
Hello
How
Are
You
Today

ACL2

(defun split-at (xs delim)
   (if (or (endp xs) (eql (first xs) delim))
       (mv nil (rest xs))
       (mv-let (before after)
               (split-at (rest xs) delim)
          (mv (cons (first xs) before) after))))

(defun split (xs delim)
   (if (endp xs)
       nil
       (mv-let (before after)
               (split-at xs delim)
          (cons before (split after delim)))))

(defun css->strs (css)
   (if (endp css)
       nil
       (cons (coerce (first css) 'string)
             (css->strs (rest css)))))

(defun split-str (str delim)
   (css->strs (split (coerce str 'list) delim)))

(defun print-with (strs delim)
   (if (endp strs)
       (cw "~%")
       (progn$ (cw (first strs))
               (cw (coerce (list delim) 'string))
               (print-with (rest strs) delim))))
Output:
> (print-with (split-str "Hello,How,Are,You,Today" #\,) #\.)
Hello.How.Are.You.Today.

Action!

The user must type in the monitor the following command after compilation and before running the program!

SET EndProg=*
Library: Action! Tool Kit
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
Output:

Screenshot from Atari 8-bit computer 

Input:
"Hello,How,Are,You,Today"

Split:
"Hello", "How", "Are", "You", "Today"

Join:
"Hello.How.Are.You.Today"

ActionScript

var hello:String = "Hello,How,Are,You,Today";
var tokens:Array = hello.split(",");
trace(tokens.join("."));

// Or as a one-liner
trace("Hello,How,Are,You,Today".split(",").join("."));

Ada

with Ada.Text_IO, Ada.Containers.Indefinite_Vectors, Ada.Strings.Fixed, Ada.Strings.Maps;
use Ada.Text_IO, Ada.Containers, Ada.Strings, Ada.Strings.Fixed, Ada.Strings.Maps;

procedure Tokenize is
   package String_Vectors is new Indefinite_Vectors (Positive, String);
   use String_Vectors;
   Input  : String   := "Hello,How,Are,You,Today";
   Start  : Positive := Input'First;
   Finish : Natural  := 0;
   Output : Vector   := Empty_Vector;
begin
   while Start <= Input'Last loop
      Find_Token (Input, To_Set (','), Start, Outside, Start, Finish);
      exit when Start > Finish;
      Output.Append (Input (Start .. Finish));
      Start := Finish + 1;
   end loop;
   for S of Output loop
      Put (S & ".");
   end loop;
end Tokenize;

ALGOL 68

main:(

  OP +:=  = (REF FLEX[]STRING in out, STRING item)VOID:(
    [LWB in out: UPB in out+1]STRING new;
    new[LWB in out: UPB in out]:=in out;
    new[UPB new]:=item;
    in out := new
  );

  PROC string split = (REF STRING beetles, STRING substr)[]STRING:(
    """ Split beetles where substr is found """;
    FLEX[1:0]STRING out;
    INT start := 1, pos;
    WHILE string in string(substr, pos, beetles[start:]) DO
      out +:= STRING(beetles[start:start+pos-2]);
      start +:= pos + UPB substr - 1
    OD;
    IF start > LWB beetles THEN
      out +:= STRING(beetles[start:])
    FI;
    out
  );

  PROC char split = (REF STRING beetles, STRING chars)[]STRING: (
    """ Split beetles where character is found in chars """;
    FLEX[1:0]STRING out;
    FILE beetlef;
    associate(beetlef, beetles); # associate a FILE handle with a STRING   #
    make term(beetlef, chars);   # make term: assign CSV string terminator # 

    PROC raise logical file end = (REF FILE f)BOOL: except logical file end;
    on logical file end(beetlef, raise logical file end);

    STRING solo;
    DO
      getf(beetlef, ($g$, solo));
      out+:=solo;
      getf(beetlef, ($x$)) # skip CHAR separator #
    OD;
    except logical file end:
      SKIP;
    out
  );

  STRING beetles := "John Lennon, Paul McCartney, George Harrison, Ringo Starr";

  printf(($g"."$, string split(beetles, ", "),$l$));
  printf(($g"."$, char   split(beetles, ", "),$l$))
)
Output:
 John Lennon.Paul McCartney.George Harrison.Ringo Starr.
 John.Lennon..Paul.McCartney..George.Harrison..Ringo.Starr.

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. 

#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
Output:
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

APL

     '.',⍨¨ ','(≠⊆⊢)'abc,123,X'   ⍝ [1] Do the split: ','(≠⊆⊢)'abc,123,X'; [2] append the periods: '.',⍨¨ 
 abc.  123.  X.                   ⍝ 3 strings (char vectors), each with a period at the end.

AppleScript

on run
  intercalate(".", splitOn(",", "Hello,How,Are,You,Today"))
end run
 
 
-- splitOn :: String -> String -> [String]
on splitOn(strDelim, strMain)
  set {dlm, my text item delimiters} to {my text item delimiters, strDelim}
  set lstParts to text items of strMain
  set my text item delimiters to dlm
  return lstParts
end splitOn
 
-- intercalate :: String -> [String] -> String
on intercalate(strText, lstText)
  set {dlm, my text item delimiters} to {my text item delimiters, strText}
  set strJoined to lstText as text
  set my text item delimiters to dlm
  return strJoined
end intercalate
Output:
Hello.How.Are.You.Today

Or, 

set my text item delimiters to ","
set tokens to the text items of "Hello,How,Are,You,Today"

set my text item delimiters to "."
log tokens as text
Output:
Hello.How.Are.You.Today

ARM Assembly

Works with: as version Raspberry Pi
/* ARM assembly Raspberry PI  */
/*  program strTokenize.s   */

/* Constantes    */
.equ STDOUT, 1                          @ Linux output console
.equ EXIT,   1                           @ Linux syscall
.equ WRITE,  4                           @ Linux syscall

.equ NBPOSTESECLAT,          20

/* Initialized data */
.data
szMessFinal:   .asciz "Words are : \n"

szString:            .asciz "Hello,How,Are,You,Today"
szMessError:         .asciz "Error tokenize !!\n"
szCarriageReturn:   .asciz "\n"

/* UnInitialized data */
.bss 

/*  code section */
.text
.global main 
main: 
    ldr r0,iAdrszString                           @ string address 
    mov r1,#','                                   @ separator
    bl stTokenize
    cmp r0,#-1                                    @ error ?
    beq 99f
    mov r2,r0                                     @ table address
    ldr r0,iAdrszMessFinal                        @ display message
    bl affichageMess
    ldr r4,[r2]                                   @ number of areas
    add r2,#4                                     @ first area
    mov r3,#0                                     @ loop counter
1:                                                @ display loop 
    ldr r0,[r2,r3, lsl #2]                        @ address area
    bl affichageMess
    ldr r0,iAdrszCarriageReturn                   @ display carriage return
    bl affichageMess
    add r3,#1                                     @ counter + 1
    cmp r3,r4                                     @ end ?
    blt 1b                                        @ no -> loop

    b 100f
99:                                               @ display error message
    ldr r0,iAdrszMessError
    bl affichageMess

100:                                              @ standard end of the program
    mov r0, #0                                    @ return code
    mov r7, #EXIT                                 @ request to exit program
    svc 0                                         @ perform the system call
iAdrszString:             .int szString
iAdrszFinalString:       .int szFinalString
iAdrszMessFinal:          .int szMessFinal
iAdrszMessError:          .int szMessError
iAdrszCarriageReturn:    .int szCarriageReturn
/******************************************************************/
/*     display text with size calculation                         */ 
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
    push {r0,r1,r2,r7,lr}                       @ save  registers 
    mov r2,#0                                   @ counter length */
1:                                              @ loop length calculation
    ldrb r1,[r0,r2]                             @ read octet start position + index 
    cmp r1,#0                                   @ if 0 its over
    addne r2,r2,#1                              @ else add 1 in the length
    bne 1b                                      @ and loop 
                                                @ so here r2 contains the length of the message 
    mov r1,r0                                   @ address message in r1 
    mov r0,#STDOUT                              @ code to write to the standard output Linux
    mov r7, #WRITE                              @ code call system "write" 
    svc #0                                      @ call systeme
    pop {r0,r1,r2,r7,lr}                        @ restaur des  2 registres
    bx lr                                       @ return
/*******************************************************************/	   
/* Separate string by separator into an array                     */
/* areas are store on the heap Linux                               */
/*******************************************************************/	  
/* r0 contains string address */
/* r1 contains separator character (, or . or : )    */
/* r0 returns table address with first item = number areas */
/* and other items contains pointer of each string     */
stTokenize:
    push {r1-r8,lr}                                 @ save des registres
    mov r6,r0
    mov r8,r1                                       @ save separator
    bl strLength                                    @ length string for place reservation on the heap
    mov r4,r0
    ldr r5,iTailleTable
    add r5,r0
    and r5,#0xFFFFFFFC
    add r5,#4                                       @ align word on the heap
                                                    @ place reservation on the heap 
    mov r0,#0                                       @ heap address
    mov r7, #0x2D                                   @ call system linux 'brk'
    svc #0                                          @ call system
    cmp r0,#-1                                      @ error call system
    beq 100f
    mov r3,r0                                       @ save address  heap begin
    add r0,r5                                       @ reserve r5 byte on the heap
    mov r7, #0x2D                                   @ call system linux 'brk'
    svc #0
    cmp r0,#-1
    beq 100f
                                                    @ string copy on the heap
    mov r0,r6
    mov r1,r3
1:                                                  @ loop copy string
    ldrb r2,[r0],#1                                 @ read one byte and increment pointer one byte
    strb r2,[r1],#1                                 @ store one byte and increment pointer one byte
    cmp r2,#0                                       @ end of string ?
    bne 1b                                          @ no -> loop 

    add r4,r3                                        @ r4 contains address table begin
    mov r0,#0
    str r0,[r4]
    str r3,[r4,#4]
    mov r2,#1                                       @ areas counter
2:                                                  @ loop load string character 
    ldrb r0,[r3]
    cmp r0,#0
    beq 3f                                          @ end string 
    cmp r0,r8                                       @ separator ?
    addne r3,#1                                     @ no -> next location 
    bne 2b                                          @ and loop
    mov r0,#0                                       @ store zero final of string
    strb r0,[r3]
    add r3,#1                                       @ next character
    add r2,#1                                       @ areas counter + 1
    str r3,[r4,r2, lsl #2]                          @ store address area in the table at index r2
    b 2b                                            @ and loop
 
3:
    str r2,[r4]                                     @ returns number areas
    mov r0,r4
100:
    pop {r1-r8,lr}
    bx lr
iTailleTable: .int 4 * NBPOSTESECLAT
/***************************************************/
/*   calcul size string                            */
/***************************************************/
/* r0 string address                 */
/* r0 returns size string            */
strLength:
    push {r1,r2,lr}
    mov r1,#0                                           @ init counter
1:
   ldrb r2,[r0,r1]                                      @ load byte of string index r1
   cmp r2,#0                                            @ end string ?
   addne r1,#1                                          @ no -> +1 counter
   bne 1b                                               @ and loop

100:
    mov r0,r1
    pop {r1,r2,lr}
    bx lr

Arturo

str: "Hello,How,Are,You,Today"

print join.with:"." split.by:"," str
Output:
Hello.How.Are.You.Today

Astro

let text = 'Hello,How,Are,You,Today'
let tokens = text.split(||,||)
print tokens.join(with: '.')

AutoHotkey

string := "Hello,How,Are,You,Today"
stringsplit, string, string, `,
loop, % string0
{
msgbox % string%A_Index%
}

AWK

BEGIN {
  s = "Hello,How,Are,You,Today"
  split(s, arr, ",")
  for(i=1; i < length(arr); i++) {
    printf arr[i] "."
  }
  print
}

A more idiomatic way for AWK is 

BEGIN { FS = "," }
{
  for(i=1; i <= NF; i++) printf $i ".";
  print ""
}

which "tokenize" each line of input and this is achieved by using "," as field separator

BASIC

Applesoft BASIC

100 T$ = "HELLO,HOW,ARE,YOU,TODAY"
110 GOSUB 200"TOKENIZE
120 FOR I = 1 TO N
130     PRINT A$(I) "." ;
140 NEXT
150 PRINT
160 END

200 IF N = 0 THEN DIM A$(256)
210 N = 1
220 A$(N) = "
230 FOR TI = 1 TO LEN(T$)
240     C$ = MID$(T$, TI, 1)
250     T = C$ = ","
260     IF T THEN C$ = "
270     N = N + T
280     IF T THEN A$(N) = C$
290     A$(N) = A$(N) + C$
300 NEXT TI
310 RETURN

BaCon

BaCon includes extensive support for delimited strings. 

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$, ",", ".")
Output:
prompt$ ./tokenize
Hello.How.Are.You.Today
Hello.How.Are.You.Today

BASIC256

instring$ = "Hello,How,Are,You,Today"

tokens$ = explode(instring$,",")
for i = 0 to tokens$[?]-1
	print tokens$[i]; ".";
next i
end


BBC BASIC

Works with: BBC BASIC for Windows
      INSTALL @lib$+"STRINGLIB"
      
      text$ = "Hello,How,Are,You,Today"
      n% = FN_split(text$, ",", array$())
      FOR i% = 0 TO n%-1
        PRINT array$(i%) "." ;
      NEXT
      PRINT

Chipmunk Basic

Solutions Applesoft BASIC and Commodore BASIC work without changes.

Commodore BASIC

Based on the AppleSoft BASIC version. 

10 REM TOKENIZE A STRING ... ROSETTACODE.ORG
20 T$ = "HELLO,HOW,ARE,YOU,TODAY"
30 GOSUB 200, TOKENIZE
40 FOR I = 1 TO N
50     PRINT A$(I) "." ;
60 NEXT
70 PRINT
80 END
200 IF N = 0 THEN DIM A$(256)
210 N = 1
220 A$(N) = ""
230 FOR L = 1 TO LEN(T$)
240     C$ = MID$(T$, L, 1)
250     IF C$<>"," THEN A$(N) = A$(N) + C$: GOTO 270
260     N = N + 1
270 NEXT L
280 RETURN

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

Liberty BASIC

'Note that Liberty Basic's array usage can reach element #10 before having to DIM the array
For i = 0 To 4
    array$(i) = Word$("Hello,How,Are,You,Today", (i + 1), ",")
    array$ = array$ + array$(i) + "."
Next i

Print Left$(array$, (Len(array$) - 1))

MSX Basic

The Commodore BASIC solution works without any changes.

PowerBASIC

PowerBASIC has a few keywords that make parsing strings trivial: PARSE, PARSE$, and PARSECOUNT. (PARSE$, not shown here, is for extracting tokens one at a time, while PARSE extracts all tokens at once into an array. PARSECOUNT returns the number of tokens found.) 

FUNCTION PBMAIN () AS LONG
    DIM parseMe AS STRING
    parseMe = "Hello,How,Are,You,Today"

    REDIM parsed(PARSECOUNT(parseMe) - 1) AS STRING
    PARSE parseMe, parsed()  'comma is default delimiter

    DIM L0 AS LONG, outP AS STRING
    outP = parsed(0)
    FOR L0 = 1 TO UBOUND(parsed)  'could reuse parsecount instead of ubound
        outP = outP & "." & parsed(L0)
    NEXT

    MSGBOX outP
END FUNCTION

PureBasic

As described 

NewList MyStrings.s()

For i=1 To 5
  AddElement(MyStrings())
  MyStrings()=StringField("Hello,How,Are,You,Today",i,",")
Next i

ForEach MyStrings()
  Print(MyStrings()+".")
Next

Still, easier would be 

Print(ReplaceString("Hello,How,Are,You,Today",",","."))

QBasic

DIM parseMe AS STRING
parseMe = "Hello,How,Are,You,Today"

DIM tmpLng1 AS INTEGER, tmpLng2 AS INTEGER, parsedCount AS INTEGER
tmpLng2 = 1
parsedCount = -1

'count number of tokens
DO
    tmpLng1 = INSTR(tmpLng2, parseMe, ",")
    IF tmpLng1 THEN
        parsedCount = parsedCount + 1
        tmpLng2 = tmpLng1 + 1
    ELSE
        IF tmpLng2 < (LEN(parseMe) + 1) THEN parsedCount = parsedCount + 1
        EXIT DO
    END IF
LOOP

IF parsedCount > -1 THEN
    REDIM parsed(parsedCount) AS STRING
    tmpLng2 = 1
    parsedCount = -1

    'parse
    DO
        tmpLng1 = INSTR(tmpLng2, parseMe, ",")
        IF tmpLng1 THEN
            parsedCount = parsedCount + 1
            parsed(parsedCount) = MID$(parseMe, tmpLng2, tmpLng1 - tmpLng2)
            tmpLng2 = tmpLng1 + 1
        ELSE
            IF tmpLng2 < (LEN(parseMe) + 1) THEN
                parsedCount = parsedCount + 1
                parsed(parsedCount) = MID$(parseMe, tmpLng2)
            END IF
            EXIT DO
        END IF
    LOOP

    PRINT parsed(0);
    FOR L0 = 1 TO parsedCount
        PRINT "."; parsed(L0);
    NEXT
END IF

Run BASIC

text$ = "Hello,How,Are,You,Today"
FOR i = 1 to 5
 textArray$(i) = word$(text$,i,",")
 print textArray$(i);" ";
NEXT

VBScript

One liner

WScript.Echo Join(Split("Hello,How,Are,You,Today", ","), ".")

In fact, the Visual Basic solution (below) could have done the same, as Join() is available.

Visual Basic

Translation of: PowerBASIC

Unlike PowerBASIC, there is no need to know beforehand how many tokens are in the string -- Split automagically builds the array for you. 

Sub Main()
    Dim parseMe As String, parsed As Variant
    parseMe = "Hello,How,Are,You,Today"

    parsed = Split(parseMe, ",")

    Dim L0 As Long, outP As String
    outP = parsed(0)
    For L0 = 1 To UBound(parsed)
        outP = outP & "." & parsed(L0)
    Next

    MsgBox outP
End Sub

Batch File

@echo off
setlocal enabledelayedexpansion
call :tokenize %1 res
echo %res%
goto :eof

:tokenize
set str=%~1
:loop
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

BQN

Uses a splitting idiom from bqncrate. 

Split ← (+`׬)⊸-∘= ⊔ ⊢

∾⟜'.'⊸∾´ ',' Split "Hello,How,Are,You,Today"
Output:
"Hello.How.Are.You.Today"

Bracmat

Solution that employs string pattern matching to spot the commas 

( "Hello,How,Are,You,Today":?String
& :?ReverseList
&   whl
  ' ( @(!String:?element "," ?String)
    & !element !ReverseList:?ReverseList
    )
& !String:?List
&   whl
  ' ( !ReverseList:%?element ?ReverseList
    & (!element.!List):?List
    )
& 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. 

(  get$("Hello,How,Are,You,Today",MEM):?CommaseparatedList
& :?ReverseList
&   whl
  ' ( !CommaseparatedList:(?element,?CommaseparatedList)
    & !element !ReverseList:?ReverseList
    )
& !CommaseparatedList:?List
&   whl
  ' ( !ReverseList:%?element ?ReverseList
    & (!element.!List):?List
    )
& out$!List
)

C

Works with: ANSI C
Library: POSIX

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<string.h>
#include<stdio.h>
#include<stdlib.h>

int main(void)
{
	char *a[5];
	const char *s="Hello,How,Are,You,Today";
	int n=0, nn;

	char *ds=strdup(s);

	a[n]=strtok(ds, ",");
	while(a[n] && n<4) a[++n]=strtok(NULL, ",");

	for(nn=0; nn<=n; ++nn) printf("%s.", a[nn]);
	putchar('\n');

	free(ds);

	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. 

#include<stdio.h>

typedef void (*callbackfunc)(const char *);

void doprint(const char *s) {
	printf("%s.", s);
}

void tokenize(char *s, char delim, callbackfunc cb) {
	char *olds = s;
	char olddelim = delim;
	while(olddelim && *s) {
		while(*s && (delim != *s)) s++;
		*s ^= olddelim = *s; // olddelim = *s; *s = 0;
		cb(olds);
		*s++ ^= olddelim; // *s = olddelim; s++;
		olds = s;
	}
}

int main(void)
{
        char array[] = "Hello,How,Are,You,Today";
	tokenize(array, ',', doprint);
	return 0;
}

C#

string str = "Hello,How,Are,You,Today"; 
// or Regex.Split ( "Hello,How,Are,You,Today", "," );
// (Regex is in System.Text.RegularExpressions namespace)
string[] strings = str.Split(',');
Console.WriteLine(String.Join(".", strings));

C++

Works with: C++98

std::getline() is typically used to tokenize strings on a single-character delimiter 

#include <string>
#include <sstream>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
int main()
{
    std::string s = "Hello,How,Are,You,Today";
    std::vector<std::string> v;
    std::istringstream buf(s);
    for(std::string token; getline(buf, token, ','); )
        v.push_back(token);
    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 <string>
#include <locale>
#include <sstream>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
struct comma_ws : std::ctype<char> {
    static const mask* make_table() {
    static std::vector<mask> v(classic_table(), classic_table() + table_size);
        v[','] |= space;  // comma will be classified as whitespace
        return &v[0];
    }
    comma_ws(std::size_t refs = 0) : ctype<char>(make_table(), false, refs) {}
};
int main()
{
    std::string s = "Hello,How,Are,You,Today";
    std::istringstream buf(s);
    buf.imbue(std::locale(buf.getloc(), new comma_ws));
    std::istream_iterator<std::string> beg(buf), end;
    std::vector<std::string> v(beg, end);
    copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."));
    std::cout << '\n';
}
Works with: C++98
Library: boost

The boost library has multiple options for easy tokenization. 

#include <string>
#include <vector>
#include <iterator>
#include <algorithm>
#include <iostream>
#include <boost/tokenizer.hpp>
int main()
{
    std::string s = "Hello,How,Are,You,Today";
    boost::tokenizer<> tok(s);
    std::vector<std::string> v(tok.begin(), tok.end());
    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. 

#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;
}

Ceylon

Works with: Ceylon 1.2
shared void tokenizeAString() {
	value input = "Hello,How,Are,You,Today";
	value tokens = input.split(','.equals);
	print(".".join(tokens));
}

CFEngine

bundle agent main
{
  reports:
    "${with}" with => join(".", splitstring("Hello,How,Are,You,Today", ",", 99));
}
Output:
cf-agent -KIf ./tokenize-a-string.cf
R: Hello.How.Are.You.Today

See https://docs.cfengine.com/docs/master/reference-functions.html for a complete list of available functions.

Clojure

Using native Clojure functions and Java Interop: 

(apply str (interpose "." (.split #"," "Hello,How,Are,You,Today")))

Using the clojure.string library: 

(clojure.string/join "." (clojure.string/split "Hello,How,Are,You,Today" #","))

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
Output:
Hello.
How.
Are.
You.
Today.

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. 

      identification division.
       program-id. tokenize.

       environment division.
       configuration section.
       repository.
           function all intrinsic.

       data division.
       working-storage section.
       01 period constant as ".".
       01 cmma   constant as ",".

       01 start-with.
          05 value "Hello,How,Are,You,Today".

       01 items.
          05 item pic x(6) occurs 5 times.

       procedure division.
       tokenize-main.
       unstring start-with delimited by cmma
           into item(1) item(2) item(3) item(4) item(5)

       display trim(item(1)) period trim(item(2)) period
               trim(item(3)) period trim(item(4)) period
               trim(item(5))

       goback.
       end program tokenize.
Output:
prompt$ cobc -xj tokenize.cob
Hello.How.Are.You.Today

CoffeeScript

arr = "Hello,How,Are,You,Today".split ","
console.log arr.join "."

ColdFusion

Classic tag based CFML

<cfoutput>
  <cfset wordListTag = "Hello,How,Are,You,Today">
  #Replace( wordListTag, ",", ".", "all" )#
</cfoutput>
Output:
"Hello.How.Are.You.Today"

Script Based CFML

<cfscript>
  wordList = "Hello,How,Are,You,Today";
  splitList = replace( wordList, ",", ".", "all" );
  writeOutput( splitList );
</cfscript>
Output:
"Hello.How.Are.You.Today"

Common Lisp

There are libraries out there that handle splitting (e.g., SPLIT-SEQUENCE, and the more-general 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. 

(defun comma-split (string)
  (loop for start = 0 then (1+ finish)
        for finish = (position #\, string :start start)
        collecting (subseq string start finish)
        until (null finish)))

(defun write-with-periods (strings)
  (format t "~{~A~^.~}" strings))

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;
Output:
Hello.
How.
Are.
You.
Today.

Crystal

puts "Hello,How,Are,You,Today".split(',').join('.')
Output:
Hello.How.Are.You.Today

D

void main() {
    import std.stdio, std.string;

    "Hello,How,Are,You,Today".split(',').join('.').writeln;
}
Output:
Hello.How.Are.You.Today

Delphi

Using String.split

Library: System.SysUtils
program Tokenize_a_string;

{$APPTYPE CONSOLE}

uses
  System.SysUtils;

var
  Words: TArray<string>;

begin
  Words := 'Hello,How,Are,You,Today'.Split([',']);
  Writeln(string.Join(#10, Words));

  Readln;
end.

Using TStringList

program TokenizeString;

{$APPTYPE CONSOLE}

uses
  Classes;

var
  tmp: TStringList;
  i: Integer;

begin

  // Instantiate TStringList class
  tmp := TStringList.Create;
  try
    { Use the TStringList's CommaText property to get/set
      all the strings in a single comma-delimited string }
    tmp.CommaText := 'Hello,How,Are,You,Today';

    { Now loop through the TStringList and display each
      token on the console }
    for i := 0 to Pred(tmp.Count) do
      Writeln(tmp[i]);

  finally
    tmp.Free;
  end;

  Readln;

end.

The result is: 

Hello
How
Are
You
Today

dt

"Hello,How,Are,You,Today" "," split "." join pl

Dyalect

var str = "Hello,How,Are,You,Today"
var strings = str.Split(',')
print(values: strings, separator: ".")
Output:
Hello.How.Are.You.Today

Déjà Vu

!print join "." split "Hello,How,Are,You,Today" ","
Output:
Hello.How.Are.You.Today

E

".".rjoin("Hello,How,Are,You,Today".split(","))

EasyLang

s$ = "Hello,How,Are,You,Today"
a$[] = strsplit s$ ","
for s$ in a$[]
   write s$ & "."
.

Elena

ELENA 6.x: 

import system'routines;
import extensions;
 
public program()
{
    auto string := "Hello,How,Are,You,Today";
 
    string.splitBy(",").forEach::(s)
    {
        console.print(s,".")
    }
}

Elixir

tokens = String.split("Hello,How,Are,You,Today", ",")
IO.puts Enum.join(tokens, ".")

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("."))
Output:
Hello.How.Are.You.Today
Hello.How.Are.You.Today

Erlang

-module(tok).
-export([start/0]).

start() ->
   Lst = string:tokens("Hello,How,Are,You,Today",","),
   io:fwrite("~s~n", [string:join(Lst,".")]),
   ok.

Euphoria

function split(sequence s, integer c)
    sequence out
    integer first, delim
    out = {}
    first = 1
    while first<=length(s) do
        delim = find_from(c,s,first)
        if delim = 0 then
            delim = length(s)+1
        end if
        out = append(out,s[first..delim-1])
        first = delim + 1
    end while
    return out
end function

sequence s
s = split("Hello,How,Are,You,Today", ',')

for i = 1 to length(s) do
    puts(1, s[i] & ',')
end for

F#

System.String.Join(".", "Hello,How,Are,You,Today".Split(','))

Factor

"Hello,How,Are,You,Today" "," split "." join print

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

a = []
a = strSplit("Hello,How,Are,You,Today", ",")
index = 0
start = 0
b = ""
for index in [ start : len(a)-1 : 1 ]
	b = b + a[index] + "."
end

> b
Output:
Hello.How.Are.You.
[Finished in 0.2s]

Fantom

A string can be split on a given character, returning a list of the intervening strings. 

class Main
{
  public static Void main ()
  {
    str := "Hello,How,Are,You,Today"
    words := str.split(',')
    words.each |Str word|
    {
      echo ("${word}. ")
    }
  }
}

Fennel

Translation of: Lua
(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 ",") ".")))

Forth

There is no standard string split routine, but it is easily written. The results are saved temporarily to the dictionary. 

: split ( str len separator len -- tokens count )
  here >r 2swap
  begin
    2dup 2,             \ save this token ( addr len )
    2over search        \ find next separator
  while
    dup negate  here 2 cells -  +!  \ adjust last token length
    2over nip /string               \ start next search past separator
  repeat
  2drop 2drop
  r>  here over -   ( tokens length )
  dup negate allot           \ reclaim dictionary
  2 cells / ;                \ turn byte length into token count

: .tokens ( tokens count -- )
  1 ?do dup 2@ type ." ." cell+ cell+ loop 2@ type ;

s" Hello,How,Are,You,Today" s" ," split .tokens  \ Hello.How.Are.You.Today

Fortran

Works with: Fortran version 90 and later
PROGRAM Example

  CHARACTER(23) :: str = "Hello,How,Are,You,Today"
  CHARACTER(5) :: word(5)
  INTEGER :: pos1 = 1, pos2, n = 0, i

  DO
    pos2 = INDEX(str(pos1:), ",")
    IF (pos2 == 0) THEN
       n = n + 1
       word(n) = str(pos1:)
       EXIT
    END IF
    n = n + 1
    word(n) = str(pos1:pos1+pos2-2)
    pos1 = pos2+pos1
 END DO

 DO i = 1, n
   WRITE(*,"(2A)", ADVANCE="NO") TRIM(word(i)), "."
 END DO
 
END PROGRAM Example

Frink

println[join[".", split[",", "Hello,How,Are,You,Today"]]]

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
Output:
Hello.How.Are.You.Today

Gambas

Click this link to run this code 

Public Sub Main()
Dim sString As String[] = Split("Hello,How,Are,You,Today")

Print sString.Join(".")

End

Output: 

Hello.How.Are.You.Today

GAP

SplitString("Hello,How,Are,You,Today", ",");
# [ "Hello", "How", "Are", "You", "Today" ]

JoinStringsWithSeparator(last, ".");
# "Hello.How.Are.You.Today"

Genie

[indent=4]

init
    str:string = "Hello,How,Are,You,Today"
    words:array of string[] = str.split(",")
    joined:string = string.joinv(".", words)
    print joined
Output:
prompt$ valac tokenize.gs
prompt$ ./tokenize
Hello.How.Are.You.Today

Go

package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "Hello,How,Are,You,Today"
    fmt.Println(strings.Join(strings.Split(s, ","), "."))
}

Groovy

println 'Hello,How,Are,You,Today'.split(',').join('.')

Haskell

Using Data.Text 

{-# OPTIONS_GHC -XOverloadedStrings #-}
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

Alternate Solution

The necessary operations are unfortunately not in the standard library (yet), but simple to write: 

splitBy :: (a -> Bool) -> [a] -> [[a]]
splitBy _ [] = []
splitBy f list = first : splitBy f (dropWhile f rest) where
  (first, rest) = break f list

splitRegex :: Regex -> String -> [String]

joinWith :: [a] -> [[a]] -> [a]
joinWith d xs = concat $ List.intersperse d xs
-- "concat $ intersperse" can be replaced with "intercalate" from the Data.List in GHC 6.8 and later

putStrLn $ joinWith "." $ splitBy (== ',') $ "Hello,How,Are,You,Today"

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

*Main> mapM_ putStrLn $ takeWhile (not.null) $ unfoldr (Just . second(drop 1). break (==',')) "Hello,How,Are,You,Today"
Hello
How
Are
You
Today
  • You need to import the modules Data.List and Control.Arrow

As special cases, splitting / joining by white space and by newlines are provided by the Prelude functions words / unwords and lines / unlines, respectively.

HicEst

CHARACTER string="Hello,How,Are,You,Today", list

nWords = INDEX(string, ',', 256) + 1
maxWordLength = LEN(string) - 2*nWords
ALLOCATE(list, nWords*maxWordLength)

DO i = 1, nWords
  EDIT(Text=string, SePaRators=',', item=i, WordEnd, CoPyto=CHAR(i, maxWordLength, list))
ENDDO

DO i = 1, nWords
  WRITE(APPend) TRIM(CHAR(i, maxWordLength, list)), '.'
ENDDO

Icon and Unicon

procedure main()
   A := []
   "Hello,How,Are,You,Today" ? {
      while put(A, 1(tab(upto(',')),=","))
      put(A,tab(0))
      }
   every writes(!A,".")
   write()
end
Output:
 ->ss
 Hello.How.Are.You.Today.
 ->

A Unicon-specific solution is: 

import util

procedure main()
   A := stringToList("Hello,How,Are,You,Today", ',')
   every writes(!A,".")
   write()
end

One wonders what the expected output should be with the input string ",,,,".

Io

"Hello,How,Are,You,Today" split(",") join(".") println

J

   s=: 'Hello,How,Are,You,Today'
   ] t=: <;._1 ',',s
+-----+---+---+---+-----+
|Hello|How|Are|You|Today|
+-----+---+---+---+-----+
   ; t,&.>'.'
Hello.How.Are.You.Today.

  '.' (I.','=s)}s  NB. two steps combined
Hello.How.Are.You.Today

Alternatively using the system library/script strings 

   require 'strings'
   ',' splitstring s
+-----+---+---+---+-----+
|Hello|How|Are|You|Today|
+-----+---+---+---+-----+

   '.' joinstring ',' splitstring s
Hello.How.Are.You.Today

splitstring and joinstring also work with longer "delimiters": 

   '"'([ ,~ ,) '","' joinstring ',' splitstring s
"Hello","How","Are","You","Today"

But, of course, this could be solved with simple string replacement: 

   rplc&',.' s
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.

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: 

   fn;._2 string,','

Here fn is applied to each ',' delimited substring and the results are assembled into an array.

Or, factoring out the names: 

   fn ((;._2)(@(,&','))) string

Java

Works with: Java version 1.0+

There are multiple ways to tokenize a String in Java.

The first is by splitting the String into an array of Strings. The separator is actually a regular expression so you could do very powerful things with this, but make sure to escape any characters with special meaning in regex.

Works with: Java version 1.8+
String toTokenize = "Hello,How,Are,You,Today";
System.out.println(String.join(".", toTokenize.split(",")));
Works with: Java version 1.4+
String toTokenize = "Hello,How,Are,You,Today";

String words[] = toTokenize.split(",");//splits on one comma, multiple commas yield multiple splits
               //toTokenize.split(",+") if you want to ignore empty fields
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 version 1.0+
String toTokenize = "Hello,How,Are,You,Today";

StringTokenizer tokenizer = new StringTokenizer(toTokenize, ",");
while(tokenizer.hasMoreTokens()) {
    System.out.print(tokenizer.nextToken() + ".");
}

JavaScript

console.log(
    "Hello,How,Are,You,Today"
        .split(",")
        .join(".")
);

A more advanced program to tokenise strings:

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 !== "");
		}
	};
})();

Output:

Tokeniser.parseString("Hello,How,Are,You,Today");

// -> ['Hello', ',', 'How', ',', 'Are', ',', 'You', ',', 'Today']

jq

split(",") | join(".")

Example:

$ jq -r 'split(",") | join(".")'
"Hello,How,Are,You,Today" 
Hello.How.Are.You.Today

Jsish

Being in the ECMAScript family, Jsi is blessed with many easy to use character, string and array manipulation routines. 

puts('Hello,How,Are,You,Today'.split(',').join('.'))
Output:
Hello.How.Are.You.Today

Julia

s = "Hello,How,Are,You,Today"
a = split(s, ",")
t = join(a, ".")

println("The string \"", s, "\"")
println("Splits into ", a)
println("Reconstitutes to \"", t, "\"")
Output:
The string "Hello,How,Are,You,Today"
Splits into SubString{ASCIIString}["Hello","How","Are","You","Today"]
Reconstitutes to "Hello.How.Are.You.Today"

K

words: "," \: "Hello,How,Are,You,Today"
"." /: words
Output:
"Hello.How.Are.You.Today"
Works with: ngn/k
","\"Hello,How,Are,You,Today"
("Hello"
 "How"
 "Are"
 "You"
 "Today")

Klingphix

( "Hello,How,Are,You,Today" "," ) split len [ get print "." print ] for

nl "End " input
Output:
Hello.How.Are.You.Today.
End

Kotlin

Works with: Kotlin version 1.0b4
fun main(args: Array<String>) {
    val input = "Hello,How,Are,You,Today"
    println(input.split(',').joinToString("."))
}
Output:
Hello.How.Are.You.Today

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}"
Output:
Hello.How.Are.You.Today

LabVIEW

To tokenize the string, we use the Search/Split String function to split the string by its first comma. Add the beginning (up to, but not including the comma) to the end of the array, remove the first comma from the rest of the string, and pass it back through the shift register to the loop's next iteration. This is repeated until the string is empty. Printing is a simple matter of concatenation.
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Lambdatalk

{S.replace , by . in Hello,How,Are,You,Today}.
-> Hello.How.Are.You.Today.

Lang

$str = Hello,How,Are,You,Today
fn.println(fn.join(\., fn.split($str, \,)))

Lang5

'Hello,How,Are,You,Today ', split '. join .

LDPL

DATA:
explode/words is text vector
explode/index is number
explode/string is text
explode/length is number
explode/stringlength is number
explode/current-token is text
explode/char is text
explode/separator is text
i is number
    
PROCEDURE:
# Ask for a sentence
display "Enter a sentence: "
accept explode/string

# Declare explode Subprocedure
# Splits a text into a text vector by a certain delimiter
# Input parameters:
# - explode/string: the string to explode (destroyed)
# - explode/separator: the character used to separate the string (preserved)
# Output parameters:
# - explode/words: vector of splitted words
# - explode/length: length of explode/words
sub-procedure explode
    join explode/string and explode/separator in explode/string
    store length of explode/string in explode/stringlength
    store 0 in explode/index
    store 0 in explode/length
    store "" in explode/current-token
    while explode/index is less than explode/stringlength do
        get character at explode/index from explode/string in explode/char
        if explode/char is equal to explode/separator then
            store explode/current-token in explode/words:explode/length
            add explode/length and 1 in explode/length
            store "" in explode/current-token
        else
            join explode/current-token and explode/char in explode/current-token
        end if
        add explode/index and 1 in explode/index
    repeat
    subtract 1 from explode/length in explode/length
end sub-procedure

# Separate the entered string
store " " in explode/separator
call sub-procedure explode
while i is less than or equal to explode/length do
    display explode/words:i crlf
    add 1 and i in i
repeat

LFE

> (set split (string:tokens "Hello,How,Are,You,Today" ","))
("Hello" "How" "Are" "You" "Today")
> (string:join split ".")
"Hello.How.Are.You.Today"

Lingo

input = "Hello,How,Are,You,Today"
_player.itemDelimiter = ","
output = ""
repeat with i = 1 to input.item.count
  put input.item[i]&"." after output
end repeat
delete the last char of output
put output
-- "Hello.How.Are.You.Today"

Works with: UCB Logo
to split :str :sep
  output parse map [ifelse ? = :sep ["| |] [?]] :str
end

This form is more robust, doing the right thing if there are embedded spaces. 

to split :str :by [:acc []] [:w "||]
  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
? show split "Hello,How,Are,You,Today ",
[Hello How Are You Today]

Logtalk

Using Logtalk built-in support for Definite Clause Grammars (DCGs) and representing the strings as atoms for readbility: 

:- object(spliting).

    :- public(convert/2).
    :- mode(convert(+atom, -atom), one).

    convert(StringIn, StringOut) :-
        atom_chars(StringIn, CharactersIn),
        phrase(split(',', Tokens), CharactersIn),
        phrase(split('.', Tokens), CharactersOut),
        atom_chars(StringOut, CharactersOut).

    split(Separator, [t([Character| Characters])| Tokens]) -->
        [Character], {Character \== Separator}, split(Separator, [t(Characters)| Tokens]).
    split(Separator, [t([])| Tokens]) -->
        [Separator], split(Separator, Tokens).
    split(_, [t([])]) -->
        [].
    % the look-ahead in the next rule prevents adding a spurious separator at the end
    split(_, []), [Character] -->
        [Character].

:- end_object.
Output:
| ?- spliting::convert('Hello,How,Are,You,Today', Converted).
Converted = 'Hello.How.Are.You.Today'
yes

Lua

Split function callously stolen from the lua-users wiki 

function string:split (sep)
    local sep, fields = sep or ":", {}
    local pattern = string.format("([^%s]+)", sep)
    self:gsub(pattern, function(c) fields[#fields+1] = c end)
    return fields
end

local str = "Hello,How,Are,You,Today"
print(table.concat(str:split(","), "."))
Output:
Hello.How.Are.You.Today

M2000 Interpreter

Module CheckIt {
	Function Tokenize$(s){
		\\ letter$ pop a string from stack of values
		\\ shift 2 swap top two values on stack of values
		fold1=lambda m=1 ->{
			shift 2 :if m=1 then m=0:drop: push letter$ else push letter$+"."+letter$
		}
		=s#fold$(fold1)
	}
	Print Tokenize$(piece$("Hello,How,Are,You,Today",",")) ="Hello.How.Are.You.Today"   ' true
}
Checkit

M4

define(`s',`Hello,How,Are,You,Today')
define(`set',`define(`$1[$2]',`$3')')
define(`get',`defn($1[$2])')
define(`n',0)
define(`fill',
   `set(a,n,$1)`'define(`n',incr(n))`'ifelse(eval($#>1),1,`fill(shift($@))')')
fill(s)
define(`j',0)
define(`show',
   `ifelse(eval(j<n),1,`get(a,j).`'define(`j',incr(j))`'show')')
show
Output:
 Hello.How.Are.You.Today.

Maple

StringTools:-Join(StringTools:-Split("Hello,How,Are,You,Today", ","),".");
Output:
"Hello.How.Are.You.Today"

Mathematica/Wolfram Language

StringJoin@StringSplit["Hello,How,Are,You,Today", "," -> "."]

MATLAB / Octave

s=strsplit('Hello,How,Are,You,Today',',')     
fprintf(1,'%s.',s{:})
Output:
Hello.How.Are.You.Today.

Maxima

l: split("Hello,How,Are,You,Today", ",")$
printf(true, "~{~a~^.~}~%", l)$

A slightly different way 

split("Hello,How,Are,You,Today",",")$
simplode(%,".");
Output:
"Hello.How.Are.You.Today"

MAXScript

output = ""
for word in (filterString "Hello,How,Are,You,Today" ",") do
(
    output += (word + ".")
)
format "%\n" output

Mercury

:- module string_tokenize.
:- interface.

:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.
:- import_module list, string.

main(!IO) :-
    Tokens = string.split_at_char((','), "Hello,How,Are,You,Today"),   
    io.write_list(Tokens, ".", io.write_string, !IO),
    io.nl(!IO).

min

Works with: min version 0.19.3
"Hello,How,Are,You,Today" "," split "." join print

MiniScript

tokens = "Hello,How,Are,You,Today".split(",")
print tokens.join(".")

MMIX

sep	IS	','
EOS	IS	0
NL	IS	10

// main registers
p	IS	$255
tp	GREG
c	GREG
t	GREG

	LOC	Data_Segment
	GREG	@
Text	BYTE	"Hello,How,Are,You,Today",EOS
token	BYTE	0
eot	IS	@+255

	LOC	#100	% main () {
Main	LDA	p,Text		%
	LDA	tp,token	% initialize pointers
2H	LDBU	c,p		% DO  get char
	BZ	c,5F		%  break if char == EOS
	CMP	t,c,sep		%  if char != sep then
	PBNZ	t,3F		%     store char
	SET	t,NL		%  terminate token with NL,EOS
	STBU	t,tp
	SET	t,EOS
	INCL	tp,1
	STBU	t,tp
	JMP	4F		%  continue

3H	STBU	c,tp		%  store char
4H	INCL	tp,1		%  update pointers
	INCL	p,1
	JMP	2B		% LOOP

5H	SET	t,NL		% terminate last token and buffer
	STBU	t,tp
	SET	t,EOS
	INCL	tp,1
	STBU	t,tp
%  next part is not really necessary
%  program runs only once
%	INCL	tp,1		% terminate buffer
%	STBU	t,tp

	LDA	tp,token	% reset token pointer
				% REPEAT
2H	ADD	p,tp,0		%    start of token
	TRAP	0,Fputs,StdOut	%    output token
	ADD	tp,tp,p
	INCL	tp,1		%    step to next token
	LDBU	t,tp
	PBNZ	t,2B		% UNTIL EOB(uffer)
	TRAP	0,Halt,0
Output:
 ~/MIX/MMIX/Progs> mmix tokenizing
 Hello
 How
 Are
 You
 Today

Modula-3

MODULE Tokenize EXPORTS Main;

IMPORT IO, TextConv;

TYPE Texts = REF ARRAY OF TEXT;

VAR tokens: Texts;
    string := "Hello,How,Are,You,Today";
    sep := SET OF CHAR {','};

BEGIN
  tokens := NEW(Texts, TextConv.ExplodedSize(string, sep));
  TextConv.Explode(string, tokens^, sep);
  FOR i := FIRST(tokens^) TO LAST(tokens^) DO
    IO.Put(tokens[i] & ".");
  END;
  IO.Put("\n");
END Tokenize.

MUMPS

TOKENS
 NEW I,J,INP
 SET INP="Hello,how,are,you,today"
 NEW I FOR I=1:1:$LENGTH(INP,",") SET INP(I)=$PIECE(INP,",",I)
 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: 

USER>D TOKENS^ROSETTA
Hello.how.are.you.today

Nanoquery

for word in "Hello,How,Are,You,Today".split(",")
        print word + "."
end
Output:
Hello.How.Are.You.Today.

Nemerle

using System;
using System.Console;
using Nemerle.Utility.NString;

module Tokenize
{
    Main() : void
    {
        def cswords = "Hello,How,Are,You,Today";
        WriteLine(Concat(".", $[s | s in cswords.Split(',')]));
        // Split() produces an array while Concat() consumes a list
        // a quick in place list comprehension takes care of that
    }
}

NetRexx

/*NetRexx program *****************************************************
* 20.08.2012 Walter Pachl derived from REXX Version 3
**********************************************************************/
  sss='Hello,How,Are,You,Today'
  Say 'input string='sss
  Say ''
  Say 'Words in the string:'
  ss =sss.translate(' ',',')
  Loop i=1 To ss.words()
    Say ss.word(i)'.'
    End
  Say 'End-of-list.'

Output as in REXX version

NewLISP

(print (join (parse "Hello,How,Are,You,Today" ",") "."))

Nial

Example for Q'Nial7, using set "nodecor and set "diagram switches for better display of the array structure:

Define Array with input string: 

     s := 'Hello,How,Are,You,Today'
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|H|e|l|l|o|,|H|o|w|,|A|r|e|,|Y|o|u|,|T|o|d|a|y|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Split string at the commas: 

     t := s eachall = `, cut s
+-----------+-------+-------+-------+-----------+
|+-+-+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+-+-+|
||H|e|l|l|o|||H|o|w|||A|r|e|||Y|o|u|||T|o|d|a|y||
|+-+-+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+|+-+-+-+-+-+|
+-----------+-------+-------+-------+-----------+

Join string with . and remove last . 

     u := front content (cart t `.)
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|H|e|l|l|o|.|H|o|w|.|A|r|e|.|Y|o|u|.|T|o|d|a|y|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Less cluttered display, using set "sketch;set "nodecor display switches. 

     s:='Hello,How,Are,You,Today'
Hello,How,Are,You,Today
     t:= s eachall = `, cut s
+-----+---+---+---+-----+
|Hello|How|Are|You|Today|
+-----+---+---+---+-----+
     u:=front content (cart t `.)

Hello.How.Are.You.Today

Or as a one-liner: 

front content (cart (s eachall = `, cut s) `.)

Nim

import strutils

let text = "Hello,How,Are,You,Today"
let tokens = text.split(',')
echo tokens.join(".")
Output:
Hello.How.Are.You.Today

Objeck

class Parse {
  function : Main(args : String[]) ~ Nil {
    tokens := "Hello,How,Are,You,Today"->Split(",");
    each(i : tokens) {
      tokens[i]->PrintLine();
    };
  }
}

Objective-C

Works with: GNUstep
Works with: Cocoa
NSString *text = @"Hello,How,Are,You,Today";
NSArray *tokens = [text componentsSeparatedByString:@","];
NSString *result = [tokens componentsJoinedByString:@"."];
NSLog(result);

OCaml

To split on a single-character separator: 

let words = String.split_on_char ',' "Hello,How,Are,You,Today" in
String.concat "." words

The function split_on_char has been introduced in OCaml 4.04. In previous versions, it could be implemented by: 

let split_on_char sep s =
  let r = ref [] in
  let j = ref (String.length s) in
  for i = String.length s - 1 downto 0 do
    if s.[i] = sep then begin
      r := String.sub s (i + 1) (!j - i - 1) :: !r;
      j := i
    end
  done;
  String.sub s 0 !j :: !r

Oforth

"Hello,How,Are,You,Today" wordsWith(',') println
Output:
[Hello, How, Are, You, Today]

ooRexx

text='Hello,How,Are,You,Today'
do while text \= ''
   parse var text word1 ',' text
   call charout 'STDOUT:',word1'.'
end
Output:
Hello.How.Are.You.Today.

OpenEdge/Progress

FUNCTION tokenizeString RETURNS CHAR (
   i_c AS CHAR
):

   DEF VAR ii        AS INT.
   DEF VAR carray    AS CHAR EXTENT.
   DEF VAR cresult   AS CHAR.

   EXTENT( carray ) = NUM-ENTRIES( i_c ).

   DO ii = 1 TO NUM-ENTRIES( i_c ):
      carray[ ii ] = ENTRY( ii, i_c ).
   END.

   DO ii = 1 TO EXTENT( carray ).
      cresult = cresult + "." + carray[ ii ].
   END.
   RETURN SUBSTRING( cresult, 2 ).

END FUNCTION. /* tokenizeString */

MESSAGE 
   tokenizeString( "Hello,How,Are,You,Today" ) 
VIEW-AS ALERT-BOX.
Output:
 ---------------------------
 Message
 ---------------------------
 Hello.How.Are.You.Today
 ---------------------------
 OK   
 ---------------------------

Oz

for T in {String.tokens "Hello,How,Are,You,Today" &,} do
   {System.printInfo T#"."}
end

PARI/GP

Version #1.

Simple version, like the most custom ones here (for this task). This version has 1 character delimiter, which is not allowed in the beginning and at the end of string, in addition, double, triple, etc., delimiters are not allowed too.

Works with: PARI/GP version 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
\\ tokenize() 3/5/16 aev
tokenize(str,d)={
my(str=Str(str,d),vt=Vecsmall(str),d1=sasc(d),Lr=List(),sn=#str,v1,p1=1);
for(i=p1,sn, v1=vt[i]; if(v1==d1, listput(Lr,ssubstr(str,p1,i-p1)); p1=i+1)); 
return(Lr);
}

{
\\ TEST 
print(" *** Testing tokenize from Version #1:");
print("1.", tokenize("Hello,How,Are,You,Today",","));
\\ BOTH 2 & 3 are NOT OK!!
print("2.",tokenize("Hello,How,Are,You,Today,",","));
print("3.",tokenize(",Hello,,How,Are,You,Today",","));
}
Output:
 *** Testing tokenize from Version #1:
1.List(["Hello", "How", "Are", "You", "Today"])
2.List(["Hello", "How", "Are", "You", "Today", ","])
3.List([",Hello,,How,Are,You,Today,", "Hello", ",How,Are,You,Today,", "How", "Ar
e", "You", "Today"])

Version #2.

Advanced version. Delimiter is allowed in any place. In addition, multiple delimiters are allowed too. This is really useful for considering omitted data. This version can be used for positional parameters processing, or for processing data from tables with string rows.

Works with: PARI/GP version 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
\\ stok() 3/5/16 aev
stok(str,d)={
my(d1c=ssubstr(d,1,1),str=Str(str,d1c),vt=Vecsmall(str),d1=sasc(d1c),
   Lr=List(),sn=#str,v1,p1=1,vo=32);
if(sn==1, return(List(""))); if(vt[sn-1]==d1,sn--);
for(i=1,sn, v1=vt[i];
    if(v1!=d1, vo=v1; next);
    if(vo==d1||i==1, listput(Lr,""); p1=i+1; vo=v1; next);
    if(i-p1>0, listput(Lr,ssubstr(str,p1,i-p1)); p1=i+1);
    vo=v1;
   ); 
return(Lr);
}

{
\\ TEST 
print(" *** Testing stok from Version #2:");
\\ pp - positional parameter(s)
print("1. 5 pp: ", stok("Hello,How,Are,You,Today",","));
print("2. 5 pp: ", stok("Hello,How,Are,You,Today,",","));
print("3. 9 pp: ", stok(",,Hello,,,How,Are,You,Today",","));
print("4. 6 pp: ", stok(",,,,,,",","));
print("5. 1 pp: ", stok(",",","));
print("6. 1 pp: ", stok("Hello-o-o??",","));
print("7. 0 pp: ", stok("",","));
}
Output:
 *** Testing stok from Version #2:
1. 5 pp: List(["Hello", "How", "Are", "You", "Today"])
2. 5 pp: List(["Hello", "How", "Are", "You", "Today"])
3. 9 pp: List(["", "", "Hello", "", "", "How", "Are", "You", "Today"])
4. 6 pp: List(["", "", "", "", "", ""])
5. 1 pp: List([""])
6. 1 pp: List(["Hello-o-o??"])
7. 0 pp: List([""])

Pascal

Works with: Free_Pascal
program TokenizeString;

{$mode objfpc}{$H+}

uses
  SysUtils, Classes;
const
  TestString = 'Hello,How,Are,You,Today';
var
  Tokens: TStringList;
  I: Integer;
begin
  // Uses FCL facilities, "harder" algorithm not implemented
  Tokens := TStringList.Create;
  try
    Tokens.Delimiter := ',';
    Tokens.DelimitedText := TestString;
    Tokens.Delimiter := '.'; // For example
    // To standard Output
    WriteLn(Format('Tokenize from: "%s"', [TestString]));
    WriteLn(Format('to:            "%s"',[Tokens.DelimitedText]));
  finally
    Tokens.Free;
  end;
end.

The result is: 

Tokenize from: "Hello,How,Are,You,Today"
to:            "Hello.How.Are.You.Today"

Perl

print join('.', split /,/, 'Hello,How,Are,You,Today'), "\n";

CLI one-liner form: 

echo "Hello,How,Are,You,Today" | perl -aplF/,/ -e '$" = "."; $_ = "@F";'

which is a compact way of telling Perl to do 

BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined($_ = <ARGV>)) {
    chomp $_;
    our(@F) = split(/,/, $_, 0);
    $" = '.';
    $_ = "@F";
}
continue {
    die "-p destination: $!\n" unless print $_;
}

Phix

?join(split("Hello,How,Are,You,Today",","),".")
Output:
"Hello.How.Are.You.Today"

Phixmonti

/# "Hello,How,Are,You,Today" "," "." subst print #/
"Hello,How,Are,You,Today" "," " " subst split len for get print "." print endfor

PHP

Works with: PHP version 5.x
<?php
$str = 'Hello,How,Are,You,Today';
echo implode('.', explode(',', $str));
?>

Picat

Using the built-in functions split/2 and join/2. 

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().
Output:
[Hello,How,Are,You,Today]
Hello.How.Are.You.Today
Hello.How.Are.You.Today

PicoLisp

(mapcar pack
   (split (chop "Hello,How,Are,You,Today") ",") )

Pike

("Hello,How,Are,You,Today" / ",") * ".";

PL/I

tok: Proc Options(main);
declare s character (100) initial ('Hello,How,Are,You,Today');
declare n fixed binary (31);

n = tally(s, ',')+1;

begin;
   declare table(n) character (50) varying;
   declare c character (1);
   declare (i, k) fixed binary (31);

   table = ''; k = 1;
   do i = 1 to length(s);
      c = substr(s, i, 1);
      if c = ',' then k = k + 1;
      else table(k) = table(k) || c;
   end;

   /* display the table */
   table = table || '.';
   put skip list (string(table));
end;
end;
Output:
Hello.How.Are.You.Today

PL/M

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;
Output:
HELLO. HOW. ARE. YOU. TODAY.

Plain English

To run:
Start up.
Split "Hello,How,Are,You,Today" into some string things given the comma byte.
Join the string things with the period byte giving a string.
Destroy the string things.
Write the string on the console.
Wait for the escape key.
Shut down.

To join some string things with a byte giving a string:
Get a string thing from the string things.
Loop.
If the string thing is nil, exit.
Append the string thing's string to the string.
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.
Output:
Hello.How.Are.You.Today

Pop11

The natural solution in Pop11 uses lists.

There are built in libraries for tokenising strings, illustrated below, along with code that the user could create for the task.

First show the use of sysparse_string to break up a string and make a list of strings. 

;;; Make a list of strings from a string using space as separator
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 

lvars list;
sysparse_string('one 1 two 2 three 3 four 4', true) -> list;
;;; print the list of strings and numbers
list =>
** [one 1 two 2 three 3 four 4]
;;; check that first item is a string and second an integer
isstring(list(1))=>
** <true>
isinteger(list(2))=>
** <true>

Now show some uses of the built in procedure sys_parse_string, which allows more options: 

;;; Make pop-11 print strings with quotes
true -> pop_pr_quotes;
;;;
;;; Create a string of tokens using comma as token separator
lvars str='Hello,How,Are,You,Today';
;;;
;;; Make a list of strings by applying sys_parse_string
;;; to str, using the character `,` as separator (the default
;;; separator, if none is provided, is the space character).
lvars strings;
[% sys_parse_string(str, `,`) %] -> strings;
;;;
;;; 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. 

{% sys_parse_string(str, `,`) %} -> 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: 

lvars numbers;
{% 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: 

;;; Declare and initialize variables
lvars str='Hello,How,Are,You,Today';
;;; Iterate over string
lvars ls = [], i, j = 1;
for i from 1 to length(str) do
    ;;; If comma
    if str(i) = `,` then
       ;;; Prepend word (substring) to list
       cons(substring(j, i - j, str), ls) -> ls;
       i + 1 -> j;
    endif;
endfor;
;;; Prepend final word (if needed)
if j <= length(str) then
    cons(substring(j, length(str) - j + 1, str), ls) -> ls;
endif;
;;; Reverse the list
rev(ls) -> ls;

Since the task requires to use array we convert list to array 

;;; Put list elements and lenght on the stack
destlist(ls);
;;; Build a vector from them
lvars ar = consvector();
;;; Display in a loop, putting trailing period
for i from 1 to length(ar) do
   printf(ar(i), '%s.');
endfor;
printf('\n');

We could use list directly for printing: 

for i in ls do
    printf(i, '%s.');
endfor;

so the conversion to vector is purely to satisfy task formulation.

PowerShell

Works with: PowerShell version 1
$words = "Hello,How,Are,You,Today".Split(',')
[string]::Join('.', $words)
Works with: PowerShell version 2
$words = "Hello,How,Are,You,Today" -split ','
$words -join '.'
Works with: PowerShell version 2

The StringSplitOptions enumeration weeds out the return of empty elements. 

"Hello,How,Are,You,Today", ",,Hello,,Goodbye,," | ForEach-Object {($_.Split(',',[StringSplitOptions]::RemoveEmptyEntries)) -join "."}
Output:
Hello.How.Are.You.Today
Hello.Goodbye

Prolog

Works with: SWI Prolog
splitup(Sep,[token(B)|BL]) --> splitup(Sep,B,BL).
splitup(Sep,[A|AL],B)      --> [A], {\+ [A] = Sep }, splitup(Sep,AL,B).
splitup(Sep,[],[B|BL])     --> Sep, splitup(Sep,B,BL).
splitup(_Sep,[],[])        --> [].
start :-
    phrase(splitup(",",Tokens),"Hello,How,Are,You,Today"),
    phrase(splitup(".",Tokens),Backtogether),
    string_to_list(ABack,Backtogether),
    writeln(ABack).
Output:
 ?- start.
 Hello.How.Are.You.Today
Works with: SWI Prolog 7

Using the SWI Prolog string data type and accompanying predicates, 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

Python

Works with: Python version 2.5
Works with: Python version 3.0
text = "Hello,How,Are,You,Today"
tokens = text.split(',')
print ('.'.join(tokens))

Or if interpretation of the task description means you don't need to keep an intermediate array: 

print ('.'.join('Hello,How,Are,You,Today'.split(',')))

Q

words: "," vs "Hello,How,Are,You,Today"
"." sv words
Output:
"Hello.How.Are.You.Today"

QB64

CBTJD: 2020/03/12 

a$ = "Hello,How,Are,You,Today" '               | Initialize original string.
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.
NEXT '                                         | End of loop.
DIM t$(nc) '                                   | Dim t$ array with total number of commas (nc). Array base is 0.
FOR nb = 1 TO LEN(a$) '                        | Start loop to find each word.
  c$ = MID$(a$, nb, 1) '                       | Look at each character in the string.
  IF c$ = "," THEN '                           | If the character is a comma, increase the t$ array for the next word.
    t = t + 1 '                                | t = token word count. Starts at 0 because array base is 0.
  ELSE '                                       | Or...
    t$(t) = t$(t) + c$ '                       | Add each character to the current token (t$) word.
  END IF '                                     | End of decision tree.
NEXT '                                         | End of loop.
FOR nd = 0 TO t '                              | Start loop to create final desired output.
  tf$ = tf$ + t$(nd) + "." '                   | Add each token word from t$ followed by a period to the final tf$.
NEXT '                                         | End of loop.
PRINT LEFT$(tf$, LEN(tf$) - 1) '               | Print all but the last period of tf$.
END '                                          | Program end.

Alternative method using word$ function:

CBTJD: 2020/03/12 

a$ = "Hello,How,Are,You,Today" '                        | Initialize original string.
DIM t$(LEN(a$) / 2) '                                   | Create an overestimated sized array.
FOR nd = 1 TO LEN(a$) '                                 | Start loop to find each comma.
  IF MID$(a$, nd, 1) = "," THEN '                       | If a comma is found...
    tc = tc + 1 '                                       | Increment tc for each found comma.
    t$(tc) = word$(a$, tc, ",") '                       | Assign tc word to t$(tc) array.
  END IF '                                              | End decision tree.
NEXT '                                                  | End loop.
t$(tc + 1) = word$(a$, tc + 1, ",") '                   | Assign last word to next array position.
ft$ = t$(1) '                                           | Start final return string ft$ with first array value.
FOR ne = 2 TO tc + 1 '                                  | Start loop to add periods and array values.
  ft$ = ft$ + "." + t$(ne) '                            | Concatenate a period with subsequent array values.
NEXT '                                                  | End loop.
PRINT ft$ '                                             | Print final return string ft$.

FUNCTION word$ (inSTG$, inDEC, inPRM$) '                | word$ function accepts original string, word number, and separator.
  inSTG$ = inSTG$ + inPRM$ '                            | Add a separator to the end of the original string.
  FOR na = 1 TO LEN(inSTG$) '                           | Start loop to count total number of separators.
    IF MID$(inSTG$, na, 1) = inPRM$ THEN nc = nc + 1 '  | If separator found, increment nc.
  NEXT '                                                | End loop.
  IF inDEC > nc THEN word$ = "": GOTO DONE '            | If requested word number (inDEC) is greater than total words (nc), bail.
  FOR nd = 1 TO inDEC '                                 | Start loop to find requested numbered word.
    last = st '                                         | Remember the position of the last separator.
    st = INSTR(last + 1, inSTG$, inPRM$) '              | Find the next separator.
  NEXT '                                                | End loop.
  word$ = MID$(inSTG$, last + 1, st - last - 1) '       | Return requested word.
  DONE: '                                               | Label for bail destination of word count error check.
END FUNCTION '                                          | End of function.

Quackery

  [ [] [] rot
    witheach 
    [ dup char , = iff
        [ drop nested join [] ]
      else join ]
    nested join ]                is tokenise ( $ --> [ )
 
  [ witheach [ echo$ say "." ] ] is display  ( [ -->   )
 
  $ "Hello,How,Are,You,Today" tokenise display
Output:
Hello.How.Are.You.Today.

R

text <- "Hello,How,Are,You,Today"
junk <- strsplit(text, split=",")
print(paste(unlist(junk), collapse="."))

or the one liner 

paste(unlist(strsplit(text, split=",")), collapse=".")

Racket

#lang racket
(string-join (string-split "Hello,How,Are,You,Today" ",") ".")
;; -> "Hello.How.Are.You.Today"

Raku

(formerly Perl 6)

Works with: Rakudo version #22 "Thousand Oaks"
'Hello,How,Are,You,Today'.split(',').join('.').say;

Or with function calls: 

say join '.', split ',', 'Hello,How,Are,You,Today';

Raven

'Hello,How,Are,You,Today' ',' split '.' join print

REBOL

print ["Original:"  original: "Hello,How,Are,You,Today"]
tokens: parse original ","
dotted: ""  repeat i tokens [append dotted rejoin [i "."]]
print ["Dotted:  "  dotted]
Output:
 Original: Hello,How,Are,You,Today
 Dotted:   Hello.How.Are.You.Today.

Red

str: "Hello,How,Are,You,Today"
>> tokens: split str ","
>> probe tokens
["Hello" "How" "Are" "You" "Today"]

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

Retro

{{
  : char     (  -$  )   " " ;
  : tokenize ( $-$$ )
    @char ^strings'splitAtChar withLength 1- over + 0 swap ! tempString ;
  : action   ( $-   )
    keepString ^buffer'add ;
---reveal---
  : split    ( $cb- )
    ^buffer'set !char
    char ^strings'append
    [ 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: 

create strings 100 allot
"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: 

strings [ @ "%s." puts ] ^types'STRING each@

REXX

version 1

This REXX version doesn't append a period to the last word in the list. 

/*REXX program separates a string of comma─delimited words, and echoes them ──► terminal*/
original = 'Hello,How,Are,You,Today'             /*some words separated by commas (,).  */
say  'The input string:'  original               /*display original string ──► terminal.*/
new= original                                    /*make a copy of the string.           */
                 do #=1  until  new==''          /*keep processing until  NEW  is empty.*/
                 parse var  new   @.#  ','  new  /*parse words delineated by a comma (,)*/
                 end   /*#*/                     /* [↑]  the new array is named   @.    */
say                                              /* NEW  is destructively parsed.   [↑] */
say center(' Words in the string ', 40, "═")     /*display a nice header for the list.  */
                 do j=1  for #                   /*display all the words (one per line),*/
                 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.*/
output   when using the internal default input:
The input string: Hello,How,Are,You,Today

═════════ Words in the string ══════════
Hello.
How.
Are.
You.
Today
═════════════ End─of─list ══════════════

version 2

This REXX version won't work if any of the words have an embedded blank (or possible a tab character) in them, as in:

Hello,Betty Sue,How,Are,You,Today 

/*REXX program to separate a string of comma-delimited words and echo */
sss='Hello,How,Are,You,Today'
say 'input string='sss
say ''
say 'Words in the string:'
ss =translate(sss,' ',',')
dot='.'
Do i=1 To words(ss)
  If i=words(ss) Then dot=''
  say word(ss,i)dot
  End
say 'End-of-list.'

output is similar to REXX version 1.

Ring

see substr("Hello,How,Are,You,Today", ",", ".")

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 version 4.2.8
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
≫ 'TOKNZ' STO

TOKNZ ( "word,word" → "word.word" ) 
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" TOKNZ

Output: 

 1: "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 ≫ 'TOKNZ' STO

Ruby

puts "Hello,How,Are,You,Today".split(',').join('.')

Rust

fn main() {
    let s = "Hello,How,Are,You,Today";
    let tokens: Vec<&str> = s.split(",").collect();
    println!("{}", tokens.join("."));
}

S-lang

variable a = strchop("Hello,How,Are,You,Today", ',', 0);
print(strjoin(a, "."));
Output:
"Hello.How.Are.You.Today"

Scala

println("Hello,How,Are,You,Today" split "," mkString ".")

Scheme

Works with: Guile
(use-modules (ice-9 regex))
(define s "Hello,How,Are,You,Today")
(define words (map match:substring (list-matches "[^,]+" s)))

(do ((n 0 (+ n 1))) ((= n (length words)))
        (display (list-ref words n))
        (if (< n (- (length words) 1))
                (display ".")))

(with SRFI 13) 

(define s "Hello,How,Are,You,Today")
(define words (string-tokenize s (char-set-complement (char-set #\,))))
(define t (string-join words "."))
Works with: Gauche Scheme
(print
  (string-join
    (string-split "Hello,How,Are,You,Today" #\,)
    "."))
Output:
Hello.How.Are.You.Today

Seed7

var array string: tokens is 0 times "";

tokens := split("Hello,How,Are,You,Today", ",");

Self

| s = 'Hello,How,Are,You,Today' |
((s splitOn: ',') joinUsing: '.') printLine.

Sidef

'Hello,How,Are,You,Today'.split(',').join('.').say;

Simula

BEGIN

    CLASS TEXTARRAY(N); INTEGER N;
    BEGIN
        TEXT ARRAY ARR(1:N);
    END TEXTARRAY;

    REF(TEXTARRAY) PROCEDURE SPLIT(T,DELIM); TEXT T; CHARACTER DELIM;
    BEGIN
        INTEGER N, I, LPOS;
        REF(TEXTARRAY) A;

        N := 1;
        T.SETPOS(1);
        WHILE T.MORE DO
            IF T.GETCHAR = DELIM THEN
                N := N+1;
        A :- NEW TEXTARRAY(N);

        I := 0;
        LPOS := 1;
        T.SETPOS(LPOS);
        WHILE T.MORE DO
            IF T.GETCHAR = DELIM THEN
            BEGIN
                I := I+1;
                A.ARR(I) :- T.SUB(LPOS,T.POS-LPOS-1);
                LPOS := T.POS;
            END;
        I := I+1;
        A.ARR(I) :- T.SUB(LPOS,T.LENGTH-LPOS+1);
        SPLIT :- A;
    END SPLIT;

    BEGIN
        TEXT S;
        REF(TEXTARRAY) TA;
        INTEGER I;

        S :- "HELLO,HOW,ARE,YOU,TODAY";
        TA :- SPLIT(S,',');
        FOR I := 1 STEP 1 UNTIL TA.N DO
        BEGIN
            OUTTEXT(TA.ARR(I));
            OUTCHAR('.');
        END;
        OUTIMAGE;
    END;

END.
Output:
HELLO.HOW.ARE.YOU.TODAY.

Slate

('Hello,How,Are,You,Today' splitWith: $,) join &separator: '.'.

Slope

(display
  (list->string
    (string->list
      "Hello,How,Are,You,Today"
      ",")
    "."))
Output:
Hello.How.Are.You.Today

Smalltalk

|array |
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: 

('Hello,How,Are,You,Today' subStrings: $,) join: '.'

The solution displaying a trailing period would be: 

|array |
array := 'Hello,How,Are,You,Today' subStrings: $,.
array inject: '' into: [:concatenation :string | concatenation, string, '.' ]

SNOBOL4

For this task, it's convenient to define Perl-style split( ) and join( ) functions. 

        define('split(chs,str)i,j,t,w2') :(split_end)
split   t = table()
sp1     str pos(0) (break(chs) | rem) $ t<i = i + 1>
+           span(chs) (break(chs) | '') . w2  = w2 :s(sp1)
*       t<i> = differ(str,'') str ;* Uncomment for CSnobol
        split = array(i)
sp2     split<j = j + 1> = t<j> :s(sp2)f(return)
split_end

        define('join(ch,a)i,') :(join_end)
join    join = join a<i = i + 1>
        join = join ?a<i + 1> ch :s(join)f(return)
join_end

*       # Test and display
        output = join('.',split(',','Hello,How,Are,You,Today'))
end
Output:
 Hello.How.Are.You.Today

Standard ML

val splitter = String.tokens (fn c => c = #",");
val main = (String.concatWith ".") o splitter;

Test: 

- main "Hello,How,Are,You,Today"
val it = "Hello.How.Are.You.Today" : string

Swift

Works with: Swift version 3.x
let text = "Hello,How,Are,You,Today"
let tokens = text.components(separatedBy: ",") // for single or multi-character separator
print(tokens)
let result = tokens.joined(separator: ".")
print(result)
Works with: Swift version 2.x
let text = "Hello,How,Are,You,Today"
let tokens = text.characters.split(",").map{String($0)} // for single-character separator
print(tokens)
let result = tokens.joinWithSeparator(".")
print(result)
Works with: Swift version 1.x
let text = "Hello,How,Are,You,Today"
let tokens = split(text, { $0 == "," }) // for single-character separator
println(tokens)
let result = ".".join(tokens)
println(result)

For multi-character separators:

import Foundation

let text = "Hello,How,Are,You,Today"
let tokens = text.componentsSeparatedByString(",")
print(tokens)

Tcl

Generating a list form a string by splitting on a comma: 

split $string ","

Joining the elements of a list by a period: 

join $list "."

Thus the whole thing would look like this: 

puts [join [split "Hello,How,Are,You,Today" ","] "."]

If you'd like to retain the list in a variable with the name "words", it would only be marginally more complex: 

puts [join [set words [split "Hello,How,Are,You,Today" ","]] "."]

(In general, the regexp command is also used in Tcl for tokenization of strings, but this example does not need that level of complexity.)

tr

tr knows nothing about arrays, so this solution only changes each comma to a period. 

echo 'Hello,How,Are,You,Today' | tr ',' '.'

Transd

#lang transd

MainModule: {
_start: (lambda locals: s "Hello,How,Are,You,Today"
    (textout (join (split s ",") "."))
)
}
Output:
Hello.How.Are.You.Today

TUSCRIPT

$$ MODE TUSCRIPT
SET string="Hello,How,Are,You,Today"
SET string=SPLIT (string,":,:")
SET string=JOIN  (string,".")

TXR

Collecting tokens which consist of non-empty sequences of non-commas. 

@(next :list "Hello,How,Are,You,Today")
@(coll)@{token /[^,]+/}@(end)
@(output)
@(rep)@token.@(last)@token@(end)
@(end)

Different approach. Collect tokens, each of which is a piece of text which either terminates before a comma, or else extends to the end of the line. 

@(next :list "Hello,How,Are,You,Today")
@(coll)@(maybe)@token,@(or)@token@(end)@(end)
@(output)
@(rep)@token.@(last)@token@(end)
@(end)

Using TXR Lisp: 

txr -p '(cat-str (split-str "Hello,How,Are,You,Today" ",") ".")'
Hello.How.Are.You.Today

UNIX Shell

Works with: Bourne Shell
string='Hello,How,Are,You,Today'

(IFS=,
 printf '%s.' $string
 echo)
Works with: Bourne Again SHell
Works with: Public Domain Korn SHell version 5.2.14
#! /bin/bash
stripchar-l ()
#removes the specified character from the left side of the string
#USAGE: stripchar "stuff" "s" --> tuff 
{ 
    string="$1";
    string=${string#"$2"};
    
  echo "$string"
}

join ()
#join a string of characters on a specified delimiter
#USAGE: join "1;2;3;4" ";" "," --> 1,2,3,4
{ 
    local result="";
    local list="$1";
    OLDIFS="$IFS";
    local IFS=${2-" "}; 
    local output_field_seperator=${3-" "};
    
    for element in $list;
    do
        result="$result$output_field_seperator$element";
    done;
    
    result="`stripchar-l "$result" "$output_field_seperator"`";
    echo "$result";
    IFS="$OLDIFS"
}

split () 
{ 
#split a string of characters on a specified delimiter
#USAGE: split "1;2;3;4" ";" --> 1 2 3 4	
    local list="$1";
    local input_field_seperator=${2-" "}; 
    local output_field_seperator=" ";
    
  #defined in terms of join
  join "$list" "$input_field_seperator" "$output_field_seperator"
}

strtokenize () 
{
#splits up a string of characters into tokens,
#based on a user supplied delimiter
#USAGE:strtokenize "1;2;3;4" ";" ":" --> 1:2:3:4
    local list="$1";
	local input_delimiter=${2-" "}; 
	local output_delimiter=${3-" "};
	local contains_a_space=" "; #added to highlight the use
                                    #of " " as an argument to join	
  
  #splits it input then joins it with a user supplied delimiter
  join "$( split "$list" "$input_delimiter" )" \
    "$contains_a_space" "$output_delimiter"; 
}

Example 

 strtokenize "Hello,How,Are,You,Today" "," "." 
            Hello.How.Are.You.Today
Works with: Almquist Shell
Works with: bash
Works with: pdksh
Works with: ksh93
Works with: zsh
string1="Hello,How,Are,You,Today"
elements_quantity=$(echo $string1|tr "," "\n"|wc -l)

present_element=1
while [ $present_element -le $elements_quantity ];do
echo $string1|cut -d "," -f $present_element|tr -d "\n"
if [ $present_element -lt $elements_quantity ];then echo -n ".";fi
present_element=$(expr $present_element + 1)
done
echo

# or to cheat
echo "Hello,How,Are,You,Today"|tr "," "."

UnixPipes

Works with: Bourne Shell
token() {
   (IFS=, read -r A B; echo "$A".; test -n "$B" && (echo "$B" | token))
}

echo "Hello,How,Are,You" | token

Ursa

decl string text
set text "Hello,How,Are,You,Today"
decl string<> tokens
set tokens (split text ",")
for (decl int i) (< i (size tokens)) (inc i)
        out tokens<i> "." console
end for
out endl console

Ursala

A list of strings is made by separating at the commas using the library function, sep. A single string is then made by joining the list of strings with periods using the library function, mat. Each of these is a second order function parameterized by the delimiter. Character literals are preceded by a backquote. 

#import std

token_list = sep`, 'Hello,How,Are,You,Today'

#cast %s

main = mat`. token_list
Output:
 'Hello.How.Are.You.Today'

Vala

void main() { 
  string s = "Hello,How,Are,You,Today";
  print(@"$(string.joinv(".", s.split(",")))");
}
Output:
Hello.How.Are.You.Today

VBA

Sub Main()
Dim temp() As String
   temp = Tokenize("Hello,How,Are,You,Today", ",")
   Display temp, Space(5)
End Sub

Private Function Tokenize(strS As String, sep As String) As String()
   Tokenize = Split(strS, sep)
End Function

Private Sub Display(arr() As String, sep As String)
   Debug.Print Join(arr, sep)
End Sub
Output:
Hello     How     Are     You     Today

VBScript

s = "Hello,How,Are,You,Today"
WScript.StdOut.Write Join(Split(s,","),".")
Output:
Hello.How.Are.You.Today

Vedit macro language

Vedit does not use the concepts of array or list. Normally, the text is processed as text in an edit buffer.

However, this example shows how to split the text into multiple text registers (10, 11, 12 etc.). The contents of each text register is then displayed to user, separated by a period. 

Buf_Switch(Buf_Free)
Ins_Text("Hello,How,Are,You,Today")

// Split the text into text registers 10, 11, ...
BOF
#1 = 9
Repeat(ALL) {
    #1++
    #2 = Cur_Pos
    Search(",", ADVANCE+ERRBREAK)
    Reg_Copy_Block(#1, #2, Cur_Pos-1)
}
Reg_Copy_Block(#1, #2, EOB_Pos)

// Display the list
for (#3 = 10; #3 <= #1; #3++) {
    Reg_Type(#3) Message(".") 
}

Buf_Quit(OK)

V (Vlang)

// 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('.'))
}
Output:
prompt$ v run rosetta/tokenize-a-string.v
Hello.How.Are.You.Today

WinBatch

text  = 'Hello,How,Are,You,Today'
result = ''
BoxOpen('WinBatch Tokenizing Example', '')
for ix = 1 to itemcount(text,',')
    result = result : itemextract(ix, text, ',') : '.'
    BoxText(result)
next
display(10, 'End of Program', 'Dialog and program will close momentarily.')
BoxShut()
Output:
Hello.How.Are.You.Today.

Wortel

@join "." @split "," "Hello,How,Are,You,Today"

Returns 

"Hello.How.Are.You.Today"

Wren

var s = "Hello,How,Are,You,Today"
var t = s.split(",").join(".") + "."
System.print(t)
Output:
Hello.How.Are.You.Today.

XPath 2.0

string-join(tokenize("Hello,How,Are,You,Today", ","), ".")
Output:
Hello.How.Are.You.Today

XPL0

string 0;
include c:\cxpl\codes;
int  I, J, K, Char;
char String, Array(5,6);        \5 words and 5 maximum chars + terminating 0

[String:= "Hello,How,Are,You,Today";
I:= 0;  K:= 0;
repeat  J:= 0;
        loop    [Char:= String(I);
                I:= I+1;
                if Char=^, or Char=0 then quit;
                Array(K,J):= Char;
                J:= J+1;
                ];
        Array(K,J):= 0;         \terminate word
        K:= K+1;                \next word in array
until   K>=5;
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 than a byte from the character array.

Output (done in reverse order to emphasize the tokens are indeed separate): 

Today.You.Are.How.Hello.

Yabasic

dim s$(1)

n = token("Hello. How are you today?", s$(), ".? ")

for i = 1 to n
	print s$(i);
	if i < n print ".";
next
print

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});
  }
}

zkl

"Hello,How,Are,You,Today".split(",").concat(".").println();
Hello.How.Are.You.Today

Zoea

program: tokenize_a_string
  input: "Hello,How,Are,You,Today"
  output: "Hello.How.Are.You.Today"

Zoea Visual

Tokenize a string

Zsh

str='Hello,How,Are,You,Today'
tokens=(${(s:,:)str})
print ${(j:.:)tokens}

Or, using SH_SPLIT_WORD: 

str='Hello,How,Are,You,Today'
IFS=, echo ${(j:.:)${=str}}
Retrieved from "https://rosettacode.org/wiki/Tokenize_a_string?oldid=348278"