Newsgroup: it.comp.lang.visual-basic
Titolo: Dove sbaglio??

 Dovresti intanto capire cosa significa While: Fintanto che...
    Facciamo "Intanto che"?... Alias "Mentre"? Perche' quel tuo "Fin*"
"ambiguizza"...
--
Ciao :o))))
Maurizio
--------
?SPQR(C)
 X
--------

 Cazzo, come si legge mille volte meglio!!!
in questo caso non è tanto il problema del while o dell'until: è proprio una
questione di algebra booleana, che qualche volta trae, oserei dire
"semanticamente", in inganno.
Cioè: leggendo la "formula" in linguaggio "naturale" sembra che dica esattamente
il contrario di quello che realmente fa.
comunque io avrei scritto
do until RetryCount > 10 or Found = true
tanto per fare il bastian contrario, ovviamente :-)
--
Salutoni
Sergio

 tanto per fare il bastian contrario, ovviamente :-)
io per aumentare il caos :
do
    ...
loop until RetryCount > 10 or Found = true
! Che bei tempi quelli del turbopasQual !
"Repeat
     codice
until qualcosa"
e poi il mitico ^_^
"Repeat until keypressed"
bei tempi !

 "ambiguizza"...
While = Finchè
Finchè Found è falso
    Cerca
Riprova

 comunque io avrei scritto
A me non pare proprio, anzi, č l'until che viaggia al contrario.
Finchč (fino a quando) RetryCount č inferiore a 10 e Found č Falso ...
mi sembra molto piů lineare di
Finchč RetryCount non č maggiore di 10 oppure Found non č falso (perchč č
cosě che si leggerebbe il "vero" in questo caso) ...
Molto piů macchinoso per la mente elaborare le negazioni.
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 Riprova
--
Ciao :o)


 e' cambiato qualcosa?...
Until io lo leggo come "A meno che"...

         Until = Finché.
Non avrebbero tutti lo stesso significato?
While = Mentre, finchč, fintanto che, ... se č cosě
Until = A meno che, ... se non č cosě
Insisto: Bisogna pensarci troppo ogni volta, io i While e gli Until li ho
plonkati da quando li ho letti.
Do
    If ... Then Exit Do
    ...
Loop
FOREVER!!!!!!!!!!!!!!!

 loop until RetryCount > 10 or Found = true
In questo ultimo caso si introduce un altro concetto fondamentale: Cosě il
test (qualunque esso sia) viene eseguito alla fine del ciclo, quindi un
"giro" lo fa comunque, nell'altro caso viene eseguito all'inizio, quindi
potrebbe non eseguire il ciclo nemmeno una volta.
Io sono stufo di urlare: Exit Do FOREVER!!!!!!!!!!!!

 la mente elaborare le negazioni.
Non me lo dire. Io non ho mai sopportato il:
If not rsMyRecordset.NoMatch()
Ciao
*Roby*

 Io sono stufo di urlare: Exit Do FOREVER!!!!!!!!!!!!
bha... ma... ok , allora so entrato qui ( seriamente ) un anno fa , ho
stravolto gran parte del mio modo di scrivere codice , ho quasi eliminato
tutti i "Vizi" del pascal e del basic del C64 come usare i goto a sfascio e
altri vizietti ... ora sti diavolo di exit mi sembrano dei semplici Goto
striminziti ... maronna mia che confusione , io non ho nessunissimo problema
coi cicli , for do until ... (while lo uso poco ) ... se devo uscire dal
ciclo (senza riferimenti mestruali) uso dei goto perche' cosi :
1 e' + leggibile di un Exit qualcosa
2 si capisce a colpo d'occhio dove va a finire e si puo' controllare appunto
dove si possa mandare ... maronna qualche giorno dobbiamo riprendere un 3ad
sull'uso di certi comandi.... per ora : Confusioneeeee ^_^
-- 
<Gigio2K>
Sito Comune
Nokia -> I.T.H.N. -> 
http://www.ithn.it/
VB -> I.C.L.VB -> 
http://www.it-lang-vb.net/

 Molto più macchinoso per la mente elaborare le negazioni.
umm umm ... dissento ^_^
per me e' + facile elaborare cose come :
Fai
    questo
Ripeto finche non si verifica qualcosa
Do
    codice
loop Until X = false or not y
oppure
Fai (le righe seguenti) finche non si verifica qualcosa
  questo
Ripeto
Do until X = false or not Y
    codice
loop
poi ognuno di noi diciamocelo si tira dietro le vecchie abitudini e tira
avanti con i propri costrutti mentali ^_^


 e' cambiato qualcosa?...
While = Mentre = RESTA nel ciclo se la condizione è vera
Until = Sino a quando = ESCE dal ciclo se la condizione è vera
Io comunque uso il costrutto (già proposto da altri)
Do While True
   ' ... eventuali statements
   If condizione1 Then Exit Do  ' >>>
   ' ... eventuali statements
   If condizione2 Then Exit Do  ' >>>
   ' ... eventuali statements
   If condizione3 Then Exit Do  ' >>>
   ' ... eventuali statements
Loop
E' universale e sempre leggibilissimo.
Ciao
pinco_pallo
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 Loop
Cosa che per l'until devi far fare alla mente un triplo carpiato.


 If not rsMyRecordset.NoMatch()
Infatti io faccio
If (rec.NoMatch) then
    condizione se non travato
else
    condizione se trovato
endif
Capita (ma dipende dalla giornata) che faccia anche un
If (rec.NoMatch) then
else
    condizione se trovato
endif
Però qui il Delphi ha ragione!
'equivalente Seek
if (rec.FindKey(...)) then
endif
'equivalente FindFirst
If (rec.Locate(...)) then
endif
Ciao

    Si e' parlato di tante cose in questo thread, di tante cosa ancora
si parlera', se continua. Non voglio fare il figlio dell'oca bianca
tuttavia mi sembra non si sia parlato delle uniche cose da dire: i
fatti. E i fatti sono (-: inconfutabilmente? /:-) questi:
Option Explicit
Private Sub Main()
  Dim b As Boolean, l As Long
  b = False: l = l + 1: Debug.Print l, b
  Do: Debug.Print , b: If b Then Exit Do Else b = Not b
  Loop: Debug.Print
  b = True: l = l + 1: Debug.Print l, b
  Do: Debug.Print , b: If b Then Exit Do Else b = Not b
  Loop: Debug.Print
  b = False: l = l + 1: Debug.Print l, b
  Do: Debug.Print , b: b = Not b: If b Then Exit Do
  Loop: Debug.Print
  b = True: l = l + 1: Debug.Print l, b
  Do: Debug.Print , b: b = Not b: If b Then Exit Do
  Loop: Debug.Print
  b = False: l = l + 1: Debug.Print l, b
  Do While b: Debug.Print , b: b = Not b: Loop
  Debug.Print
  b = True: l = l + 1: Debug.Print l, b
  Do While b: Debug.Print , b: b = Not b: Loop
  Debug.Print
  b = False: l = l + 1: Debug.Print l, b
  Do: Debug.Print , b: b = Not b: Loop While b
  Debug.Print
  b = True: l = l + 1: Debug.Print l, b
  Do: Debug.Print , b: b = Not b: Loop While b
  Debug.Print
  b = False: l = l + 1: Debug.Print l, b
  Do Until b: Debug.Print , b: b = Not b: Loop
  Debug.Print
  b = True: l = l + 1: Debug.Print l, b
  Do Until b: Debug.Print , b: b = Not b: Loop
  Debug.Print
  b = False: l = l + 1: Debug.Print l, b
  Do: Debug.Print , b: b = Not b: Loop Until b
  Debug.Print
  b = True: l = l + 1: Debug.Print l, b
  Do: Debug.Print , b: b = Not b: Loop Until b
  Debug.Print
End Sub
OUTPUT:
 1            Falso
              Falso
              Vero
 2            Vero
              Vero
 3            Falso
              Falso
 4            Vero
              Vero
              Falso
 5            Falso
 6            Vero
              Vero
 7            Falso
              Falso
              Vero
 8            Vero
              Vero
 9            Falso
              Falso
 10           Vero
 11           Falso
              Falso
 12           Vero
              Vero
              Falso
    Da cui deriva che si equivalgono le forme:
        Falso. Falso, Vero : 1, 7
        Vero.  Vero        : 2, 6, 8
        Falso. Falso       : 3, 9, 11
        Vero.  Vero, Falso : 4, 12
        Falso.             : 5
        Vero.              : 10
    (.: Ma con questo cosa volevo dire?... /:-)


 Until = Sino a quando
Questo è appunto il problema. Se consideri Until="Sino a quando", arrivi a
ragionare al contrario:
Cicla SINO A QUANDO condizione.
Quindi, ragioneremmo come un while, non un until.
Until in italiano è orribilmente fraintendibile, perchè è qualcosa del tipo
"FINO A QUANDO NON"
Credo che una delle poche traduzioni che rendono la logica dell'until sia "A
meno che" (l'ha già postato qualcuno, credo...)
Ciao
Alberto

 
Traducendo dall'inglese until vuol dire finché, fino a quando, fin al 
momento che; fino al punto che; prima di
Il ciclo do... until io l'ho sempre pensato come Esegui... fino a quando 
la condizione non è verificata


 
Si in questo caso sarebbe Esegui finchè la condizione è falsa


     (.: Ma con questo cosa volevo dire?... /:-)
Mi sono perso anch'io...


 Si in questo caso sarebbe Esegui finchč la condizione č falsa
Appunto, "a meno che non si verifichi (sia vero) quanto dice il test"...