Create an HTML table: Difference between revisions

{{trans|Python}}

 

F nonrandom(n)

:seed = 1664525 * :seed + 1013904223

V rows = (1..5).map(i -> tag(‘tr’, tag(‘td’, i, ‘ style="font-weight: bold;"’)‘’(0.<3).map(j -> tag(‘td’, rand9999())).join(‘’))).join("\n")

V table = tag(‘table’, "\n"header‘’rows"\n")

 

{{out}}

=={{header|360 Assembly}}==

{{trans|BBC BASIC}}

CREHTML CSECT

USING CREHTML,R13

XDEC DS CL12

YREGS

{{out}}

<pre>

 

=={{header|Action!}}==

DEFINE COL_COUNT="3"

 

PrintE("</body>")

PrintE("</html>")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Create_an_HTML_table.png Screenshot from Atari 8-bit computer]

We define a generic package to output HTML tables:

 

 

generic

procedure Print(Items: Item_Array; Column_Heads: Header_Array);

 

 

The implementation of the package:

 

procedure Print(Items: Item_Array; Column_Heads: Header_Array) is

end Print;

 

 

Here is the main program, using an instance of HTML_Table:

 

 

procedure Test_HTML_Table is

T.Print(Items => The_Table,

Column_Heads => (T.Convert("X"), T.Convert("Y"), T.Convert("Z")));

 

 

Each time you run the program, you get different random values for the table. {{out}}

<thead align = "right">

<tr><th></th><td>X</td><td>Y</td><td>Z</td></tr>

<tr><td> 4</td><td> 31</td><td> 6897</td><td> 8265</td></tr>

</tbody>

 

{{out}}

{{trans|ALGOL 68}}

Tested with Agena 2.9.5 Win32

numberedLeft := 1; # " " " " " " "

numberedRight := 2; # " " " " " " "

t.data := [ [ 1001, 1002, 1003 ], [ 21, 22, 23 ], [ 201, 202, 203 ] ];

writeHtmlTable( io.stdout, t )

{{out}}

<table cellspacing='0' colspacing='0' border='1'>

 

=={{header|ALGOL 68}}==

INT numbered left = 1; # " " " " " " #

INT numbered right = 2; # " " " " " " #

headings OF t := ( "A", "B", "C" );

data OF t := ( ( 1001, 1002, 1003 ), ( 21, 22, 23 ), ( 201, 202, 203 ) );

{{out}}

<table cellspacing="0" colspacing="0" border="1">

</table>

 

=={{header|Arturo}}==

 

-> join @["<table>" join @content "</table>"]

 

row 4

row 5

 

{{out}}

=={{header|AutoHotkey}}==

{{trans|C}}

Loop 4

out .= "`r`n<tr><th>" A_Index "</th><td>" Rand() "</td><td>" Rand() "</td><td>" Rand() "</tr>"

Random, n, 1, % u

return n

{{out}}

<table style="text-align:center; border: 1px solid"><th></th><th>X</th><th>Y</th><th>Z</th><tr>

=={{header|AWK}}==

BEGIN {

print "<table>\n <thead align = \"right\">"

}

print " </tbody>\n</table>\n"

{{out}}

<pre><table>

=={{header|Batch File}}==

This will overwrite any file by the name of "table.html" in the current directory.

@echo off

setlocal enabledelayedexpansion

) > table.html

start table.html

{{out}}

<pre>

{{works with|BBC BASIC for Windows}}

Uses BBC BASIC's *spool command to create a file.

nrows% = 4

SYS "ShellExecute", @hwnd%, 0, "temp.htm", 0, 0, 1

{{out}}

<pre>&lt;html&gt;&lt;head&gt;&lt;/head&gt;&lt;body&gt;

<code>Tag</code> is a helper function which encloses the left argument in the right argument tag type.

 

 

<tr><td>0</td><td>1</td><td>2</td><td>3</td></tr>

<tr><td>0</td><td>3</td><td>6</td><td>9</td></tr>

<tr><td>1</td><td>4</td><td>7</td><td>10</td></tr>

<tr><td>2</td><td>5</td><td>8</td><td>11</td></tr>

=={{header|Bracmat}}==

To make this interesting, the table is created as a Bracmat structure and then converted to XML by a library. This has the advantage that one doesn't have to worry about HTML entities and encoding issues. The contents of the cells are generated by a function that is instantiated with a starting number when the function makeTable is called. Notice the absence of loops.

= headTexts

minRowNr

Generator

Table

& ( headCells

= cellText

)

: ?Table

)

& makeTable

)

)

{{out}}

<pre>&lt;table&gt;&lt;thead align="right"&gt;

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

{{out}} (wiki doesn't like tbody/thead tags):<table style="text-align:center; border: 1px solid"><th></th><th>X</th><th>Y</th><th>Z</th><tr><th>0</th><td>2777</td><td>886</td><td>9383</td></tr><tr><th>1</th><td>8335</td><td>7793</td><td>6915</td></tr><tr><th>2</th><td>6649</td><td>492</td><td>5386</td></tr><tr><th>3</th><td>27</td><td>2362</td><td>1421</td></tr></table>

 

=={{header|C sharp|C#}}==

using System.Text;

 

}

}

 

=== More modern version ===

using System.Text;

using System.Xml;

}

}

 

=={{header|C++}}==

#include <boost/array.hpp>

#include <string>

htmltable.close( ) ;

return 0 ;

{{out}} ( of testtable.html ):

<head></head>

<body>

</body>

</html>

 

=={{header|Clojure}}==

Using Hiccup (https://github.com/weavejester/hiccup):

(:use 'hiccup.core))

 

(<tr> :th ["" \X \Y \Z])

(for [n (range 1 4)]

 

=={{header|CoffeeScript}}==

# This is one of many ways to create a table. CoffeeScript plays nice

# with any templating solution built for JavaScript, and of course you

html = table header_row, rows

console.log html

 

{{out}}

 

=={{header|COBOL}}==

IDENTIFICATION DIVISION.

PROGRAM-ID. Table.

END-PROGRAM.

 

=={{header|Common Lisp}}==

Using Closure-HTML (https://common-lisp.net/project/closure/closure-html/) installed by the code itself via QuickLisp (http://quicklisp.org/).

 

(ql:quickload :closure-html)

(use-package :closure-html)

,@(loop repeat 3 collect `(td nil ,(format nil "~a" (random 10000)))))))

(make-string-sink))

 

{{out}}

=={{header|D}}==

{{trans|C}}

import std.stdio, std.random;

 

i, uniform(0,1000), uniform(0,1000), uniform(0,1000));

writeln("</table>");

{{out}}

<table style="text-align:center; border: 1px solid">

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln('</table>');

Readln;

 

{{out}}

<tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>

<tr><td>1</td><td>7371</td><td>2659</td><td>1393</td></tr>

<tr><td>3</td><td>1316</td><td>1599</td><td>2086</td></tr>

<tr><td>4</td><td>4785</td><td>6612</td><td>5042</td></tr>

 

=={{header|EchoLisp}}==

;; styles -

(style 'td "text-align:right")

(for ((i 1000)(row (rest table))) (emit-tag 'tr h-row (cons i row))))

{{out}}

(define my-table '(("" X Y Z) (-1111 111 11) (22 -222 2222) (4422 0 42) (33 333 3333) (6666 666 66)))

 

(emit-tag 'table h-table my-table)

(string-join (stack->list html) " ")

 

<table style='border-spacing: 10px;border:1px solid red'> <table style='border-spacing: 10px;border:1px solid red'> <tr style='undefined'> <th style='color:blue;'> </th> <th style='color:blue;'> X </th> <th style='color:blue;'> Y </th> <th style='color:blue;'> Z </th> </tr> <tr style='undefined'> <td style='text-align:right'> 0 </td> <td style='text-align:right'> -1111 </td> <td style='text-align:right'> 111 </td> <td style='text-align:right'> 11 </td> </tr> <tr style='undefined'> <td style='text-align:right'> 1 </td> <td style='text-align:right'> 22 </td> <td style='text-align:right'> -222 </td> <td style='text-align:right'> 2222 </td> </tr> <tr style='undefined'> <td style='text-align:right'> 2 </td> <td style='text-align:right'> 4422 </td> <td style='text-align:right'> 0 </td> <td style='text-align:right'> 42 </td> </tr> <tr style='undefined'> <td style='text-align:right'> 3 </td> <td style='text-align:right'> 33 </td> <td style='text-align:right'> 333 </td> <td style='text-align:right'> 3333 </td> </tr> <tr style='undefined'> <td style='text-align:right'> 4 </td> <td style='text-align:right'> 6666 </td> <td style='text-align:right'> 666 </td> <td style='text-align:right'> 66 </td> </tr> </table>

=={{header|Elixir}}==

 

defp put_rows(n) do

Enum.map_join(1..n, fn i ->

end

 

 

{{out}}

<th></th><th>X</th><th>Y</th><th>Z</th>

<tr align=right><th>1</th><td>1362</td><td>1289</td><td>357</td></tr>

<tr align=right><th>2</th><td>1161</td><td>1345</td><td>1176</td></tr>

<tr align=right><th>3</th><td>391</td><td>62</td><td>609</td></tr>

 

{{out}}

=={{header|Erlang}}==

Both external_format/1 and html_table/3 are used by [[CSV_to_HTML_translation]]. Keep backwards compatibility when changing or change both.

-module( create_html_table ).

 

 

remove_quoutes( String ) -> lists:flatten( string:tokens(String, "\"") ).

{{out}}

<table border=1 cellpadding=10><tr><th> </th><th>X</th><th>Y</th><th>Z</th></tr><tr><td>1</td><td>6</td><td>563</td><td>476</td></tr><tr><td>2</td><td>401</td><td>310</td><td>59</td></tr><tr><td>3</td><td>579</td><td>990</td><td>331</td></tr></table>

 

=={{header|Euphoria}}==

puts(1," <tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>\n")

for i = 1 to 3 do

puts(1,"</tr>\n")

end for

 

{{out}}

<tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>

<tr><td>1</td><td>7978</td><td>7376</td><td>2382</td></tr>

<tr><td>2</td><td>3632</td><td>1947</td><td>8900</td></tr>

<tr><td>3</td><td>4098</td><td>1563</td><td>2762</td></tr>

 

=={{header|F_Sharp|F#}}==

 

type XmlDocument with

let xw = new XmlTextWriter(System.Console.Out)

xw.Formatting <- Formatting.Indented

{{out}}

(table part only)

 

=={{header|Factor}}==

 

: rnd ( -- n ) 10,000 random ;

${ 3 rnd rnd rnd }

}

{{out}}

<tr>

<td valign="top" style="border: 1px solid #cccccc; padding: 2px; ">

</tr>

</table>

 

=={{header|Forth}}==

Although this example is not a complete HTML interpreter, with these few extensions we can demonstrate mixing HTML tags with Forth code to generate the specified random numbers in-line with HTML. We could even use Forth to compile tags together and make HTML generating sub-routines like NETREXX does.

 

 

\ parser routines

</tr>

</table>

{{Output}}

<pre>

 

===Source===

MODULE PARAMETERS !Assorted oddities that assorted routines pick and choose from.

CHARACTER*5 I AM !Assuage finicky compilers.

CALL HTMLSTOP

END

===Output===

As yet another demonstration of the vagaries of text interpretation, notice that the blank column heading, carefully converted to nbsp; (no leading ampersand here!) does ''not'' appear when the page is displayed, despite the "pre-formatted" hint.

 

=={{header|FreeBASIC}}==

Dim As Integer col, row

 

Print "</table>"

Print "</body>" & Chr(10) & "</html>"

 

 

 

=={{header|FutureBasic}}==

include "NSLog.incl"

 

 

local fn BuildHTMLTable

end fn

 

 

HandleEvents

{{ HTML code output:}}

<pre>

=={{header|Go}}==

html/template is a package in the standard library.

 

import (

fmt.Println(err)

}

{{out}}

<tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>

<tr><td>0</td><td>0</td><td>1</td><td>2</td></tr>

<tr><td>2</td><td>6</td><td>7</td><td>8</td></tr>

<tr><td>3</td><td>9</td><td>10</td><td>11</td></tr>

 

=={{header|Groovy}}==

 

def createTable(columns, rowCount) {

}

 

{{out}}

<table style='border:1px solid;text-align:center;'>

{{libheader|blaze-html}}

 

import Control.Monad (forM_)

 

main = do

g <- getStdGen

 

Or using the Shakespeare templates from the Yesod web framework.

{{libheader|shakespeare}}

 

import Data.List (elemIndex)

rowsOf _ [] = []

rowsOf n xs = take n xs : rowsOf n (drop n xs)

 

=={{header|Icon}} and {{header|Unicon}}==

printf("<table>\n <tr><th></th><th>X</th><th>Y</th><th>Z</th>")

every r := 1 to 4 do {

end

 

 

{{libheader|Icon Programming Library}}

 

{{out}}

<tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>

<tr><td>1</td><td>3129</td><td>3294</td><td>7013</td></tr>

<tr><td>3</td><td>7001</td><td>963</td><td>4183</td></tr>

<tr><td>4</td><td>1695</td><td>1158</td><td>1240</td></tr>

 

=={{header|J}}==

We can define:

 

nm=. x-.LF

lf=. x-.nm

rows=. 'td' <@ele"1 ":&.>y

'table' ele ('tr',LF) <@ele ('th' ele x); rows

 

With these definitions:

 

<table><tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>

<tr><td>0</td><td>0</td><td>1</td><td>2</td></tr>

<tr><td>3</td><td>9</td><td>10</td><td>11</td></tr>

<tr><td>4</td><td>12</td><td>13</td><td>14</td></tr>

 

Or, if running under jhs:

 

 

to display the table inline, as html.

 

=={{header|Java}}==

{{works with|Java|1.5+}}

This example assumes the header row is the first row in the given array and does not add row numbers. They will need to be added by the programmer when constructing the array.

 

public static String array2HTML(Object[][] array){

System.out.println(array2HTML(ints));

}

{{out}}

 

=={{header|JavaScript}}==

===Iterative===

 

// normally, don't do this: at least name it something other than "a"

}

</script></head>

 

===Functional===

:#fold a more general HTML rendering function over a data tree.

 

'use strict';

 

// MAIN ---

return main();

{{Out}}

 

=={{header|jq}}==

{{works with|jq|1.4}}

"<tr>",

" \(.[] | "<td>\(.)</td>")",

length as $length

| . as $in

 

'''Example'''

[ [4,5,6],

[41, 51, 61],

 

# The first column has no header

{{out}}

<table>

<thead align = 'right'>

</tr>

</tbody

 

=={{header|Julia}}==

t, b = x

attrstr = join(" $n=\"$p\"" for (n, p) in attr)

body = "\n" * join(rows, '\n') * "\n"

table = tag(:table => string('\n', header, body, '\n'), :style => "width: 60%")

 

{{out}}

 

'''The raw html:'''

<th></th><th>X</th><th>Y</th><th>Z</th>

 

<tr><td style="font-weight: bold;">6</td><td>3896</td><td>9827</td><td>7006</td></tr>

 

 

=={{header|Kotlin}}==

 

import java.util.Random

}

println(sb.toString())

 

{{out}}

Sample output:

<head>

<style>

</table>

</body>

 

=={{header|Lambdatalk}}==

Lambdatalk outputs standard HTML/CSS code sent to the web browser who does the job.

 

{table

{@ style="background:#ffe; width:50%;"}

{serie 1 3}}}}

{serie 1 3}}}

 

{{out}}

 

=={{header|Lasso}}==

 

local(

#output -> append('</table>\n')

 

{{out}}

<table border=2 cellpadding=5 cellspace=0>

<br>

A time delay is needed to allow this, then the file is deleted.

nomainwin

 

end

end sub

 

=={{header|Lingo}}==

str = "<table>"

 

put "</table>" after str

return str

 

["X", "Y", "Z"],\

["1", "2", "3"],\

-- render the result in a text member (which only supports simple/ancient HTML)

m = new(#text)

 

=={{header|Lua}}==

This function is written so as to take arbitrary table data. Its argument is a (Lua) table of (Lua) tables, where each sub-table is one row of the HTML table. The first row is assumed to be the column headings.

local html = "<table>\n<tr>\n<th></th>\n"

for _, heading in pairs(data[1]) do

}

 

{{out}}

<pre><table>

 

=={{header|M2000 Interpreter}}==

MODULE HtmlTable {

tag$=LAMBDA$ (a$)-> {

}

HtmlTable

 

{{out}}

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Print["<table>", "\n","<tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>"]

Scan[Print["<tr><td>", #, "</td><td>", x, "</td><td>", x, "</td><td>","</td></tr>"] & , Range[3]]

 

{{out}}

=={{header|MATLAB}} / {{header|Octave}}==

fprintf(fid,'<table>\n <thead align = "right">\n');

if nargin<3,

fprintf(fid,' <tr><td>%2i</td><td>%5i</td><td>%5i</td><td>%5i</td></tr>\n', [1:size(table,1);table']);

fprintf(fid,' </tbody>\n</table>\n');

 

{{out}}

 

=={{header|Modula-2}}==

 

FROM InOut IMPORT WriteCard, WriteLn, WriteString, WriteBf;

WriteLn;

WriteBf

 

=={{header|Modula-3}}==

{{trans|C}}

 

IMPORT IO, Random;

END;

END;

 

=={{header|Nanoquery}}==

{{trans|Ursa}}

This program outputs the HTML table to the console.

 

random = new(Random)

end for

 

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

return html

 

{{out}}

<div style="height:80ex;overflow:scroll;">

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" lang="en-US" xml:lang="en-US">

</body>

</html>

</div>

{{out}}

 

=={{header|NewLISP}}==

; url: http://rosettacode.org/wiki/Create_an_HTML_table

; author: oofoe 2012-01-29

))

 

 

{{out}}

 

=={{header|Nim}}==

randomize()

 

randTR 3,

randTR 4,

{{out}}

<table><tr><th></th><th>X</th><th>Y</th><th>Z</th></tr><tr><td style="font-weight: bold">1</td><td>8815</td><td>5115</td><td>9452</td></tr><tr><td style="font-weight: bold">2</td><td>5048</td><td>5694</td><td>6610</td></tr><tr><td style="font-weight: bold">3</td><td>6163</td><td>4598</td><td>9015</td></tr><tr><td style="font-weight: bold">4</td><td>5638</td><td>8679</td><td>3994</td></tr><tr><td style="font-weight: bold">5</td><td>1515</td><td>1822</td><td>4020</td></tr></table>

 

=={{header|Objeck}}==

class CreateTable {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

A simple <code>printf</code> method:

 

let buf = Buffer.create 1 in

let s = Buffer.add_string buf in

s "</tbody>";

s "</table>";

 

=== With a dedicated library ===

Using the library [http://theorie.physik.uni-wuerzburg.de/~ohl/xhtml/ ocaml-xhtml]. With this library the validity of the pages is guaranteed by the OCaml type system.

 

 

let _td s = td [pcdata s]

 

let () =

 

=== TyXml ===

The library [http://ocsigen.org/tyxml/ TyXml] contains a module for XHTML that provides the same interface than the previous <code>ocaml-xhtml</code> library.

 

#require "tyxml"

 

let my_html = X.html my_head my_body in

P.print print_endline my_html;

 

The previous function <code>make_table ()</code> produces a simple table, we can replace it by the function below to output a more complex table with <code>thead</code> and <code>tbody</code>:

 

let br = X.a_border 1 in

let th s = X.th [X.pcdata s] in

let my_tbody = X.tbody my_tr1 [my_tr2; my_tr3] in

let my_table = X.tablex ~thead:my_thead ~a:[br] my_tbody [] in

 

=={{header|Oz}}==

As a complete web application, using the [https://github.com/wmeyer/roads/wiki "Roads"] web programming library. Connect your browser to http://localhost:8080/table after starting the program.

 

[Roads] = {Module.link ['x-ozlib://wmeyer/roads/Roads.ozf']}

 

{Roads.registerFunction table Table}

 

=={{header|PARI/GP}}==

print("<table>\n<tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>");

for(i=1,n,

);

print("</table>")

{{out}}

<pre><table>

 

Note also the built-in <code>printtex</code> command, which allows the analogous task to be written as

 

=={{header|Pascal}}==

Opcodes of interest: SDC -- simple document; R!I -- ranged random integer

 

<@ DTBLIT>

<@ DTRLITLIT>

</@>

</@>

 

=={{header|Perl}}==

my $rows = 5;

print '<table><thead><td>',

}

 

Note that this is a rather inane way (because of the inane task specification) of generating structured document. For serious work, one should use a module such as XML or HTML for well-formedness instead of this ad hoc method.

 

{{libheader|Phix/basics}}

===plain text approach===

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&lt;table border=2&gt;\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" &lt;tr&gt;&lt;th&gt;&lt;/th&gt;"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&lt;/table&gt;"</span><span style="color: #0000FF;">)</span>

{{out}}

<table border=2>

 

===more structured===

<span style="color: #008080;">include</span> <span style="color: #000000;">xml<span style="color: #0000FF;">.<span style="color: #000000;">e</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">contents</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #0000FF;">}</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">doc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xml_new_doc<span style="color: #0000FF;">(<span style="color: #000000;">table<span style="color: #0000FF;">,<span style="color: #008000;">""<span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">puts<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #7060A8;">xml_sprint<span style="color: #0000FF;">(<span style="color: #000000;">doc<span style="color: #0000FF;">)<span style="color: #0000FF;">)

{{out}}

<table border="2">

 

=== normal style ===

/**

* @author Elad Yosifon

 

echo $html;

 

=== template engine style ===

/**

* @author Elad Yosifon

</body>

</html>

 

=={{header|PicoLisp}}==

 

(<table> NIL NIL '(NIL (NIL "X") (NIL "Y") (NIL "Z"))

(for N 3

 

=={{header|PL/I}}==

/* Create an HTML table. 6/2011 */

 

call create_table (headings, table_contents);

 

 

=={{header|PowerShell}}==

# Converts Microsoft .NET Framework objects into HTML that can be displayed in a Web browser.

ConvertTo-Html -inputobject (Get-Date)

 

$object | ConvertTo-Html

{{out}}

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

</table>

</body></html>

 

When raw results are exported to Out-File cmdlet like this:

$object | ConvertTo-Html | Out-File -FilePath $env:temp\test.html ; invoke-item $env:temp\test.html

 

{{out}}

 

=={{header|Prolog}}==

:- use_module(library(http/html_write)).

 

],

phrase(html(table([tr(\theader(Header)), \trows(Rows,1)])), Out, []),

 

<tr><th>X</th><th>Y</th><th>Z</th></tr>

<tr><td>1</td><td>7055</td><td>5334</td><td>5795</td></tr>

<tr><td>3</td><td>140</td><td>7607</td><td>8144</td></tr>

<tr><td>4</td><td>7090</td><td>475</td><td>4140</td></tr>

 

=={{header|PureBasic}}==

</font>

 

Title.s="Create an HTML table"

 

 

; RunProgram(FileName.s)

 

{{out}}

'''The raw HTML'''

 

<html><head><title>Create an HTML table</title></head><body>

<table border=1 cellpadding=10 cellspacing=0>

</table>

</body></html>

 

=={{header|Python}}==

import random

 

for i in range(1, 6))

table = tag(table='\n' + header + rows + '\n')

 

{{out}}

 

'''The raw HTML'''

<tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>

<tr><td style="font-weight: bold;">1</td><td>6040</td><td>4697</td><td>7055</td></tr>

<tr><td style="font-weight: bold;">4</td><td>5313</td><td>4396</td><td>1765</td></tr>

<tr><td style="font-weight: bold;">5</td><td>4013</td><td>5924</td><td>6082</td></tr>

 

 

{{Trans|JavaScript}}

{{works with|Python|3.6}}

import itertools

import random

 

if __name__ == '__main__':

 

{{Out}}

 

Raw HTML output

<caption>Table generated with Python</caption>

<tr>

<td>8882</td>

</tr>

 

=={{header|Racket}}==

 

#lang racket

 

 

(display-xml/content (xexpr->xml xexpr))

 

=={{header|Raku}}==

This is certainly not the only or best way to generate HTML tables using Raku; just an example of one possible method.

 

my $rows = 5;

 

}

 

 

{{out}}

 

=={{header|Rascal}}==

import util::Math;

 

html("Rosetta Code Table", table(rows)));

return "written";

 

This will result in a simple html file. For example:

 

 

{{out}}

 

{{out}}

 

=={{header|Red}}==

 

Create an HTML table

newline contents newline "</" tag ">"]]

 

 

=={{header|Retro}}==

Using the '''casket::html'''' library which allows creation of HTML using quotes and combinators:

 

with casket::html'

 

[ [ "5" ] td [ rnd ] td [ rnd ] td [ rnd ] td ] tr

[ [ "6" ] td [ rnd ] td [ rnd ] td [ rnd ] td ] tr

 

=={{header|REXX}}==

<br>makes reading the file easier and also helps in debugging, &nbsp; but they could've been combined into a

<br>single &nbsp; '''lineout''' &nbsp; for succinctness.

parse arg rows . /*obtain optional argument from the CL.*/

if rows=='' | rows=="," then rows=5 /*no ROWS specified? Then use default.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

rnd: return right(random(0,maxRand*2)-maxRand,5) /*RANDOM doesn't generate negative ints*/

{{out|output|text=&nbsp; to the terminal (screen) using the default input of &nbsp; <tt> 5 </tt> &nbsp; rows:}}

<pre>

 

=={{header|Ring}}==

# Project: Create an HTML table

see str + nl

systemcmd("temp.htm")

Output:

<pre>

Pure Ruby solution:

 

def r

rand(10000)

html << "</table>"

end

 

 

 

{{libheader|REXML}}

table = [["", "X", "Y", "Z"],

[ 1, r, r, r],

formatter = REXML::Formatters::Pretty.new

formatter.compact = true

 

{{out}}

<tr>

<td></td>

<td>9849</td>

</tr>

 

<table>

 

=={{header|Run BASIC}}==

for i = 1 to 5

html "<tr align=right>"

html "</tr>"

next i

 

{{out}}

=={{header|Rust}}==

{{libheader|rand|0.3}}

 

use rand::Rng;

 

println!("</table>");

 

{{out}}

<tr><th>0</th><td>7101</td><td>9111</td><td>3446</td></tr>

<tr><th>1</th><td>426</td><td>9518</td><td>611</td></tr>

<tr><th>2</th><td>9693</td><td>419</td><td>4878</td></tr>

 

=={{header|Scala}}==

val data = List(List("X", "Y", "Z"), List(11, 12, 13), List(12, 22, 23), List(13, 32, 33))

 

 

println(generateTable(data))

 

=={{header|Scheme}}==

#("" "X" "Y" "Z")

#(1 1 2 3)

(display "</td>")))

(display "</tr>"))

 

=={{header|Seed7}}==

 

const proc: main is func

end for;

writeln("</table>")

 

{{out}}

 

=={{header|Sidef}}==

method _attr(Hash h) {

h.keys.sort.map {|k| %Q' #{k}="#{h{k}}"' }.join('')

)

}...

 

{{out}}

 

=={{header|Snobol4}}==

output = "<table>"

output = " <tr><th></th><th>X</th><th>Y</th><th>Z</th></tr>"

end

 

{{out}}

<pre><table>

 

 

* val mkHtmlTable : ('a list * 'b list) -> ('a -> string * 'b -> string)

* -> (('a * 'b) -> string) -> string

(fn (a, b) => Real.toString (Math.pow (a, b))))

 

 

{{out}}

First, a program to write a Stata matrix to an HTML file.

 

local nr = rowsof(`1')

local nc = colsof(`1')

file write `f' "</html>" _n

file close `f'

 

An example:

 

matrix rownames a = A B C

matrix colnames a = X Y Z

 

=={{header|Tcl}}==

proc TAG {name args} {

set body [lindex $args end]

}]

}]

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

tablefile="table.html"

ENDACCESS d

BROWSE $tablefile

{{out}}

<pre style='height:30ex;overflow:scroll'>

=={{header|UNIX Shell}}==

{{works with|ksh93}}

nameref d=$1

typeset -i idx=0

done

 

{{out}}

<pre><table>

=={{header|Ursa}}==

This program outputs the HTML table to the console.

 

out "<table>" endl console

end for

 

 

=={{header|VBA}}==

Public Sub BuildHTMLTable()

'simple HTML table, represented as a string matrix "cells"

HTMLWrap = sOpenTag & s & sClosingTag

End Function

 

Subroutine BuildHTMLTable builds the HTML code as one big string.

 

=={{header|VBScript}}==

Set objFSO = CreateObject("Scripting.FileSystemObject")

 

objOutHTML.Close

Set objFSO = Nothing

 

{{In}}

=={{header|Visual Basic .NET}}==

VB.NET has XML literals with embedded expressions (<%= ... %>) similar to [[#Scala|Scala]]. This example additionally uses LINQ query syntax.

Sub Main()

Const ROWS = 3

Console.WriteLine(result)

End Sub

 

{{out}}

 

Since embedded expressions must contain expressions, anonymous iterator functions that are immediately called (notice the parentheses after End Function) are used to enable control constructs.

Sub Main()

Dim rand As Func(Of Integer, Integer) = AddressOf New Random(0).Next

Console.WriteLine(result)

End Sub

 

{{out}}

 

A more idiomatic version that uses LINQ instead of loops:

Sub Main()

Dim rand As Func(Of Integer, Integer) = AddressOf New Random(0).Next

Console.WriteLine(result)

End Sub

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var r = Random.new()

sb = sb + "</table>\n"

sb = sb + "</body>\n</html>"

 

{{out}}

</html>

</pre>

 

=={{header|XSLT}}==

 

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:output method="html" version="4.01" indent="yes"/>

</tr>

</xsl:template>

 

XSLT does not have a standard PRNG facility, so a list of numbers is given as input.

Sample input:

 

<numbers>

<number>1578</number>

<number>1403</number>

<number>4637</number>

 

{{out}}

<html>

<head>

</tr>

</table></body>

 

{{out}}

 

=={{header|zkl}}==

"<th></th><th>X</th><th>Y</th><th>Z</th><tr>";

table=Sink(table);

table.write("</tr>");

}

{{out}}

<table style="text-align:center; border: 1px solid"><th></th><th>X</th><th>Y</th><th>Z</th><tr>