Split and join strings

[codeguy]

I use my recursive StringReplace().
It skips things inside quotes or whatever literal marking delimiters you choose. It may not be as fast, namely due to the required string splitting, but it does  the job correctly. Nice work though.

[Pete]

I put in three split subs, a diminishing string and a progressive instr() technique, one with exit on length, and one with exit on instr() = 0.

I kept luke's in for comparison. What I like about luke's method is it handles null strings without additional conditions. Nice job, there.  I would have to modify mine at the for/next  printing loop, so it printed one less array, the last one always being null, to get rid of the null condition in my join1 function. 

Oh, I also differ from some in that I don't like using the zero bound in an array, so mine is set up to start words at array element number one, not zero; and yes, I know I could have used OPTION BASE 1.

Code: QB64: [Select]

1. WIDTH 80, 42
2. _SCREENMOVE 0, 0
3.  
4. REDIM words$(0)
5.  
6. original$ = "   The rain   in Spain  "
7.  
8. PRINT "Original string: "; original$
9. PRINT
10.  
11. '------------------------------luke's method.
12.  
13. split1 original$, " ", words$()
14.  
15. PRINT "Words with luke's method:"
16. PRINT
17. FOR i = LBOUND(words$) TO UBOUND(words$)
18.     PRINT words$(i)
19. NEXT i
20. PRINT
21. PRINT "Joined with commas: "; join0$(words$(), ","): PRINT "------------------------------------------------"
22.  
23. '------------------------------Pete's dimishing string method.
24. original$ = "   The rain   in Spain  "
25.  
26. split2 original$, " ", words$()
27.  
28. PRINT "Words with Pete's dimishing string method:"
29. PRINT
30. FOR i = 1 TO UBOUND(words$)
31.     PRINT words$(i)
32. NEXT i
33. PRINT
34. PRINT "Joined with commas: "; join1$(words$(), ","): PRINT "------------------------------------------------"
35.  
36. '------------------------------Pete's progressive instr() method A.
37. original$ = "   The rain   in Spain  "
38.  
39. split3 original$, " ", words$()
40.  
41. PRINT "Words with Pete's progressive instr() method A:"
42. PRINT
43. FOR i = 1 TO UBOUND(words$)
44.     PRINT words$(i)
45. NEXT i
46. PRINT
47. PRINT "Joined with commas: "; join1$(words$(), ","): PRINT "------------------------------------------------"
48.  
49. '------------------------------Pete's progressive instr() method B.
50. original$ = "   The rain   in Spain  "
51.  
52. split4 original$, " ", words$()
53.  
54. PRINT "Words with Pete's progressive instr() method B:"
55. PRINT
56. FOR i = 1 TO UBOUND(words$)
57.     PRINT words$(i)
58. NEXT i
59. PRINT
60. PRINT "Joined with commas: "; join1$(words$(), ","): PRINT "------------------------------------------------"
61.  
62. SUB split1 (in$, delimiter$, result$())
63. REDIM result$(-1)
64. start = 1
65. DO
66.     WHILE MID$(in$, start, 1) = delimiter$
67.         start = start + 1
68.         IF start > LEN(in$) THEN EXIT SUB
69.     WEND
70.     finish = INSTR(start, in$, delimiter$)
71.     IF finish = 0 THEN finish = LEN(in$) + 1
72.     REDIM _PRESERVE result$(0 TO UBOUND(result$) + 1)
73.     result$(UBOUND(result$)) = MID$(in$, start, finish - start)
74.     start = finish + 1
75. LOOP WHILE start <= LEN(in$)
76. END SUB
77.  
78. SUB split2 (in$, delimiter$, result$())
79. DIM ii AS _INTEGER64
80. REDIM result$(LEN(in$) \ 2 + 1)
81. in$ = in$ + delimiter$
82. DO
83.     ii = ii + 1
84.     DO UNTIL LEFT$(in$, 1) <> delimiter$
85.         in$ = MID$(in$, 2)
86.     LOOP
87.     result$(ii) = MID$(in$, 1, INSTR(in$, delimiter$) - 1)
88.     in$ = LTRIM$(MID$(in$, LEN(result$(ii)) + 1))
89. LOOP UNTIL in$ = ""
90. REDIM _PRESERVE result$(ii)
91. END SUB
92.  
93. SUB split3 (in$, delimiter$, result$())
94. DIM ii AS _INTEGER64, seed AS _INTEGER64, slen AS _INTEGER64
95. REDIM result$(LEN(in$) \ 2 + 1)
96. in$ = in$ + delimiter$
97. slen = LEN(in$)
98. DO
99.     ii = ii + 1
100.     DO
101.         seed = seed + 1
102.     LOOP UNTIL MID$(in$, seed, 1) <> delimiter$
103.     IF seed >= slen THEN EXIT DO
104.     result$(ii) = MID$(in$, seed, INSTR(seed, in$, delimiter$) - seed)
105.     seed = seed + LEN(result$(ii))
106. LOOP
107. REDIM _PRESERVE result$(ii - 1)
108. END SUB
109.  
110. SUB split4 (in$, delimiter$, result$())
111. DIM ii AS _INTEGER64, seed AS _INTEGER64
112. REDIM result$(LEN(in$) \ 2 + 1)
113. in$ = in$ + delimiter$
114. DO
115.     ii = ii + 1
116.     DO
117.         seed = seed + 1
118.     LOOP UNTIL MID$(in$, seed, 1) <> delimiter$
119.     IF INSTR(seed, in$, delimiter$) = 0 THEN EXIT DO
120.     result$(ii) = MID$(in$, seed, INSTR(seed, in$, delimiter$) - seed)
121.     seed = seed + LEN(result$(ii))
122. LOOP
123. REDIM _PRESERVE result$(ii - 1)
124. END SUB
125.  
126. FUNCTION join0$ (in$(), delimiter$)
127. result$ = in$(LBOUND(in$))
128. FOR i = LBOUND(in$) + 1 TO UBOUND(in$)
129.     result$ = result$ + delimiter$ + in$(i)
130. NEXT i
131. join0$ = result$
132. END FUNCTION
133.  
134. FUNCTION join1$ (in$(), delimiter$)
135. DIM ii AS _INTEGER64
136. IF UBOUND(in$) > 0 THEN
137.     result$ = in$(1)
138.     FOR ii = 2 TO UBOUND(in$)
139.         result$ = result$ + delimiter$ + in$(ii)
140.     NEXT
141. END IF
142. join1$ = result$
143. END FUNCTION
144.