Newsgroup: it.comp.lang.visual-basic
Titolo: case sensitive

Ciao ragazzi
mi sono accorto che comparando delle stringhe vb6 mi dice che sono diverse 
anche se sono identiche, e cioň č dovuto al fatto che una ha la lettera 
maiuscola all'inizio, come posso evitare in tutto il mio programma che vb 
sia "case sensitive" ??
grazie a tutti 


usa 
Option Compare Text   (e non Binary)
al inizio del moduulo
e varrà per tutto il modulo
oppure metti il parametro
vbTextCompare
nel comando che usi
leggi però questo
http://www.aivosto.com/vbtips/not-optimize.html
opure con LCase trasformi tutto prima in minuscolo
e non hai problemi nei confronti
(poi riporta le cose come erano 
o usa una variabile di servizio)

 ha scritto nel messaggio 
news:ZPO4h.36902$Fk1....@twister2.libero.it...

Una puntualizzazione: se due stringhe differiscono per un carattere allora 
SONO DIVERSE.
Questo in tutti i linguaggi di programmazione del mondo.
Detto questo, il mio consiglio č non toccare l'option text (a meno che tu 
non debba fare confronti con l'operatore LIKE) e usare la forma che 
preferisci tra ad es.
LCase$(str1) = LCase$(str2)
UCase$(str1) = UCase$(str2)
StrComp(str1, str2, vbCompareText) = 0
Se l'ultima č troppo lunga te ne fai una tua
Public function Equal(s1 as string, s2 as string)
    Equal = StrComp(str1, str2, vbCompareText) = 0
end function
Se cerchi performaces mi ricordo che alcuni miei test davano per vincente la 
formula
StrComp(LCase$(str1), LCase$(str2), vbCompareBinary) = 0
Ciao 

 StrComp(LCase$(str1), LCase$(str2), vbCompareBinary) = 0
Scusa sai per caso se quella sopra è migliore (più veloce) di:
LCase$(str1)=LCase$(str2)
Grazie.
-- 
DBMS Firebird
VB6 + Ado

 LCase$(str1)=LCase$(str2)
Io ero arrivato a questo
http://groups.google.it/group/it.comp.lang.visual-basic/browse_frm/thread/d4fbb09289a3ec81/966b84ac3e4c8596?lnk=gst&q=StrComp(LCase&rnum=2&hl=it#966b84ac3e4c8596
Ciao

 Io ero arrivato a questo
Ho fatto una prova (senza ucase, lcase)
    bFind = False
    i = LBound(AllowValue)
    Do Until bFind Or i > UBound(AllowValue)
      '#1 If StrComp(inValue, AllowValue(i), vbBinaryCompare) = 0 Then
      '#2 If inValue = AllowValue(i) Then
        bFind = True
      End If
      i = i + 1
    Loop
In questo caso con numerose iterazioni (10 volte un array da 10^6 elementi)
risulta meglio #2 (34 sec. invece di 47).
Quindi deduco che facendo lcase in entrambi i casi dovrebbe essere uguale.
Poi togliendo l'array e mettendolo globale c'è molta meno differenza.
Prova in un vbp a mettere 2 label e 1 command
*******************************************
Const max As Long = 10 ^ 6
Dim i As Long
Dim AllowValue(max) As String
Private Sub Command1_Click()
For i = 0 To max
  AllowValue(i) = CStr(i)
Next i
Label1.Caption = Time
For i = 1 To 10
  bInputInRange (max)
Next i
Label2.Caption = Time
End Sub
Public Function bInputInRange(inValue As String) As Boolean
Dim i As Long
Dim bFind As Boolean
    bFind = False
    i = LBound(AllowValue)
    Do Until bFind Or i > UBound(AllowValue)
      '#1 bFind = (StrComp(inValue, AllowValue(i), vbBinaryCompare) = 0)
      '#2 bFind = (inValue = AllowValue(i))
      i = i + 1
    Loop
 
    bInputInRange = bFind
End Function
*******************************************


> Io ero arrivato a questo
Ne ho fatta una anch'io
---------------------------------------------------
Const N_STRINGHE = 1000
Dim s1(N_STRINGHE) As String
Dim s2(N_STRINGHE) As String
Dim i As Long
Dim j As Long
Dim CharRnd As Long
Dim LenRnd As Long
Dim StartTime As Date
Dim EndTime As Date
Dim b As Boolean
'costruzione stringhe
For i = 1 To N_STRINGHE
    LenRnd = Int(Rnd * 40) + 10
    For j = 1 To LenRnd
        CharRnd = Int(Rnd * 90) + 33
        s1(i) = s1(i) & Chr$(CharRnd)
    Next
Next
StartTime = Now
For i = 1 To N_STRINGHE * 2000&
    j = i Mod 1000
    b = StrComp(s1(j), s2(j), vbTextCompare)
Next
EndTime = Now
Debug.Print "StrComp: " & CDate(EndTime - StartTime)
StartTime = Now
For i = 1 To N_STRINGHE * 2000&
    j = i Mod 1000
    b = LCase$(s1(j)) = LCase$(s2(j))
Next
EndTime = Now
Debug.Print "LCase: " & CDate(EndTime - StartTime)
---------------------------------------------------
Così StrComp(s1(j), s2(j), vbTextCompare) sembra la soluzione più veloce 
(circa 1/3 del confronto LCase, che risultava circa la metà del 
vbCompareBinary).
A questo punto non vorrei che dipenda anche dall'hardware utilizzato, il che 
spiegherebbe anche le varie ottimizzazioni del .Net Jit.
Ciao