Newsgroup: it.comp.lang.visual-basic
Titolo: Ciclo for

E' possibile fare un ciclo for---next con le lettere dell'alfabeto?
Quello che vorrei ottenere è una cosa del tipo
for i = "a" to "z"
    <operazioni>
    next i
è possibile farlo includendo anche la punteggiatura?
Grazie a tutti


se ti occorrono le lettere, puoi raggirarlo così:
for i = 0 to 25
    txtLettera =  chr(i + 65)    ' dove chr(65) = 'A'
next i
--
www.sepham.com

 Grazie a tutti
La cosa piů elastica (ma non piů rapida) č fare cosě:
strCaratteri="ABCDEFGHIJKLMNOPQRSTUVWXYZ,;.:"
for i=1 to len(strCaratteri)
	debug.print mid(strCaratteri,i,1)	
next
termoPilucco
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 "Jedediah Orne" <lu...@visionsoftware.TOGLIMIit> ha scritto

non sei obbligato a partire da 0
    s=""
    For j = 97 To 122
        s = s & Chr$(j) & " "
    next
    s=left(s, len(s)-1)
ciao, j.

     s=left(s, len(s)-1)
miglioria:
    For I = asc("a") To asc("a")
        c = c & chr(I) & " "
    Next I
ciao!

correzione:
     For I = asc("a") To asc("z")



La tua soluzione č senz'altro quella piů accettabile.
Le altre soluzioni fanno uso di una sottostringa oppure ad ogni ciclo
avviene la conversione del carattere in numero.
=======================================================================
Se mi vuoi scrivere togli le maiuscole
Sveltolampo 
cteniza...@hotmail.com
=======================================================================

 micromillinanosecondi, ma..
sicuramente è più veloce passargli direttamente i numeri, ma era per far
capire a Jedediah Orne da dove venivano e come trovarli (a meno di tabelle e
tabelline...)
ciao!
--
www.sepham.com

 tabelline...)
giusto :)
cmq, consigliabilissimo ascicat
http://ourworld.compuserve.com/homepages/r_harvey/
ciao, j.

 avviene la conversione del carattere in numero.
Non sono per niente d'accordo.
Tra tre mesi aprirà questo codice e dirà " ma che cavolo di numeri sono 97 e
122? Perchè questi numeri e non altri?".
Il calcolo nei valori iniziali e finali in un for viene eseguito solo
all'entrata nel ciclo, quindi il calo di prestazioni è davvero irrisorio.
E poi quando si rilegge il codice, anche da parte di altri, è decisamente
più comprensibile.
Ciao
-- 
NeoDataType : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 sono 97 e  122? Perchč questi numeri e non altri?".
Vabbe', tagliamo la testa al toro:
const lcaseA as byte=97
const lcaseZ as byte=122
For j = lcaseA To lcaseZ
  s = s & Chr$(j) & " "
next
Per quanto riguarda le prestazioni invece tutto dipende dal contesto.


termoPilucco
Sono d'accordo con te che in termini di leggibilità il programma for
asc ... o il tuo for j .. è senz'altro migliore.
Io ragionavo sulla sola for avulsa da qualsiasi altro contesto di
ordine stilistico.
Io facevo semplicemente una considerazione rispetto al fatto che ad
ogni ciclo avvengono le operazioni:
converti il valore di Z in numero e confrontalo con j per vedere se
questo (j) ha superato il valore di Z nel qual caso interrompi.
La tua soluzione ha il vantaggio che avvengono solo due conversioni
(all'inizio) e poi essendo costanti (almeno si spera) che non ci
saranno più conversioni (ma io ho comunque il dubbio).
Le prestazioni qualsivoglia saranno sempre inferiori di un ciclo 
for j = 97 to 122 (costanti numeriche dirette senza conversioni da
fare).


fare).
Come, sopra, non c'è differenza fra "costanti dirette numeriche" e costanti
letterali. Vengono sostituite "on fly" prima di creare l'exe, quindi prima di
eseguirlo :)
termoPilucco

 maldestro principiante.
se ci troviamo a un incrocio, passa pure tranquillo, mi fermo io, perche'
tu non distinguerai stop da pots, e proverai.
stai bene, j.




Siccome sono come "tommaso" sono andato a vedere come sono state
costruite le istruzioni a livello "assembler".
La soluzione con le costanti (quella che hai proposto tu) byte
effettua molte operazioni in più il che sicuramente non giova alla
velocità.
Ecco i frammenti incriminati:
(con costanti)
Private Sub Command1_Click()
    Dim j As Integer
    Dim s As String
    Const lcaseA As Byte = 97
    Const lcaseZ As Byte = 122
    'inizia qui
    s = ""
For j = lcaseA To lcaseZ
  s = s & Chr$(j) & " "
Next
End Sub
00401A30   > 55             PUSH EBP
00401A31   . 8BEC           MOV EBP,ESP
00401A33   . 83EC 0C        SUB ESP,0C
00401A36   . 68 A6104000    PUSH <JMP.&MSVBVM60.__vbaExceptHandler>
;  SE handler installation
00401A3B   . 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]
00401A41   . 50             PUSH EAX
00401A42   . 64:8925 000000>MOV DWORD PTR FS:[0],ESP
00401A49   . 83EC 30        SUB ESP,30
00401A4C   . 53             PUSH EBX
00401A4D   . 56             PUSH ESI
00401A4E   . 57             PUSH EDI
00401A4F   . 8965 F4        MOV DWORD PTR SS:[EBP-C],ESP
00401A52   . C745 F8 901040>MOV DWORD PTR SS:[EBP-8],Progetto.00401090
00401A59   . 8B45 08        MOV EAX,DWORD PTR SS:[EBP+8]
00401A5C   . 8BC8           MOV ECX,EAX
00401A5E   . 83E1 01        AND ECX,1
00401A61   . 894D FC        MOV DWORD PTR SS:[EBP-4],ECX
00401A64   . 24 FE          AND AL,0FE
00401A66   . 50             PUSH EAX
00401A67   . 8945 08        MOV DWORD PTR SS:[EBP+8],EAX
00401A6A   . 8B10           MOV EDX,DWORD PTR DS:[EAX]
00401A6C   . FF52 04        CALL DWORD PTR DS:[EDX+4]
00401A6F   . 33C0           XOR EAX,EAX
00401A71   . BA D8164000    MOV EDX,Progetto.004016D8
00401A76   . 8D4D E4        LEA ECX,DWORD PTR SS:[EBP-1C]
00401A79   . 8945 E4        MOV DWORD PTR SS:[EBP-1C],EAX
00401A7C   . 8945 E0        MOV DWORD PTR SS:[EBP-20],EAX
00401A7F   . 8945 DC        MOV DWORD PTR SS:[EBP-24],EAX
00401A82   . FF15 60104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaStrCopy>]          ;  MSVBVM60.__vbaStrCopy
00401A88   . 8B3D 78104000  MOV EDI,DWORD PTR
DS:[<&MSVBVM60.__vbaStrMove>]       ;  MSVBVM60.__vbaStrMove
00401A8E   . 8B1D 10104000  MOV EBX,DWORD PTR
DS:[<&MSVBVM60.__vbaStrCat>]        ;  MSVBVM60.__vbaStrCat
00401A94   . C745 C8 010000>MOV DWORD PTR SS:[EBP-38],1
00401A9B   . BE 61000000    MOV ESI,61
00401AA0   > B8 7A000000    MOV EAX,7A
00401AA5   . 66:3BF0        CMP SI,AX
00401AA8   . 7F 4E          JG SHORT Progetto.00401AF8
00401AAA   . 8B45 E4        MOV EAX,DWORD PTR SS:[EBP-1C]
00401AAD   . 0FBFCE         MOVSX ECX,SI
00401AB0   . 50             PUSH EAX
00401AB1   . 51             PUSH ECX
00401AB2   . FF15 4C104000  CALL DWORD PTR DS:[<&MSVBVM60.#537>]
;  MSVBVM60.rtcBstrFromAnsi
00401AB8   . 8BD0           MOV EDX,EAX
00401ABA   . 8D4D E0        LEA ECX,DWORD PTR SS:[EBP-20]
00401ABD   . FFD7           CALL EDI
00401ABF   . 50             PUSH EAX
00401AC0   . FFD3           CALL EBX
00401AC2   . 8BD0           MOV EDX,EAX
00401AC4   . 8D4D DC        LEA ECX,DWORD PTR SS:[EBP-24]
00401AC7   . FFD7           CALL EDI
00401AC9   . 50             PUSH EAX
00401ACA   . 68 E0164000    PUSH Progetto.004016E0
00401ACF   . FFD3           CALL EBX
00401AD1   . 8BD0           MOV EDX,EAX
00401AD3   . 8D4D E4        LEA ECX,DWORD PTR SS:[EBP-1C]
00401AD6   . FFD7           CALL EDI
00401AD8   . 8D55 DC        LEA EDX,DWORD PTR SS:[EBP-24]
00401ADB   . 8D45 E0        LEA EAX,DWORD PTR SS:[EBP-20]
00401ADE   . 52             PUSH EDX
00401ADF   . 50             PUSH EAX
00401AE0   . 6A 02          PUSH 2
00401AE2   . FF15 64104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaFreeStrList>]      ;  MSVBVM60.__vbaFreeStrList
00401AE8   . 66:8B4D C8     MOV CX,WORD PTR SS:[EBP-38]
00401AEC   . 83C4 0C        ADD ESP,0C
00401AEF   . 66:03CE        ADD CX,SI
00401AF2   . 70 4F          JO SHORT Progetto.00401B43
00401AF4   . 8BF1           MOV ESI,ECX
00401AF6   .^EB A8          JMP SHORT Progetto.00401AA0
00401AF8   > C745 FC 000000>MOV DWORD PTR SS:[EBP-4],0
00401AFF   . 68 241B4000    PUSH Progetto.00401B24
00401B04   . EB 14          JMP SHORT Progetto.00401B1A
00401B06   . 8D55 DC        LEA EDX,DWORD PTR SS:[EBP-24]
00401B09   . 8D45 E0        LEA EAX,DWORD PTR SS:[EBP-20]
00401B0C   . 52             PUSH EDX
00401B0D   . 50             PUSH EAX
00401B0E   . 6A 02          PUSH 2
00401B10   . FF15 64104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaFreeStrList>]      ;  MSVBVM60.__vbaFreeStrList
00401B16   . 83C4 0C        ADD ESP,0C
00401B19   . C3             RETN
00401B1A   > 8D4D E4        LEA ECX,DWORD PTR SS:[EBP-1C]
00401B1D   . FF15 88104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaFreeStr>]          ;  MSVBVM60.__vbaFreeStr
00401B23   . C3             RETN
00401B24   . 8B45 08        MOV EAX,DWORD PTR SS:[EBP+8]
00401B27   . 50             PUSH EAX
00401B28   . 8B08           MOV ECX,DWORD PTR DS:[EAX]
00401B2A   . FF51 08        CALL DWORD PTR DS:[ECX+8]
00401B2D   . 8B45 FC        MOV EAX,DWORD PTR SS:[EBP-4]
00401B30   . 8B4D EC        MOV ECX,DWORD PTR SS:[EBP-14]
00401B33   . 5F             POP EDI
00401B34   . 5E             POP ESI
00401B35   . 64:890D 000000>MOV DWORD PTR FS:[0],ECX
00401B3C   . 5B             POP EBX
00401B3D   . 8BE5           MOV ESP,EBP
00401B3F   . 5D             POP EBP
00401B40   . C2 0400        RETN 4
00401B43   > FF15 54104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaErrorOverflow>]    ;  MSVBVM60.__vbaErrorOverflow
-> solo con costanti numeriche <---
Private Sub Command1_Click()
    Dim j As Integer
    Dim s As String
    'inizia qui
    s = ""
For j = 97 To 122
  s = s & Chr$(j) & " "
Next
End Sub
00401A10   > 55             PUSH EBP
00401A11   . 8BEC           MOV EBP,ESP
00401A13   . 83EC 0C        SUB ESP,0C
00401A16   . 68 A6104000    PUSH <JMP.&MSVBVM60.__vbaExceptHandler>
;  SE handler installation
00401A1B   . 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]
00401A21   . 50             PUSH EAX
00401A22   . 64:8925 000000>MOV DWORD PTR FS:[0],ESP
00401A29   . 83EC 1C        SUB ESP,1C
00401A2C   . 53             PUSH EBX
00401A2D   . 56             PUSH ESI
00401A2E   . 57             PUSH EDI
00401A2F   . 8965 F4        MOV DWORD PTR SS:[EBP-C],ESP
00401A32   . C745 F8 901040>MOV DWORD PTR SS:[EBP-8],Progetto.00401090
00401A39   . 8B45 08        MOV EAX,DWORD PTR SS:[EBP+8]
00401A3C   . 8BC8           MOV ECX,EAX
00401A3E   . 83E1 01        AND ECX,1
00401A41   . 894D FC        MOV DWORD PTR SS:[EBP-4],ECX
00401A44   . 24 FE          AND AL,0FE
00401A46   . 50             PUSH EAX
00401A47   . 8945 08        MOV DWORD PTR SS:[EBP+8],EAX
00401A4A   . 8B10           MOV EDX,DWORD PTR DS:[EAX]
00401A4C   . FF52 04        CALL DWORD PTR DS:[EDX+4]
00401A4F   . 33C0           XOR EAX,EAX
00401A51   . BA D4164000    MOV EDX,Progetto.004016D4
00401A56   . 8D4D E4        LEA ECX,DWORD PTR SS:[EBP-1C]
00401A59   . 8945 E4        MOV DWORD PTR SS:[EBP-1C],EAX
00401A5C   . 8945 E0        MOV DWORD PTR SS:[EBP-20],EAX
00401A5F   . FF15 60104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaStrCopy>]          ;  MSVBVM60.__vbaStrCopy
00401A65   . 8B3D 74104000  MOV EDI,DWORD PTR
DS:[<&MSVBVM60.__vbaStrMove>]       ;  MSVBVM60.__vbaStrMove
00401A6B   . BB 01000000    MOV EBX,1
00401A70   . BE 61000000    MOV ESI,61
00401A75   > B8 7A000000    MOV EAX,7A
00401A7A   . 66:3BF0        CMP SI,AX
00401A7D   . 7F 38          JG SHORT Progetto.00401AB7
00401A7F   . 8B45 E4        MOV EAX,DWORD PTR SS:[EBP-1C]
00401A82   . 0FBFCE         MOVSX ECX,SI
00401A85   . 50             PUSH EAX
00401A86   . 51             PUSH ECX
00401A87   . FF15 4C104000  CALL DWORD PTR DS:[<&MSVBVM60.#537>]
;  MSVBVM60.rtcBstrFromAnsi
00401A8D   . 8BD0           MOV EDX,EAX
00401A8F   . 8D4D E0        LEA ECX,DWORD PTR SS:[EBP-20]
00401A92   . FFD7           CALL EDI
00401A94   . 50             PUSH EAX
00401A95   . FF15 10104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaStrCat>]           ;  MSVBVM60.__vbaStrCat
00401A9B   . 8BD0           MOV EDX,EAX
00401A9D   . 8D4D E4        LEA ECX,DWORD PTR SS:[EBP-1C]
00401AA0   . FFD7           CALL EDI
00401AA2   . 8D4D E0        LEA ECX,DWORD PTR SS:[EBP-20]
00401AA5   . FF15 84104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaFreeStr>]          ;  MSVBVM60.__vbaFreeStr
00401AAB   . 66:8BD3        MOV DX,BX
00401AAE   . 66:03D6        ADD DX,SI
00401AB1   . 70 45          JO SHORT Progetto.00401AF8
00401AB3   . 8BF2           MOV ESI,EDX
00401AB5   .^EB BE          JMP SHORT Progetto.00401A75
00401AB7   > C745 FC 000000>MOV DWORD PTR SS:[EBP-4],0
00401ABE   . 68 D91A4000    PUSH Progetto.00401AD9
00401AC3   . EB 0A          JMP SHORT Progetto.00401ACF
00401AC5   . 8D4D E0        LEA ECX,DWORD PTR SS:[EBP-20]
00401AC8   . FF15 84104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaFreeStr>]          ;  MSVBVM60.__vbaFreeStr
00401ACE   . C3             RETN
00401ACF   > 8D4D E4        LEA ECX,DWORD PTR SS:[EBP-1C]
00401AD2   . FF15 84104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaFreeStr>]          ;  MSVBVM60.__vbaFreeStr
00401AD8   . C3             RETN
00401AD9   . 8B45 08        MOV EAX,DWORD PTR SS:[EBP+8]
00401ADC   . 50             PUSH EAX
00401ADD   . 8B08           MOV ECX,DWORD PTR DS:[EAX]
00401ADF   . FF51 08        CALL DWORD PTR DS:[ECX+8]
00401AE2   . 8B45 FC        MOV EAX,DWORD PTR SS:[EBP-4]
00401AE5   . 8B4D EC        MOV ECX,DWORD PTR SS:[EBP-14]
00401AE8   . 5F             POP EDI
00401AE9   . 5E             POP ESI
00401AEA   . 64:890D 000000>MOV DWORD PTR FS:[0],ECX
00401AF1   . 5B             POP EBX
00401AF2   . 8BE5           MOV ESP,EBP
00401AF4   . 5D             POP EBP
00401AF5   . C2 0400        RETN 4
00401AF8   > FF15 54104000  CALL DWORD PTR
DS:[<&MSVBVM60.__vbaErrorOverflow>]    ;  MSVBVM60.__vbaErrorOverflow


 End Sub
Se j è integer devi usare le costanti as integer :)
altrimenti vengono fatte le relative conversioni.
Se anche così il compilato è differente... non ci sono più i compilatori
di una volta ;)
Un compilatore C o un Assembler non fa differenze tra costanti simboliche
ed esplicite.


termoPilucco ha scritto:
Aggiungo, prova a fare un eseguibile con questo codice (2 due label):
E' un mini benchmark delle due soluzioni...
curiosamente la mia sembra essere leggermente più veloce...
Private Sub Command1_Click()
Dim t As Single
Dim j As Integer
Dim a As Long
Const lcaseA As Integer = 97
Const lcaseZ As Integer = 122
t = Timer
For a = 1 To 100000000
    For j = lcaseA To lcaseZ
    Next
Next
Label1 = "k: " & Timer - t
t = Timer
For a = 1 To 100000000
    For j = 97 To 122
    Next
Next
Label2 = " " & Timer - t
End Sub


 ed esplicite.
E dato che il compilatore di VB è il C2... ;)
