I read a paper recently that described a new looping construct. This is admittedly pretty weird: we've pretty much settled on looping constructs in imperative languages by now, and with a few exceptions I don't see much change. You've got your while and (increasingly rarely) your do while loop, which moves the test around:

                     cond -> true
-----------------------------------------------------------
  while (cond) { body }   ->   body; while (cond) { body }

          cond -> false
-------------------------------------
  while (cond) { body }   ->   ()


                        cond -> true
------------------------------------------------------------------
  do { body } while (cond)   ->   body; do { body } while (cond)

              cond -> false
------------------------------------------
  do { body } while (cond)   ->   body

We also have the nice scaffolding provided to us by for loops, which are nice sugar for while loops:

for (init, iter, cond) { body } => init; do { body; iter } while (cond)

and we have flavors of foreach loops, which add awareness of some underlying iterator protocol or collection type, which introduces an element of binding

foreach (x in coll) { body } => coll.iter(); while (coll.has_next()) { x = coll.next(); body }