How do I set this up ? (good array example)[RESOLVED]

How would I cycle through these 4 (actually a bunch more) pairs until they are all processed by the same code ...it's probably a For Each Array solution but I've never had to do it before... tkx

str1="stuff"
str2="otherstuff"

str1="stuff"
str2="otherstuff"

str1="stuff"
str2="otherstuff"

str1="stuff"
str2="otherstuff"

'some code to do something with str1 and str2

'get the next pair and do it again until all pairs processed

what is your data source. A text file or are the strings in text box's on a form ?

.

It's a text file...

Comma or tab delimited ??
A pair of strings per line or one string per line? The former would be better as it makes differentiation of the data more positive.
.

like this in the file:
text str1
text str2
(space)
text str1
text str2
(space)
text str1
text str2
(space)
etc.

No Probs. Just trying some code now...

OK - This code works wth the text file in the format that you called for. But it is quick and dirty with regards how it handles the file. You have to have two carriage returns after the last string (in the text file) and no spaces at the top of the file.

You will get the idea from this though, and maybe you will feel that you could work it better with a different file format. I would go for comma or tab delimited strings. Two to a line.

Anyway, here you go...

VB Code:

Function LoadAndOperate() As Boolean
 
Dim n As Long
Dim s1 As String, s2 As String
 
Begin:
 
     On Error GoTo Module_Error
     LoadAndOperate = False
     
     Dim Buffer As String
     Dim File2WorkOn
     
     'Load the file into a line array
     Dim Linecount, LineArray, filenum, OneLine, Line1, Line2, skipline
     ReDim LineArray(0 To 1, 0 To 10)
 
     File2WorkOn = "c:\test.txt"
     filenum = FreeFile
     
     Open File2WorkOn For Input As #filenum
     '--------------------------
     n = 0
     Do While Not EOF(filenum)
          ' assuming no space at the start of the line..
          
          Line Input #filenum, Line1
          Line Input #filenum, Line2
          Line Input #filenum, skipline
          
          ' Load each string ....
          LineArray(0, n) = Line1
          LineArray(1, n) = Line2
          
          n = n + 1
          ' Make more space in the array if we need to....
          If n > UBound(LineArray) Then
               ReDim Preserve LineArray(0 To 1, 0 To (UBound(LineArray) + 10))
               End If
     Loop
     
     Close #filenum
 
     ReDim Preserve LineArray(0 To 1, 0 To n - 1)     ' EDIT - OOPS Forgot this first time in              
          
     For n = 0 To UBound(LineArray, 2)
          
          s1 = LineArray(0, n)
          s2 = LineArray(1, n)
          
          ' Work with S1 and S2 here....
                    
     Next n
    
          
     LoadAndOperate = True
Module_Exit:
     On Error GoTo 0
     Exit Function
 
Module_Error:
     MsgBox "Error " & Err.Number & " (" & Err.Description & ") in procedure LoadAndOperate "
     GoTo Module_Exit
End Function

Thanks a bunch David ! not only does it work straitaway, it's simple enough so I can learn how it works and go from there (since I knew nothing about setting up arrays) :bigyello:

You are welcome. The trick with arrays is not to define them fully at the declaration point - unless you want to that is. Because if you do you can't change them later.

Dim LineArray

can be redimentioned, but

Dim Linearray(0 to 1, 0 to 10)
Dim Linearray(10)

are fixed.

Also when you redimention an array, to save what was already in there use the "preserve" keyword. This only works however if you extend the LAST dimention in the array.

For example. In the code I posted, I could not have added more room for another string (making it able to handle three strings instead of two) without clearing down the array and starting again. I tend to think of it that it is the structure of the array that is fixed, but how many items you have in the array can be extended.

Have fun...

You also have UDT's (User defined types), Collections and Dictionary types to play with yet.
.