• Iteraattorille voi myös itse ohjelmoida etenemisen logiikan.

• Esimerkkinä kokonaislukuväli (MDN:n esimerkki):

  // Määritellään kokonaislukuväliä esittävä olio:
  function Range(low, high){
    this.low = low;
    this.high = high;
  }
  
  // Laaditaan iteraattori, joka antaa yksitellen kokonaislukuvälin luvut:
  function RangeIterator(range){
    this.range = range;
    this.current = this.range.low;
  }
  RangeIterator.prototype.next = function(){
    if (this.current > this.range.high)
      throw StopIteration;
    else
      return this.current++;
  }
  
  // Asetetaan Range.prototype.__iterator__-kentän
  // arvoksi funktio, joka palauttaa arvonaan uuden iteraattoriolion:
  Range.prototype.__iterator__ = function(){
    return new RangeIterator(this);
  };
  
  // Ja eikun hommiin:
  var range = new Range(3, 7);
  for (let i in range)
    write(i);         // 3, 4, 5, 6, 7
  

• Pakko myöntää, että tällainen tapa rakentaa iterointilogiikka on kiusallisen kimurantti. En suostu edes mielessäni piirtämään tässä syntyvää "assosiaatiolistojen verkkoa"... ;-)

• Ehkäpä generaattoreista saadaan apu?

**************** päivitysraja *****************

• Generaattori sisältää yhden tai useamman yield-lauseen, jolla ilmaistaan next()-kutsun seuraava palautusarvo. Kun generaattorifunktion algoritmi päättyy tai kun se suorittaa return-lauseen, heitetään poikkeus StopIteration. (yield on ollut käytettävissä kielen versiosta 1.7 alkaen.)

• Ensimmäisenä esimerkkinä kokonaislukujen joukon (sic!) generoiva generaattori:

  function N() {
    for (let i=0; true; ++i) 
     yield i
  }
  
  var luvut = new N()
  
  write(luvut.next())   // 0
  write(luvut.next())   // 1
  write(luvut.next())   // 2
  
  var toiset = new N()
  
  write(toiset.next())  // 0
  write(toiset.next())  // 1
  write(luvut.next())  // 3
  

• Fibonaccin lukujonon generointi voidaan ohjelmoida vaikka tähän tyyliin:

  function Fibo() {
    var luku=1, seuraava=1;
    while (true) {
      yield luku
      var summa=luku+seuraava
      luku=seuraava
      seuraava=summa
    } 
  }
  var luvut = new Fibo()
  for (var i=0; i<10; ++i)
    write(luvut.next())         // 1,1,2,3,5,8,13,21,34,55
  

• Generoidaan sitten kokonaislukuja annettuun ylärajaan saakka. Ohjelmoidaan MDN:n tyyliin asettamalla generaattori kenttään prototype.__iterator__ seuraavaan tapaan. Tässä generoidaan kokonaislukuja annettuun ylärajaan saakka:

  function N(yla) {
    this.yla = yla
  }
  
  N.prototype.__iterator__ =
    function(yla) {for (let i=0; i<this.yla; ++i) 
                     yield i
                  }
  
  var luvut = new N(10)
  
  for (var i in luvut) write(i)  // 1,2,3,4,5,6,7,8,9
  

• En onnistu vaivatta näkemään, miksi MDN haluaa liittää generaattorin noin hankalaan paikkaan. Miksei vain:

  function N(yla) {
    for (let i=0; i<yla; ++i) 
     yield i
  }
  
  var x = new N(10)
  var y = new N(4)
  
  write(x.next()) // 0
  write(x.next()) // 1
  write(x.next()) // 2
  
  write(y.next()) // 0
  write(y.next()) // 1
  
  for (let a in x) write(a)  // 3,4,5,6,7,8,9
  for (let a in y) write(a)  // 2,3
  
  

• Edellä nähty Range voidaan ohjelmoida helpommin (MDN):

  function Range(low, high) {
    this.low = low;
    this.high = high;
  }
  Range.prototype.__iterator__ = function() {
    for (var i = this.low; i <= this.high; i++)
      yield i;
  }
  var range = new Range(3, 5);
  for (var i in range)
    write(i);            // 3 4 5
  

• Minua houkuttaisi ohjelmoida sama vieläkin vaivattomammin:

  function Range(low, high) {
    for (var i = low; i <= high; i++)
      yield i;
  }
  
  var range = new Range(3, 5);
  for (var i in range)
    write(i);            // 3 4 5
  

• Varoitus: Luultavasti MDN:llä on menettelyynsä jokin erittäin hyvä syy, jota minä vain en näe. Syy saattaa liittyä perintään tai joihinkin esimerkkejä monimutkaisimpiin tilanteisiin.

• Huomautus: Luennolla 26.11. tuli esiin yksi hyvä perustelu tuolle MDN:n hankalan näköiselle menettelylle. Jos iteraattoreita samaan rakenteeseen tarvitaan useita tai edes muutamia jos iteraattorin algoritmi on hyvin iso, MDN:n tapa tuottaa vain yhden jaetun funktion. Käytännössä kuitenkin tällainen tilanne lienee hyvin poikkeuksellinen; iterointialgorimit harvoin vievät paljon tilaa ja harvoin niitä samaan rakenteeseen tarvitaan kovin monta.

• Huomautus: Luennolla 5.12. tuli esiin toinen hyvä perustelu tuolle MDN:n menettelylle:

  MDN:n tapaan ohjelmoidessa generaattori osaa aloittaa uudelleen alusta:

  function Range(low, high) {
    this.low = low;
    this.high = high;
  }
  Range.prototype.__iterator__ = function() {
    for (var i = this.low; i <= this.high; i++)
      yield i;
  }
  var range = new Range(3, 5);
  for (var i in range)
    write(i);            // 3 4 5
  for (var i in range)
    write(i)             // 3 4 5     UUDELLEEN ALUSTA!
  

  Minun tavallani ohjelmoiden generaattorin "sormi" jää lopputilaan:

  function Range(low, high) {
    for (var i = low; i <= high; i++)
      yield i;
  }
  
  var range = new Range(3, 5);
  for (var i in range)
    write(i);            // 3 4 5
  
  for (var i in range)
    write(i);            //