taken from HTML5 A vocabulary and associated APIs for HTML and XHTML Editor's Draft 27 October 2009
table
elementStatus: open issues around @summary, additions to cell. API, and @orientation
caption
element, followed by either zero or more
colgroup elements, followed
optionally by a thead element,
followed optionally by a tfoot
element, followed by either zero or more
tbody elements or one or more tr
elements, followed optionally by a tfoot
element (but there can only be one tfoot
element child in total).orientation summary
interface HTMLTableElement : HTMLElement {
attribute HTMLTableCaptionElement caption;
HTMLElement createCaption();
void deleteCaption();
attribute HTMLTableSectionElement tHead;
HTMLElement createTHead();
void deleteTHead();
attribute HTMLTableSectionElement tFoot;
HTMLElement createTFoot();
void deleteTFoot();
readonly attribute HTMLCollection tBodies;
HTMLElement createTBody();
readonly attribute HTMLCollection rows;
HTMLElement insertRow(in optional long index);
void deleteRow(in long index);
attribute DOMString summary;
attriute DOMString orientation;
};
The table element
represents data with more than one dimension, in the
form of a table.
The table element takes
part in the table model.
Tables must not be used as layout aids. Historically, some Web authors have misused tables in HTML as a way to control their page layout. This usage is non-conforming, because tools attempting to extract tabular data from such documents would obtain very confusing results. In particular, users of accessibility tools like screen readers are likely to find it very difficult to navigate pages with tables used for layout.
There are a variety of alternatives to using HTML tables for layout, primarily using CSS positioning and the CSS table model.
User agents that do table analysis on arbitrary content are encouraged to find heuristics to determine which tables actually contain data and which are merely being used for layout. This specification does not define a precise heuristic.
Tables have rows and columns given by their descendants. A table must not have an empty row or column, as described in the description of the table model.
The orientation attribute has cna have the values rows and columns, which indicate whether the table should be read in rows (horizontally), in colums (rows).
rows is the default value. Auditory user agents MUST read the table according to this attribute, across rows when it is set to rows and down columns when it is set to columns.
User Agents MAY make use of the orientation when splitting tables, such as for small screens or printing.
See the National Braille Association's Tape Recording Manual [http://www.rfbd.org/about.htm]
for further explaination of rows and columns.
The status of the summary attribute is an open issue
The summary
attribute provides a summary of the table's purpose for
user agents rendering to non-visual media such as speech and Braille.
Earlier versions of HTML suggested using summary to provide structural
information about the table. This version adds the orientation attribute, and
methods on the cell interface that allow user agents to derive that
information from the table markup.
Authors SHOULD use summary to provide information that is obvious to visual users of the table, but would be difficult to determine by navigating the table cell by cell in an auditory user agent, and which cannot be derived by the user agent from the markup. The information provided by the summary is needed by users who cannot see the table, but would usually be redundant for those who can. Authors SHOULD use summary to highlight general idea that is to be drawn from the table, describe trends, high and low points, and the like. When a user with a non-visual user agent encounters a table, the summary should give him enough information to decide if he wishes to explore the table in detail, which can be quite time-consuming.
The information
provided by the summary is needed by users who cannot see the table, but
would usually be redundant for those who can. For tables where the
relationships are not obvious to users who can see the layout, or in other
situations where text describing the structure of the table might be useful
to sighted users as well as users of screen-readers and Braille devices, it
is better to describe the structure using the a
caption,
legend, or surrounding text instead
of, or in addition to,
summary. Authors MUST do this in a way
that is associated with the table via markup, such that user agents and
assistive technology can programmatically determine the relationship. When
using summary in combination with another technique, authors MUST NOT duplicate
the text, but instead use summary for the parts of the description
that are only useful to users who cannot see the table.
User agents MUST expose summary text in the accessibility API on their platform as specified in the Mappings from HTML to Platform APIs document [note: This document is still under development and does not yet have a stable URL. It will have one before last call]. Visual user agents MUST NOT render summary visually in non-editing scenarios, and SHOULD render summary visually in editing scenarios. Non-visual user agents MUST render summary.
| Flood Type | Map no. | Date | Area or stream with flooding | Reported deaths | Approximate cost (uninflated) | Comments |
|---|---|---|---|---|---|---|
| Regional flood | 1 | Mar.-Apr. 1913 | Ohio, statewide | 467 | $143M | Excessive regional rain. |
| 2 | Apr.-May 1927 | Mississippi River from Missouri to Louisiana | unknown | $230M | Record discharge downstream from Cairo, Illinois. | |
| 3 | Mar. 1936 | New England | 150+ | $300M | Excessive rainfall on snow. | |
| 4 | July 1951 | Kansas and Neosho River Basins in Kansas | 15 | $800M | Excessive regional rain. | |
| 5 | Dec. 1964 - Jan. 1965 | Pacific Northwest | 47 | $430M | Excessive rainfall on snow. | |
| Flash flood | 21 | June 14, 1903 | Willow Creek in Oregon | 225 | unknown | City of Heppner, Oregon, destroyed. |
| 22 | June 9-10, 1972 | Rapid City, South Dakota | 237 | $160M | 15 inches of rain in 5 hours. | |
| 23 | July 31, 1976 | Big Thompson and Cache la Poudre Rivers in Colorado | 144 | $39M | Flash flood in canyon after excessive rainfall. | |
| Ice-jam flood | 25 | May 1992 | Yukon River Alaska | 0 | unknown | 100-year flood on Yukon River. |
| Storm-surge flood | 26 | Sept. 1990 | Galveston, Texas | 6,000+ | unknown | Hurricane. |
| 27 | Sept. 1938 | Northeast United States | 494 | $360M | Hurricane. | |
| Dam-failure flood | 29 | Feb. 2, 1972 | Buffalo Creek in West Virginia | 125 | $60M | Dam failure after excessive rainfall. |
| 30 | June 5, 1976 | Teton River in Idaho | 11 | $400M | Earthen dam breached. | |
| Mudflow flood | 32 | May 18, 1980 | Toutle and lower Cowlitz Rivers in Washington | 60 | unknown | Result of eruption of Mt. St. Helens. |
<table border="1" orientation="row" summary="This table lists the 32 most significant floods of the 20th Century grouped into 6 types of floods: Regional, flash, ice-jam, storm-surge, dam-failure, and mudflow. The majority of the floods (20) are listed as Regional floods. There are between one and four floods in each of the other 5 categories. ">
The summary attribute includes the following information:
The orientation attribute in the row state indicates that the table should be read across.
<caption>Significant Floods of the 20th Century <br /> [M, million; B, billion]</caption>
The caption includes the title of the table, and a key to abbreviations used in the table for Millions and Billions.
This information is needed by all users of the table, and so is in the visible caption.
<tbody> <tr> <th id="type">Flood Type</th> <th id="map">Map no.</th> <th id="date">Date</th> <th id="area">Area or stream with flooding</th> <th id="deaths">Reported deaths</th> <th id="cost">Approximate cost (uninflated)</th> <th id="comments">Comments</th> </tr>
TH elements with ID attributes are used to associate cells with their related headers. The cell api has access to
these headers
<tr> <th rowspan="5" id="regional" scope="row">Regional flood</th> <td headers="regional map">1</td> <td headers="regional date">Mar.-Apr. 1913</td> <td headers="regional area">Ohio, statewide</td> <td headers="regional deaths">467</td> <td headers="regional cost">$143M</td> <td headers="regional comments">Excessive regional rain.</td> </tr>
The first cell in this table is also a TH, and will be available via the cell API.
<tr> <td headers="regional map">2</td> <td headers="regional date">Apr.-May 1927</td> <td headers="regional area">Mississippi River from Missouri to Louisiana</td> <td headers="regional deaths">unknown</td> <td headers="regional cost">$230M</td> <td headers="regional comments">Record discharge downstream from Cairo, Illinois.</td> </tr> <tr> <td headers="regional map">3</td> <td headers="regional">Mar. 1936</td> <td headers="regional">New England</td> <td headers="regional">150+</td> <td headers="regional">$300M</td> <td headers="regional">Excessive rainfall on snow.</td> </tr> <tr> <td headers="regional map">4</td> <td headers="regional">July 1951</td> <td headers="regional">Kansas and Neosho River Basins in Kansas</td> <td headers="regional">15</td> <td headers="regional">$800M</td> <td headers="regional">Excessive regional rain.</td> </tr> <tr> <td headers="regional map">5</td> <td headers="regional">Dec. 1964 - Jan. 1965</td> <td headers="regional">Pacific Northwest</td> <td headers="regional">47</td> <td headers="regional">$430M</td> <td headers="regional">Excessive rainfall on snow.</td> </tr> <tr> <th rowspan="3" scope="row">Flash flood</th> <td>21</td> <td>June 14, 1903</td> <td>Willow Creek in Oregon</td> <td>225</td> <td>unknown</td> <td>City of Heppner, Oregon, destroyed.</td> </tr> <tr> <td>22</td> <td>June 9-10, 1972</td> <td>Rapid City, South Dakota</td> <td>237</td> <td>$160M</td> <td>15 inches of rain in 5 hours.</td> </tr> <tr> <td>23</td> <td>July 31, 1976</td> <td>Big Thompson and Cache la Poudre Rivers in Colorado</td> <td>144</td> <td>$39M</td> <td>Flash flood in canyon after excessive rainfall.</td> </tr> <tr> <th scope="row">Ice-jam flood</th> <td>25</td> <td>May 1992</td> <td>Yukon River Alaska</td> <td>0</td> <td>unknown</td> <td>100-year flood on Yukon River.</td> </tr> <tr> <th rowspan="2" scope="row">Storm-surge flood</th> <td>26</td> <td>Sept. 1990</td> <td>Galveston, Texas</td> <td>6,000+</td> <td>unknown</td> <td>Hurricane.</td> </tr> <tr> <td>27</td> <td>Sept. 1938</td> <td>Northeast United States</td> <td>494</td> <td>$360M</td> <td>Hurricane.</td> </tr> <tr> <th rowspan="2" scope="row">Dam-failure flood</th> <td>29</td> <td>Feb. 2, 1972</td> <td>Buffalo Creek in West Virginia</td> <td>125</td> <td>$60M</td> <td>Dam failure after excessive rainfall.</td> </tr> <tr> <td>30</td> <td>June 5, 1976</td> <td>Teton River in Idaho</td> <td>11</td> <td>$400M</td> <td>Earthen dam breached.</td> </tr> <tr> <th scope="row">Mudflow flood</th> <td>32</td> <td>May 18, 1980</td> <td>Toutle and lower Cowlitz Rivers in Washington</td> <td>60</td> <td>unknown</td> <td>Result of eruption of Mt. St. Helens.</td> </tr> </tbody> </table>
The following table has an unusual layout which will not be obvious to many users who can see it. It might benefit from a visible description explaining to the way the table is laid out, something like "Characteristics are given in the second column, with the negative side in the left column and the positive side in the right column". In this case, it is best to describe the table in visible text. The text must be marked up in such a way that assistive technologies can determine programmatically that it is a description for the table.
For instance, the following table:
| Negative | Characteristic | Positive |
|---|---|---|
| Sad | Mood | Happy |
| Failing | Grade | Passing |
...might benefit from a description explaining the way the table is laid out, something like "Characteristics are given in the second column, with the negative side in the left column and the positive side in the right column".
There are a variety of ways to include this information, such as:
<p>In the following table, characteristics are given in the second column, with the negative side in the left column and the positive side in the right column.</p> <table> <caption>Characteristics with positive and negative sides</caption> <thead> <tr> <th id="n"> Negative <th> Characteristic <th> Positive <tbody> <tr> <td headers="n r1"> Sad <th id="r1"> Mood <td> Happy <tr> <td headers="n r2"> Failing <th id="r2"> Grade <td> Passing </table>
caption<table> <caption> <strong>Characteristics with positive and negative sides.</strong> <p>Characteristics are given in the second column, with the negative side in the left column and the positive side in the right column.</p> </caption> <thead> <tr> <th id="n"> Negative <th> Characteristic <th> Positive <tbody> <tr> <td headers="n r1"> Sad <th id="r1"> Mood <td> Happy <tr> <td headers="n r2"> Failing <th id="r2"> Grade <td> Passing </table>
caption,
in a details element<table>
<caption>
<strong>Characteristics with positive and negative sides.</strong>
<details>
<dt>Help</dt>
<dd>
<p>Characteristics are given in the second column, with the
negative side in the left column and the positive side in the right
column.</p>
</dd>
</details>
</caption>
<thead>
<tr>
<th id="n"> Negative
<th> Characteristic
<th> Positive
<tbody>
<tr>
<td headers="n r1"> Sad
<th id="r1"> Mood
<td> Happy
<tr>
<td headers="n r2"> Failing
<th id="r2"> Grade
<td> Passing
</table>
figure<figure>
<dt>Characteristics with positive and negative sides</dt>
<dd>
<p>Characteristics are given in the second column, with the
negative side in the left column and the positive side in the right
column.</p>
<table>
<thead>
<tr>
<th id="n"> Negative
<th> Characteristic
<th> Positive
<tbody>
<tr>
<td headers="n r1"> Sad
<th id="r1"> Mood
<td> Happy
<tr>
<td headers="n r2"> Failing
<th id="r2"> Grade
<td> Passing
</table>
</dd>
</figure>
figure's
dt<figure>
<dt>
<strong>Characteristics with positive and negative sides</strong>
<p>Characteristics are given in the second column, with the
negative side in the left column and the positive side in the right
column.</p>
</dt>
<dd>
<table>
<thead>
<tr>
<th id="n"> Negative
<th> Characteristic
<th> Positive
<tbody>
<tr>
<td headers="n r1"> Sad
<th id="r1"> Mood
<td> Happy
<tr>
<td headers="n r2"> Failing
<th id="r2"> Grade
<td> Passing
</table>
</dd>
</figure>
Authors may also use other techniques, or combinations of the above techniques, as appropriate.
The best option, of course, rather than writing a description explaining the way the table is laid out, is to adjust the table such that no explanation is needed.
In the case of the table used in the examples above, a simple
rearrangement of the table so that the headers are on the top and left sides
removes the need for an explanation as well as removing the need for the use
of headers
attributes:
<table> <caption>Characteristics with positive and negative sides</caption> <thead> <tr> <th> Characteristic <th> Negative <th> Positive <tbody> <tr> <th> Mood <td> Sad <td> Happy <tr> <th> Grade <td> Failing <td> Passing </table>
caption [ = value
]Returns the table's caption
element.
Can be set, to replace the caption
element. If the new value is not a
caption element, throws a
HIERARCHY_REQUEST_ERR exception.
createCaption()Ensures the table has a caption
element, and returns it.
deleteCaption()Ensures the table does not have a
caption element.
tHead [ = value ]Returns the table's thead
element.
Can be set, to replace the thead
element. If the new value is not a thead
element, throws a
HIERARCHY_REQUEST_ERR exception.
createTHead()Ensures the table has a thead
element, and returns it.
deleteTHead()Ensures the table does not have a
thead element.
tFoot [ = value ]Returns the table's tfoot
element.
Can be set, to replace the tfoot
element. If the new value is not a tfoot
element, throws a
HIERARCHY_REQUEST_ERR exception.
createTFoot()Ensures the table has a tfoot
element, and returns it.
deleteTFoot()Ensures the table does not have a
tfoot element.
tBodiesReturns an HTMLCollection of
the tbody elements of the
table.
createTBody()Creates a tbody element,
inserts it into the table, and returns it.
rowsReturns an HTMLCollection of
the tr elements of the table.
insertRow(index)Creates a tr element, along
with a tbody if required,
inserts them into the table at the position given by the argument, and
returns the tr.
The position is relative to the rows in the table. The index −1 is equivalent to inserting at the end of the table.
If the given position is less than −1 or greater than the number of rows,
throws an INDEX_SIZE_ERR
exception.
deleteRow(index)Removes the tr element with
the given position in the table.
The position is relative to the rows in the table. The index −1 is equivalent to deleting the last row of the table.
If the given position is less than −1 or greater than the index of the
last row, or if there are no rows, throws an
INDEX_SIZE_ERR exception.
The caption
IDL attribute must return, on getting, the first
caption element child of the
table element, if any, or null
otherwise. On setting, if the new value is a
caption element, the first
caption element child of the
table element, if any, must be
removed, and the new value must be inserted as the first node of the
table element. If the new value is
not a caption element, then
a HIERARCHY_REQUEST_ERR
DOM exception must be raised instead.
The
createCaption() method must return the first
caption element child of the
table element, if any; otherwise a
new caption element must be
created, inserted as the first node of the
table element, and then returned.
The
deleteCaption() method must remove the first
caption element child of the
table element, if any.
The tHead
IDL attribute must return, on getting, the first
thead element child of the
table element, if any, or null
otherwise. On setting, if the new value is a
thead element, the first
thead element child of the
table element, if any, must be
removed, and the new value must be inserted immediately before the first
element in the table element
that is neither a caption
element nor a colgroup
element, if any, or at the end of the table if there are no such elements.
If the new value is not a thead
element, then a HIERARCHY_REQUEST_ERR
DOM exception must be raised instead.
The
createTHead() method must return the first
thead element child of the
table element, if any; otherwise a
new thead element must be
created and inserted immediately before the first element in the
table element that is neither a
caption element nor a
colgroup element, if any, or at
the end of the table if there are no such elements, and then that new
element must be returned.
The
deleteTHead() method must remove the first
thead element child of the
table element, if any.
The tFoot
IDL attribute must return, on getting, the first
tfoot element child of the
table element, if any, or null
otherwise. On setting, if the new value is a
tfoot element, the first
tfoot element child of the
table element, if any, must be
removed, and the new value must be inserted immediately before the first
element in the table element
that is neither a caption
element, a colgroup
element, nor a thead element,
if any, or at the end of the table if there are no such elements. If the new
value is not a tfoot element,
then a HIERARCHY_REQUEST_ERR
DOM exception must be raised instead.
The
createTFoot() method must return the first
tfoot element child of the
table element, if any; otherwise a
new tfoot element must be
created and inserted immediately before the first element in the
table element that is neither a
caption element, a
colgroup element, nor a
thead element, if any, or at the end
of the table if there are no such elements, and then that new element must
be returned.
The
deleteTFoot() method must remove the first
tfoot element child of the
table element, if any.
The tBodies
attribute must return an HTMLCollection
rooted at the table node,
whose filter matches only tbody
elements that are children of the table
element.
The
createTBody() method must create a new
tbody element, insert it immediately
after the last tbody element
in the table element, if any,
or at the end of the table
element if the table element
has no tbody element children,
and then must return the new tbody
element.
The rows
attribute must return an HTMLCollection
rooted at the table node,
whose filter matches only tr
elements that are either children of the
table element, or children of
thead, tbody, or
tfoot elements that are
themselves children of the table
element. The elements in the collection must be ordered such that those
elements whose parent is a thead
are included first, in tree order, followed by those elements whose parent
is either a table or
tbody element, again in tree order,
followed finally by those elements whose parent is a
tfoot element, still in tree order.
The behavior of the
insertRow(index)
method depends on the state of the table. When it is called, the method must
act as required by the first item in the following list of conditions that
describes the state of the table and the index argument:
rows collection:
INDEX_SIZE_ERR exception.rows
collection has zero elements in it, and the
table has no
tbody elements in it:tbody
element, then create a tr
element, then append the tr
element to the tbody
element, then append the tbody
element to the table
element, and finally return the tr
element.rows
collection has zero elements in it:tr
element, append it to the last tbody
element in the table, and return the tr
element.
rows collection:tr
element, and append it to the parent of the last
tr element in the
rows
collection. Then, the newly created tr
element must be returned.tr
element, insert it immediately before the indexth
tr element in the
rows
collection, in the same parent, and finally must return the newly
created tr element.When the
deleteRow(index) method is called, the user
agent must run the following steps:
If index is equal to −1, then index
must be set to the number if items in the
rows collection, minus one.
Now, if index is less than zero, or greater than
or equal to the number of elements in the
rows collection, the method must
instead raise an INDEX_SIZE_ERR
exception, and these steps must be aborted.
Otherwise, the method must remove the indexth
element in the
rows collection from its parent.
The orientation
IDL attribute must reflect the content attribute of
the same name.
The summary
IDL attribute must reflect the content attribute of
the same name.
caption elementStatus: Last call for comments
table
element.
table elements.interface HTMLTableCaptionElement : HTMLElement {};
The caption element
represents the title of the
table that is its parent, if it has a
parent and that is a table
element.
The caption element takes
part in the table model.
When a table element is the
only content in a figure
element's dd, the
caption element should be omitted in
favor of the dt.
A caption can introduce context for a table, making it significantly easier to understand.
Consider, for instance, the following table:
| 1 | 2 | 3 | 4 | 5 | 6 | |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| 5 | 6 | 7 | 8 | 9 | 10 | 11 |
| 6 | 7 | 8 | 9 | 10 | 11 | 12 |
In the abstract, this table is not clear. However, with a caption giving the table's number (for reference in the main prose) and explaining its use, it makes more sense:
<caption> <p>Table 1. <p>This table shows the total score obtained from rolling two six-sided dice. The first row represents the value of the first die, the first column the value of the second die. The total is given in the cell that corresponds to the values of the two dice. </caption>
This provides the user with more context:
| 1 | 2 | 3 | 4 | 5 | 6 | |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| 5 | 6 | 7 | 8 | 9 | 10 | 11 |
| 6 | 7 | 8 | 9 | 10 | 11 | 12 |
colgroup elementStatus: Last call for comments
table
element, after any caption
elements and before any thead,
tbody,
tfoot, and
tr elements.col elements.spaninterface HTMLTableColElement : HTMLElement {
attribute unsigned long span;
};
The colgroup element
represents a
group of one or
more columns in the
table that is its parent, if it has a
parent and that is a table
element.
If the colgroup element
contains no col elements, then the
element may have a
span content attribute specified, whose value must be a
valid non-negative integer greater
than zero.
The colgroup element and
its span
attribute take part in the table model.
The span
IDL attribute must reflect the content attribute of
the same name. The value must be
limited to
only non-negative numbers greater than zero.
col
elementStatus: Last call for comments
colgroup
element that doesn't have a
span attribute.span
HTMLTableColElement, same
as for colgroup elements.
This interface defines one member,
span.
If a col element has a parent and
that is a colgroup element that
itself has a parent that is a table
element, then the col element
represents one or more
columns in the
column group
represented by that colgroup.
The element may have a
span content attribute specified, whose value must be a
valid non-negative integer greater
than zero.
The col element and its
span
attribute take part in the table model.
The span
IDL attribute must reflect the content attribute of
the same name. The value must be
limited to
only non-negative numbers greater than zero.
tbody
elementStatus: Last call for comments
table
element, after any caption,
colgroup, and
thead elements, but only if there
are no tr elements that are
children of the table element.tr elementsinterface HTMLTableSectionElement : HTMLElement {
readonly attribute HTMLCollection rows;
HTMLElement insertRow(in optional long index);
void deleteRow(in long index);
};
The HTMLTableSectionElement
interface is also used for thead
and tfoot elements.
The tbody element
represents a
block of
rows that consist of a body of
data for the parent table element,
if the tbody element has a parent
and it is a table.
The tbody element takes
part in the table model.
rowsReturns an HTMLCollection of
the tr elements of the table
section.
insertRow(
[ index ] )Creates a tr element, inserts
it into the table section at the position given by the argument, and returns
the tr.
The position is relative to the rows in the table section. The index −1, which is the default if the argument is omitted, is equivalent to inserting at the end of the table section.
If the given position is less than −1 or greater than the number of rows,
throws an INDEX_SIZE_ERR
exception.
deleteRow(index)Removes the tr element with
the given position in the table section.
The position is relative to the rows in the table section. The index −1 is equivalent to deleting the last row of the table section.
If the given position is less than −1 or greater than the index of the
last row, or if there are no rows, throws an
INDEX_SIZE_ERR exception.
The rows
attribute must return an HTMLCollection
rooted at the element, whose filter matches only
tr elements that are children of the
element.
The
insertRow(index) method must, when invoked
on an element table section, act as follows:
If index is less than −1 or greater than the number
of elements in the
rows collection, the method must raise an
INDEX_SIZE_ERR exception.
If index is missing, equal to −1, or equal to the
number of items in the
rows collection, the method must create
a tr element, append it to the
element table section, and return the newly created
tr element.
Otherwise, the method must create a tr
element, insert it as a child of the table section
element, immediately before the indexth
tr element in the
rows
collection, and finally must return the newly created
tr element.
The
deleteRow(index) method must remove the
indexth element in the
rows collection from its parent. If
index is less than zero or greater than or equal to the
number of elements in the
rows collection, the method must
instead raise an INDEX_SIZE_ERR
exception.
thead
elementStatus: Last call for comments
table
element, after any caption,
and colgroup elements and
before any tbody,
tfoot, and
tr elements, but only if there are no
other thead elements that are
children of the table element.tr elementsHTMLTableSectionElement,
as defined for tbody elements.The thead element
represents the
block of
rows that consist of the column
labels (headers) for the parent table
element, if the thead element has
a parent and it is a table.
The thead element takes
part in the table model.
tfoot
elementStatus: Last call for comments
table
element, after any caption,
colgroup, and
thead elements and before any
tbody and
tr elements, but only if there are no
other tfoot elements that are
children of the table element.table
element, after any caption,
colgroup,
thead,
tbody, and
tr elements, but only if there are no
other tfoot elements that are
children of the table element.tr elementsHTMLTableSectionElement,
as defined for tbody elements.The tfoot element
represents the
block of
rows that consist of the column
summaries (footers) for the parent table
element, if the tfoot element has
a parent and it is a table.
The tfoot element takes
part in the table model.
tr
elementStatus: Last call for comments
thead
element.tbody
element.tfoot
element.table
element, after any caption,
colgroup, and
thead elements, but only if there
are no tbody elements that are
children of the table element.thead
element: Zero or more th elementstd or
th elementsinterface HTMLTableRowElement : HTMLElement {
readonly attribute long rowIndex;
readonly attribute long sectionRowIndex;
readonly attribute HTMLCollection cells;
HTMLElement insertCell(in optional long index);
void deleteCell(in long index);
};
The tr element
represents a
row of
cells in a
table.
The tr element takes part in
the table model.
rowIndexReturns the position of the row in the table's
rows list.
Returns −1 if the element isn't in a table.
sectionRowIndexReturns the position of the row in the table section's
rows list.
Returns −1 if the element isn't in a table section.
cellsReturns an HTMLCollection of
the td and
th elements of the row.
insertCell(
[ index ] )Creates a td element, inserts
it into the table row at the position given by the argument, and returns the
td.
The position is relative to the cells in the row. The index −1, which is the default if the argument is omitted, is equivalent to inserting at the end of the row.
If the given position is less than −1 or greater than the number of
cells, throws an INDEX_SIZE_ERR
exception.
deleteCell(index)Removes the td or
th element with the given position in
the row.
The position is relative to the cells in the row. The index −1 is equivalent to deleting the last cell of the row.
If the given position is less than −1 or greater than the index of the
last cell, or if there are no cells, throws an
INDEX_SIZE_ERR exception.
The rowIndex
attribute must, if the element has a parent
table element, or a parent
tbody,
thead, or
tfoot element and a grandparent
table element, return the
index of the tr element in that
table element's
rows
collection. If there is no such table
element, then the attribute must return −1.
The
sectionRowIndex attribute must, if the element has a
parent table,
tbody,
thead, or
tfoot element, return the index of
the tr element in the parent
element's rows collection (for tables, that's the
rows
collection; for table sections, that's the
rows collection). If there is no such
parent element, then the attribute must return −1.
The cells
attribute must return an HTMLCollection
rooted at the tr element, whose
filter matches only td and
th elements that are children of the
tr element.
The
insertCell(index) method must act as
follows:
If index is less than −1 or greater than the number
of elements in the cells
collection, the method must raise an
INDEX_SIZE_ERR exception.
If index is missing, equal to −1, or equal to the
number of items in cells
collection, the method must create a td
element, append it to the tr
element, and return the newly created td
element.
Otherwise, the method must create a td
element, insert it as a child of the tr
element, immediately before the indexth
td or
th element in the
cells collection, and finally must return
the newly created td element.
The
deleteCell(index) method must remove the
indexth element in the
cells collection from its parent. If
index is less than zero or greater than or equal to the
number of elements in the
cells collection, the method must instead
raise an INDEX_SIZE_ERR
exception.
td
elementStatus: Last call for comments
tr element.colspanrowspanheaders
interface HTMLTableDataCellElement : HTMLTableCellElement {};
The td element
represents a data
cell in a table.
The td element and its
colspan,
rowspan,
and headers
attributes take part in the table model.
th
elementStatus: Last call for comments
tr element.colspanrowspanheadersscopeinterface HTMLTableHeaderCellElement : HTMLTableCellElement {
attribute DOMString scope;
};
The th element
represents a header
cell in a table.
The th element may have a
scope content
attribute specified. The
scope attribute is an enumerated
attribute with five states, four of which have explicit keywords:
row
keyword, which maps to the row statecol
keyword, which maps to the column staterowgroup keyword, which maps to the row group
stateth
element's scope
attribute must not be in the
row group
state if the element is not anchored in a
row group.colgroup keyword, which maps to the column group
stateth
element's scope
attribute must not be in the
column
group state if the element is not anchored in a
column group.The scope
attribute's missing value default is the auto state.
The th element and its
colspan,
rowspan,
headers,
and scope
attributes take part in the table model.
The scope
IDL attribute must reflect the content attribute of
the same name.
The following example shows how the
scope attribute's
rowgroup value affects which data cells a header cell applies to.
Here is a markup fragment showing a table:
<table> <thead> <tr> <th> ID <th> Measurement <th> Average <th> Maximum <tbody> <tr> <td> <th scope=rowgroup> Cats <td> <td> <tr> <td> 93 <th> Legs <td> 3.5 <td> 4 <tr> <td> 10 <th> Tails <td> 1 <td> 1 <tbody> <tr> <td> <th scope=rowgroup> English speakers <td> <td> <tr> <td> 32 <th> Legs <td> 2.67 <td> 4 <tr> <td> 35 <th> Tails <td> 0.33 <td> 1 </table>
This would result in the following table:
| ID | Measurement | Average | Maximum |
|---|---|---|---|
| Cats | |||
| 93 | Legs | 3.5 | 4 |
| 10 | Tails | 1 | 1 |
| English speakers | |||
| 32 | Legs | 2.67 | 4 |
| 35 | Tails | 0.33 | 1 |
The headers in the first row all apply directly down to the rows in their column.
The headers with the explicit
scope attributes apply to all the cells
in their row group other than the cells in the first column.
The remaining headers apply just to the cells to the right of them.

td and
th elementsStatus: Last call for comments
The td and
th elements may have a
colspan
content attribute specified, whose value must be a
valid non-negative integer greater
than zero.
The td and
th elements may also have a
rowspan
content attribute specified, whose value must be a
valid non-negative integer.
These attributes give the number of columns and rows respectively that the cell is to span. These attributes must not be used to overlap cells, as described in the description of the table model.
The td and
th element may have a
headers
content attribute specified. The
headers attribute, if specified, must
contain a string consisting of an
unordered set of
unique space-separated tokens, each of which must have the value of an ID of
a th element taking part in the same
table as the
td or th
element (as defined by the table model).
A th element with ID
id is said to be directly targeted by all
td and th
elements in the same table
that have headers
attributes whose values include as one of their tokens the ID id.
A th element A is
said to be targeted by a th or
td element B if
either A is directly targeted by B
or if there exists an element C that is itself targeted
by the element B and A is directly
targeted by C.
A th element must not be
targeted by itself.
The colspan,
rowspan,
and headers
attributes take part in the table model.
The td and
th elements implement interfaces that
inherit from the HTMLTableCellElement
interface:
interface HTMLTableCellElement : HTMLElement {
attribute unsigned long colSpan;
attribute unsigned long rowSpan;
attribute DOMString headers;
readonly attribute long cellIndex;
};
cellIndexReturns the position of the cell in the row's
cells list.
Returns 0 if the element isn't in a row.
cellColumnHeadersHTMLCollection of
column headers associated with this cell.
cellColumnGroupHeadersHTMLCollection of
column group headers associated with this cell.
cellRowHeadersHTMLCollection of
row headers associated with this cell.
cellRowGroupHeadersHTMLCollection of
row group headers associated with this cell.The colSpan
IDL attribute must reflect the content attribute of
the same name. The value must be
limited to
only non-negative numbers greater than zero.
The rowSpan
IDL attribute must reflect the content attribute of
the same name. Its default value, which must be used if
parsing the attribute as a non-negative integer returns an error, is 1.
The headers
IDL attribute must reflect the content attribute of
the same name.
The
cellIndex IDL attribute must, if the element has a parent
tr element, return the index of the
cell's element in the parent element's
cells collection. If there is no such
parent element, then the attribute must return 0.
Status: Last call for comments
The various table elements and their content attributes together define the table model.
A table consists of
cells aligned on a two-dimensional grid of
slots with coordinates (x,
y). The grid is finite, and is either empty or has one
or more slots. If the grid has one or more slots, then the x
coordinates are always in the range 0 ≤ x < xwidth,
and the y coordinates are always in the range
0 ≤ y < yheight.
If one or both of xwidth and
yheight are zero, then the table is
empty (has no slots). Tables correspond to
table elements.
A cell is a set of
slots anchored at a slot (cellx,
celly), and with a particular
width and height such that the cell
covers all the slots with coordinates (x,
y) where cellx ≤ x < cellx+width
and celly ≤ y < celly+height.
Cells can either be data cells or header cells. Data cells
correspond to td elements, and
header cells correspond to th
elements. Cells of both types can have zero or more associated header cells.
It is possible, in certain error cases, for two cells to occupy the same slot.
A row is a complete set
of slots from x=0 to
x=xwidth-1,
for a particular value of y. Rows correspond to
tr elements.
A column is a
complete set of slots from y=0 to
y=yheight-1,
for a particular value of x. Columns can correspond to
col elements, but in the absence
of col elements are implied.
A row group
is a set of rows anchored at
a slot (0, groupy) with a particular
height such that the row group covers all the slots with
coordinates (x, y) where
0 ≤ x < xwidth
and groupy ≤ y < groupy+height.
Row groups correspond to tbody,
thead, and
tfoot elements. Not every row is
necessarily in a row group.
A column
group is a set of
columns anchored at a slot (groupx,
0) with a particular width such that the column group
covers all the slots with coordinates (x,
y) where groupx ≤ x < groupx+width
and 0 ≤ y < yheight.
Column groups correspond to colgroup
elements. Not every column is necessarily in a column group.
Row groups cannot overlap each other. Similarly, column groups cannot overlap each other.
A cell cannot cover slots that are from two or more row groups. It is, however, possible for a cell to be in multiple column groups. All the slots that form part of one cell are part of zero or one row groups and zero or more column groups.
In addition to cells,
columns,
rows,
row groups, and
column groups,
tables can have a
caption element associated with
them. This gives the table a heading, or legend.
A table model error is an error with
the data represented by table
elements and their descendants. Documents must not have table model errors.
Status: Last call for comments
To determine which elements correspond to which slots in a
table associated with a
table element, to determine
the dimensions of the table (xwidth
and yheight), and to determine if
there are any table
model errors, user agents must use the following algorithm:
Let xwidth be zero.
Let yheight be zero.
Let pending tfoot
elements be a list of tfoot
elements, initially empty.
Let the table be the
table represented by
the table element. The
xwidth and yheight
variables give the table's dimensions.
The table is initially empty.
If the table element
has no children elements, then return the table
(which will be empty), and abort these steps.
Associate the first caption
element child of the table
element with the table. If there are no such
children, then it has no associated
caption element.
Let the current element be the first element
child of the table
element.
If a step in this algorithm ever requires the current
element to be
advanced
to the next child of the table when there is no such
next child, then the user agent must jump to the step labeled end,
near the end of this algorithm.
While the current element is not one of the
following elements,
advance
the current element to the next child of the
table:
If the current element is a
colgroup, follow these
substeps:
Column groups: Process the current element according to the appropriate case below:
col element childrenFollow these steps:
Let xstart have the value of xwidth.
Let the current column be the first
col element
child of the colgroup
element.
Columns: If the current column
col element has
a span
attribute, then parse its value using the
rules for
parsing non-negative integers.
If the result of parsing the value is not an error or zero, then let span be that value.
Otherwise, if the col
element has no
span attribute, or if
trying to parse the attribute's value resulted in an error,
then let span be 1.
Increase xwidth by span.
Let the last span
columns
in the table correspond to the
current column
col element.
If current column is not the last
col element
child of the colgroup
element, then let the current column be
the next col
element child of the
colgroup element, and return to the step labeled
columns.
Let all the last
columns
in the table from x=xstart
to x=xwidth-1
form a new
column group, anchored at the slot (xstart,
0), with width xwidth-xstart,
corresponding to the
colgroup element.
col element childrenIf the colgroup
element has a
span attribute,
then parse its value using the
rules for
parsing non-negative integers.
If the result of parsing the value is not an error or zero, then let span be that value.
Otherwise, if the
colgroup element has no
span attribute, or
if trying to parse the attribute's value resulted in an
error, then let span be 1.
Increase xwidth by span.
Let the last span
columns
in the table form a new
column group, anchored at the slot (xwidth-span,
0), with width span, corresponding to
the colgroup
element.
While the current element is not one of the
following elements,
advance the current element to the next
child of the table:
If the current element is a
colgroup element, jump to
the step labeled column groups above.
Let ycurrent be zero.
Let the list of downward-growing cells be an empty list.
Rows: While the current element is not one
of the following elements,
advance
the current element to the next child of the
table:
If the current element is a
tr, then run the
algorithm for processing rows,
advance
the current element to the next child of the
table, and return to the step
labeled rows.
Run the algorithm for ending a row group.
If the current element is a
tfoot, then add that element to
the list of pending
tfoot elements,
advance
the current element to the next child of the
table, and return to the step
labeled rows.
The current element is either a
thead or a
tbody.
Run the algorithm for processing row groups.
Return to the step labeled rows.
End: For each tfoot
element in the list of pending
tfoot elements, in tree
order, run the algorithm
for processing row groups.
If there exists a row or column in the table the table containing only slots that do not have a cell anchored to them, then this is a table model error.
Return the table.
The algorithm for
processing row groups, which is invoked by the set of steps above for
processing thead,
tbody, and
tfoot elements, is:
Let ystart have the value of yheight.
For each tr element that
is a child of the element being processed, in tree order, run the
algorithm for processing rows.
If yheight > ystart, then let all the last rows in the table from y=ystart to y=yheight-1 form a new row group, anchored at the slot with coordinate (0, ystart), with height yheight-ystart, corresponding to the element being processed.
Run the algorithm for ending a row group.
The algorithm for ending a row group, which is invoked by the set of steps above when starting and ending a block of rows, is:
While ycurrent is less than yheight, follow these steps:
Increase ycurrent by 1.
Empty the list of downward-growing cells.
The algorithm for processing rows,
which is invoked by the set of steps above for processing
tr elements, is:
If yheight is equal to ycurrent, then increase yheight by 1. (ycurrent is never greater than yheight.)
Let xcurrent be 0.
If the tr element being
processed has no td or
th element children, then increase
ycurrent by 1, abort this set of
steps, and return to the algorithm above.
Let current cell be the first
td or
th element in the
tr element being processed.
Cells: While xcurrent is less than xwidth and the slot with coordinate (xcurrent, ycurrent) already has a cell assigned to it, increase xcurrent by 1.
If xcurrent is equal to xwidth, increase xwidth by 1. (xcurrent is never greater than xwidth.)
If the current cell has a
colspan
attribute, then
parse that attribute's value, and let colspan be
the result.
If parsing that value failed, or returned zero, or if the attribute is absent, then let colspan be 1, instead.
If the current cell has a
rowspan
attribute, then
parse that attribute's value, and let
rowspan be the result.
If parsing that value failed or if the attribute is absent, then let rowspan be 1, instead.
If rowspan is zero, then let cell grows downward be true, and set rowspan to 1. Otherwise, let cell grows downward be false.
If xwidth < xcurrent+colspan, then let xwidth be xcurrent+colspan.
If yheight < ycurrent+rowspan, then let yheight be ycurrent+rowspan.
Let the slots with coordinates (x, y) such that xcurrent ≤ x < xcurrent+colspan and ycurrent ≤ y < ycurrent+rowspan be covered by a new cell c, anchored at (xcurrent, ycurrent), which has width colspan and height rowspan, corresponding to the current cell element.
If the current cell element is a
th element, let this new cell
c be a header cell; otherwise, let it be a data
cell.
To establish which header cells apply to the current cell element, use the algorithm for assigning header cells described in the next section.
If any of the slots involved already had a cell covering them, then this is a table model error. Those slots now have two cells overlapping.
If cell grows downward is true, then add the tuple {c, xcurrent, colspan} to the list of downward-growing cells.
Increase xcurrent by colspan.
If current cell is the last
td or
th element in the
tr element being processed, then
increase ycurrent by 1, abort
this set of steps, and return to the algorithm above.
Let current cell be the next
td or
th element in the
tr element being processed.
Return to the step labelled cells.
When the algorithms above require the user agent to run the algorithm for growing downward-growing cells, the user agent must, for each {cell, cellx, width} tuple in the list of downward-growing cells, if any, extend the cell cell so that it also covers the slots with coordinates (x, ycurrent), where cellx ≤ x < cellx+width.
Status: Last call for comments
Each cell can be assigned zero or more header cells. The algorithm for assigning header cells to a cell principal cell is as follows.
Let header list be an empty list of cells.
Let (principalx, principaly) be the coordinate of the slot to which the principal cell is anchored.
headers
attribute specifiedTake the value of the principal cell's
headers attribute and
split it on spaces, letting id list be
the list of tokens obtained.
For each token in the id list, if the
first element in the Document with an ID equal to
the token is a cell in the same
table, and
that cell is not the principal cell, then
add that cell to header list.
headers
attribute specifiedLet principalwidth be the width of the principal cell.
Let principalheight be the height of the principal cell.
For each value of y from principaly to principaly+principalheight-1, run the internal algorithm for scanning and assigning header cells, with the principal cell, the header list, the initial coordinate (principalx,y), and the increments Δx=−1 and Δy=0.
For each value of x from principalx to principalx+principalwidth-1, run the internal algorithm for scanning and assigning header cells, with the principal cell, the header list, the initial coordinate (x,principaly), and the increments Δx=0 and Δy=−1.
If the principal cell is anchored in a row group, then add all header cells that are row group headers and are anchored in the same row group with an x-coordinate less than or equal to principalx+principalwidth-1 and a y-coordinate less than or equal to principaly+principalheight-1 to header list.
If the principal cell is anchored in a column group, then add all header cells that are column group headers and are anchored in the same column group with an x-coordinate less than or equal to principalx+principalwidth-1 and a y-coordinate less than or equal to principaly+principalheight-1 to header list.
Remove all the empty cells from the header list.
Remove any duplicates from the header list.
Assign the headers in the header list to the principal cell.
The internal algorithm for scanning and assigning header cells, given a principal cell, a header list, an initial coordinate (initialx, initialy), and Δx and Δy increments, is as follows:
Let x equal initialx.
Let y equal initialy.
Let opaque headers be an empty list of cells.
Let in header block be true, and let headers from current header block be a list of cells containing just the principal cell.
Let in header block be false and let headers from current header block be an empty list of cells.
Loop: Increment x by Δx; increment y by Δy.
For each invocation of this algorithm, one of Δx and Δy will be −1, and the other will be 0.
If either x or y is less than 0, then abort this internal algorithm.
If there is no cell covering slot (x, y), or if there is more than one cell covering slot (x, y), return to the substep marked loop.
Let current cell be the cell covering slot (x, y).
Set in header block to true.
Add current cell to headers from current header block.
Let blocked be false.
If there are any cells in the opaque headers list anchored with the same x-coordinate as the current cell, and with the same width as current cell, then let blocked be true.
If the current cell is not a column header, then let blocked be true.
If there is are any cells in the opaque headers list anchored with the same y-coordinate as the current cell, and with the same height as current cell, then let blocked be true.
If the current cell is not a row header, then let blocked be true.
If blocked is false, then add the current cell to the headers list.
Set in header block to false. Add all the cells in headers from current header block to the opaque headers list, and empty the headers from current header block list.
Return to the step marked loop.
A header cell anchored at the slot with coordinate (x, y) with width width and height height is said to be a column header if any of the following conditions are true:
scope attribute is in the
column state,
or
scope attribute is in the
auto state,
and there are no data cells in any of the cells covering slots with
y-coordinates y ..
y+height-1.A header cell anchored at the slot with coordinate (x, y) with width width and height height is said to be a row header if any of the following conditions are true:
scope attribute is in the
row state, or
scope attribute is in the
auto state,
the cell is not a column header, and there
are no data cells in any of the cells covering slots with
x-coordinates x ..
x+width-1.A header cell is said to be a column group
header if its
scope attribute is in the
column
group state.
A header cell is said to be a row group header
if its scope
attribute is in the
row group
state.
A cell is said to be an empty cell if it contains no elements and its text content, if any, consists only of White_Space characters.
Status: Last call for comments
This section is non-normative.
The following shows how might one mark up the bottom part of table 45 of the Smithsonian physical tables, Volume 71:
<table> <caption>Specification values: <b>Steel</b>, <b>Castings</b>, Ann. A.S.T.M. A27-16, Class B;* P max. 0.06; S max. 0.05.</caption> <thead> <tr> <th rowspan=2>Grade.</th> <th rowspan=2>Yield Point.</th> <th colspan=2>Ultimate tensile strength</th> <th rowspan=2>Per sent elong. 50.8mm or 2 in.</th> <th rowspan=2>Per cent reduct. area.</th> </tr> <tr> <th>kg/mm<sup>2</sup></th> <th>lb/in<sup>2</sup></th> </tr> </thead> <tbody> <tr> <td>Hard</td> <td>0.45 ultimate</td> <td>56.2</td> <td>80,000</td> <td>15</td> <td>20</td> </tr> <tr> <td>Medium</td> <td>0.45 ultimate</td> <td>49.2</td> <td>70,000</td> <td>18</td> <td>25</td> </tr> <tr> <td>Soft</td> <td>0.45 ultimate</td> <td>42.2</td> <td>60,000</td> <td>22</td> <td>30</td> </tr> </tbody> </table>
This table could look like this:
| Grade. | Yield Point. | Ultimate tensile strength | Per cent elong. 50.8 mm or 2 in. | Per cent reduct. area. | |
|---|---|---|---|---|---|
| kg/mm2 | lb/in2 | ||||
| Hard | 0.45 ultimate | 56.2 | 80,000 | 15 | 20 |
| Medium | 0.45 ultimate | 49.2 | 70,000 | 18 | 25 |
| Soft | 0.45 ultimate | 42.2 | 60,000 | 22 | 30 |
The following shows how one might mark up the gross margin table on page 46 of Apple, Inc's 10-K filing for fiscal year 2008:
<table> <thead> <tr> <th> <th>2008 <th>2007 <th>2006 <tbody> <tr> <th>Net sales <td>$ 32,479 <td>$ 24,006 <td>$ 19,315 <tr> <th>Cost of sales <td> 21,334 <td> 15,852 <td> 13,717 <tbody> <tr> <th>Gross margin <td>$ 11,145 <td>$ 8,154 <td>$ 5,598 <tfoot> <tr> <th>Gross margin percentage <td>34.3% <td>34.0% <td>29.0% </table>
This table could look like this:
| 2008 | 2007 | 2006 | |
|---|---|---|---|
| Net sales | $ 32,479 | $ 24,006 | $ 19,315 |
| Cost of sales | 21,334 | 15,852 | 13,717 |
| Gross margin | $ 11,145 | $ 8,154 | $ 5,598 |
| Gross margin percentage | 34.3% | 34.0% | 29.0% |
The following shows how one might mark up the operating expenses table from lower on the same page of that document:
<table>
<colgroup> <col>
<colgroup> <col> <col> <col>
<thead>
<tr> <th> <th>2008 <th>2007 <th>2006
<tbody>
<tr> <th scope=rowgroup> Research and development
<td> $ 1,109 <td> $ 782 <td> $ 712
<tr> <th scope=row> Percentage of net sales
<td> 3.4% <td> 3.3% <td> 3.7%
<tbody>
<tr> <th scope=rowgroup> Selling, general, and administrative
<td> $ 3,761 <td> $ 2,963 <td> $ 2,433
<tr> <th scope=row> Percentage of net sales
<td> 11.6% <td> 12.3% <td> 12.6%
</table>
This table could look like this:
| 2008 | 2007 | 2006 | |
|---|---|---|---|
| Research and development | $ 1,109 | $ 782 | $ 712 |
| Percentage of net sales | 3.4% | 3.3% | 3.7% |
| Selling, general, and administrative | $ 3,761 | $ 2,963 | $ 2,433 |
| Percentage of net sales | 11.6% | 12.3% | 12.6% |
Status: Last call for comments
Forms allow unscripted client-server interaction: given a form, a user can provide data, submit it to the server, and have the server act on it accordingly (e.g. returning the results of a search or calculation). The elements used in forms can also be used for user interaction with no associated submission mechanism, in conjunction with scripts.
Mostly for historical reasons, elements in this section fall into several overlapping (but subtly different) categories in addition to the usual ones like flow content, phrasing content, and interactive content.
A number of the elements are
form-associated elements, which means they can have a
form owner and, to expose this, have a
form content
attribute with a matching
form IDL attribute.
The form-associated elements fall into several subcategories:
Denotes elements that are listed in the
form.elements
and
fieldset.elements APIs.
Denotes elements that can be associated with
label elements.
Denotes elements that can be used for
constructing the form data set
when a form element is
submitted.
Denotes elements that can be affected when a
form element is
reset.
In addition, some submittable elements can be, depending on their attributes, buttons. The prose below defines when an element is a button. Some buttons are specifically submit buttons.
The object
element is also a form-associated element
and can, with the use of a suitable plugin, partake in
form submission.