Overview
Consider the inbuilt Wolfram Mathematica functions of Map, Table, and For. Each can be used to execute an expression sequentially over a dataset. The strict definitions of each lies below.

Map

Map is described in the Wolfram Mathematica references as follows.
In[]:=
?Map
Out[]=
Symbol
Map[f,expr] or f/@expr applies f to each element on the first level in expr. ​Map[f,expr,levelspec] applies f to parts of expr specified by levelspec. ​Map[f] represents an operator form of Map that can be applied to an expression.

Table

Table is described in the Wolfram Mathematica references as follows.
In[]:=
?Table
Out[]=
Symbol
Table[expr,n] generates a list of n copies of expr. ​Table[expr,{i,
i
max
}] generates a list of the values of expr when i runs from 1 to
i
max
. ​Table[expr,{i,
i
min
,
i
max
}] starts with i=
i
min
. ​Table[expr,{i,
i
min
,
i
max
,di}] uses steps di. ​Table[expr,{i,{
i
1
,
i
2
,…}}] uses the successive values
i
1
​,
i
2
​, ….​Table[expr,{i,
i
min
,
i
max
},{j,
j
min
,
j
max
},…] gives a nested list. The list associated with i is outermost.

For

For is described in the Wolfram Mathematica references as follows.
In[]:=
?For
Out[]=
Symbol
For[start,test,incr,body] executes start​, then repeatedly evaluates body and incr until test fails to give True.
Basic Systematic Comparison
Most basic definitions
For a basic comparison, and the simplest chart, we will consider the most general definitions of Map, Table, and For.
That is,
◼
  • Map
    • Map[f, expr] or f /@ expr applies f to each element on the first level in expr
    ◼
  • Table
    • Table[expr, n] generates a list of n copies of expr.
    ◼
  • For
    • For[ start, test, incr, body] executes start, then repeatedly evaluates body and incr until test fails to give True
    Chart
    In[]:=
    Clear[mapAssociation,tableAssociation,forAssociation];​​mapAssociation=Association["Name"->"Map",​​"Arguments"->"function, expression",​​"Output Format"->"Format of the expression, TypeOf[expr]",​​"Calculation performed _N_ times"->"_N_ is size of expression"​​];​​tableAssociation=Association["Name"->"Table",​​"Arguments"->"expression, n",​​"Output Format"->"List of size n",​​"Calculation performed _N_ times"->"_N_ is n"​​];​​forAssociation=Association["Name"->"For",​​"Arguments"->"start, test, increment, body",​​"Output Format"->"Null. Only executes unless body returns",​​"Calculation performed _N_ times"->"_N_ is determined by start, test, & increment"​​];​​​​contents=Dataset[{mapAssociation,tableAssociation,forAssociation}];​​​​contents[[All,{1,2,3}]]​​contents[[All,{1,4}]]
    Out[]=
    Name
    Arguments
    Output Format
    Map
    function, expression
    Format of the expression, TypeOf[expr]
    Table
    expression, n
    List of size n
    For
    start, test, increment, body
    Null. Only executes unless body returns
    Out[]=
    Name
    Calculation performed _N_ times
    Map
    _N_ is size of expression
    Table
    _N_ is n
    For
    _N_ is determined by start, test, & increment
    Further Thoughts
    All of the functions examined, Map, Table, and For, can apply a set of operations repeatedly over a dataset.
    ​
    If one wishes to apply a function to an existing dataset, Map would work well.
    If one wishes to evaluate an expression n times, Table works well.
    If one wishes to perform a set of operations repeatedly until a certain set of stopping conditions is met, For loops work well.

    ​