Manipulation of string Directly and Indirectly
For now, I will mostly concentrate in this post on the indirect way of manipulation , that is to say through the use of the OOP type model object, ( HTMLdoc ). I will just briefly touch initially on looking at the simple string as a string of text..

Rem 3 Manipulation of string Directly and Indirectly
Rem 3a) Directly
I have not completed this section yet. I may come back to this later. The only thing I have done is to produce a simple text file from the HTML code string , PageSrc , which was obtained from '2a
Just for fun, if we compare the two text files, report.txt and the text file made in this section, strTextFile.txt then we see that they appear very similar.. in fact they appear to be the same, except that their size differs…. I will definitely come back to look at that later..…. ##
report_txt and strTextFile_txt .JPG : https://imgur.com/35eE19e
report_txt and strTextFile_txt .JPG : https://imgur.com/0MdFeUt

Rem 3b) (Rem 3b)(ii) ) Large Object from main made OOP type model object, ( HTMLdoc )
This is a small “ in between “ section , which I mainly do to keep in line with a typical way of doing coding of this type.
The OOP type model object, ( HTMLdoc ) is a large quite complicated object , which is probably difficult to relate to anything humanly perceivable. Generally we try to get at an “under object” either directly of through other objects. There probably are ways to get straight to a specific “thing” which we are after, but usually it is not done that way. If we always did that simple way, then it might put a lot of computer programmes out of work as the extra complication helps to give them something to do.
In this short code section we use the The .getElementsByTagName( ) method, which is a method available to our created HTMLdoc . This returns a collection of all elements in the document with the specified tag name, as a “NodeList” object. A NodeList object represents a collection of nodes. The nodes can be accessed by index numbers. The index starts at 0. The nodes can crudely be considered as simply points in our long string, and generally we talk in computing about nodes as the point in a string at a branch in a string type structure. The index number would usually represent nodes of the same level that also satisfy the condition in the ( )
This string structure can sometimes be seen in the way the indent is used in the HTML text files.
This is all somewhat academic to the fairly simple “html string file” that we are using, but in this way we are coming close to using the same coding as for getting information from the very large ( actually very long html string ) data strong that is used to show a typical internet site.
In our case the use .getElementsByTagName( ) has resulted in getting a collection object of just one item, ( which, incidentally , our HTMLdoc appears to have actually recognised as a table. Indeed, if we were using Early Binding, then we could of Dimed the object we use in the next section as a HTMLTable
oTable as HTMLTable.JPG : https://imgur.com/R309JjC
In a , ( possibly unnecessary round about sort of a way ) we finally have a “table object” , ( specifically a “html Dom object” HTMLTable ).
_.________________________________________________ ____

Rem 4 Manipulation of string Indirectly
We start here probably at the main point of the use of a OOP type model object, ( HTMLdoc ) in preference to a more straight forward way of string manipulation of either our report.txt or , strTextFile.txt file or PageSrc text String .
( Rem 4 would probably be better denoted by Rem 3b)(ii), but the use of Rem 4 is partly because it is a large section of a particular theme, that of the manipulation ( and partly just to keep in comparison with some other coding of this type that I have ) )

Code section '4b) Array generation from HTMLTable objects within “html Dom object”
This code section forms the main working to get a useable list of update data. It basically fills a data array using the “html Dom object” properties for the HTMLTable object which the last section has got us.
I will review how we got here and then go on to walk through this code section in more detail.
Review How did we get this far.
This review is specifically referring to the “HTML stuff and nonsense”…
We have originally been presented with a large string of text which looks like a lot of normal everyday text except that a lot of pointy brackets are included. This string text format characterises a typical “HTML” coding, which is one of the most common languages used for things moving around the internet. In the previous code sections we have used some tried and tested techniques, principally for using information from the internet, but which work equally well for our File containing that string of “pointy bracket text”. The result of using these techniques is that we have been able to supply a form of our original text , ( possibly in fact exactly the same, I am not sure yet ## ) , held in a simple String variable, PageSrc , into an object of a type/class going by the names of HTMLDocument for Early Binding and htmlfile for late binding. ( We use late binding , and note in parsing that we are dealing with a class that untypical works slightly differently in Early and Late binding : http://www.eileenslounge.com/viewtop...=31547#p244184 ) . This large main object is often named , htmlfile , HTMLdoc , html dom object , HTML document object … or similar
In our coding we use HTMLdoc for the variable for this main large object.
At the start of code section Rem 4 we have used a technique typically used to allow getting at “under objects “ from the main large “Dom” object. For our simple case we end up with an object known as a HTMLTable, which in simple terms could be thought of as an actual table full just as we want finally full with our update information.

The next detailed code description in the next post may appear more complicated than it is.
All we are doing is using the Properties of that table to build a simple array of our data. If you are familiar with a bit of VBA , then when dealing with “HTML Dom things” , a slight adjustment in your way of thinking can be helpful:
The properties that we use are approximately mainly to do with :

Rows : This can be considered as similar to rows type things in VBA and Excel generally.

Cells : In “HTML Dom things” generally and in “HTMLTable” things in particular, a regular row, column way of thinking as in a spreadsheet is not so common. It is more unusual to talk in terms of Cells. To a first approximation a Cell in a HTML Table and a spreadsheet could be considered similar. In general we do not talk in terms of column things.
What we can have, in addition to the entire cells for the table, is an additional Cells property for each row. So rather than getting at a Cell via a (r, c) type co ordinate system as in the case of a spreadsheet, we tend to do something different for a HTML table. For a MTHM Table we would tend to refer to a cell via something like pseudo
Table.Row(r).Cells(C)
So as comparison: In VBA coding generally we might see like this pseudo coding to loop through a range or a table
__For each row, r
____For each column, c
As comparison the equivalent pseudo coding when looking at HTML Table coding would be like:
__For each row, r
____For each row(r).cell(C)

Length : In HTML things, the word Length is often used where in other VBA things, the word Count might be used.


The next post will now look at a detailed walkthrough of code section 4b)