Newsgroup: it.comp.lang.visual-basic
Titolo: Suffisso $

Che differenza c'è tra una funzione ed la sua omonima con suffisso $ ?
Ad es. Tra Format() e format$()?
Giovanni Lauria
Responsabile WRSoft Provincia di Taranto
wrsoft...@tiscalinetNOSPAM.it



Probabilmente e' solo un fatto di compatibilità con le vecchie
versioni di VB...
Ciao

versioni di VB...
  Compatibilita' una cippa, la versione col $ opera su stringhe e
restituisce stringhe, quella senza opera su variant e restituisce
variant.
  Ciao :-)
  Massimo
  Nell'indirizzo, inserire una "h" tra la "t" e la "u"
  In the address, insert an "h" between the "t" and the "u"


wrote:

Io non scrivo prima di leggere il manuale MSDN, dove entrambe le voci
ti portano sulla stessa pagina di documentazione e non ci sono note si
differenze, e' praticamente la stessa!
Uso MSDN Aprile 2001
Ciao

 Giovanni Lauria
Ragazzi, questo Giovanni ha della stoffa!
E' uno dei pochi(ssimi) che in tanti anni si accorge che c'è una doppia
versione delle funzioni stringa!
La risposta te l'ha data Massimo: usa sempre quelle con $.
Ciao

   Compatibilita' una cippa
:)
Ottimo intercalare :)
Rende molto l'idea!
Ciao



Come vedi c'e' anche chi pensa che siano diverse....
Ciao e buon lavoro!

 Come vedi c'e' anche chi pensa che siano diverse....
E lo sono!
Non si capisce bene perchè la M$ spinga ad usare i Variant facendo questo
tipo di disinformazione.
Comunque per controllare basta premere F2, cercare nella libreria VBA ad es.
"Left"
Si trova:
Left
-----
Function Left$(String, Length As Long) ' Sottintesi i Variant
Left$
Function Left$(String As String, Length As Long) As String
Ciao



Ho fatto una piccola prova ed in entrambi i casi, usando le funzioni
Format / Format$ - Left / Left$ mi ritorna in Visual Basic sempre una
String.
Bhooo!
Ciao e buon lavoro!

 mi ritorna in Visual Basic sempre una String.
No. Non ti ritorna una string. Solo che per vedere il tipo restituito
avrai utilizzato o VarType o TypeName, che ritornano, in caso di
Variant, il tipo di dato contenuto nel Variant stesso.
Prova:
dim a
a = "qqq"
debug.print typename(a)
Ciao.



Ora ho le idee confuse :-))))
Nella prova con le funzioni Format avevo usato Format(15.5,"##.##") e
mi tornava una String...
Ciao e grazie per l'intervento!

 Format(15.5,"##.##") e mi tornava una String...
Come hai fatto per verificare che ti ritornasse una string e non un
variant?
Ciao.



VarType(Format(15.5, "##.##"))

VarType(Format(15.5, "##.##"))
Attenzione: Varype non ritorna il _tipo_, bensi' il _sottotipo_ di una Variant:
------------ inizio citazione da msdn
VarType Function
Returns an Integer indicating the subtype of a variable.
Syntax
VarType(varname)
The required varname argument is a Variant containing any variable except a variable 
of a user-defined type.
---------------- fine citazione --------
-- 
ciao, hal

 VarType(Format(15.5, "##.##"))
Ti ha già risposto hal. Nè VarType, nè TypeName ti consentono di
verificare se una variabile è un Variant.
Ciao.

On Tue, 04 Dec 2001 22:38:29 GMT, "H.P.L." <u...@vaila.ble> wrote:

se ho ben capito il "Format" ritorna sempre una stringa che e' in ogni
caso un sottotipo di Variant.
Tutti i tipi di dati sono sottotipi di Variant proprio perche' variant
puo' contenerli tutti, anche un array.
La differenza sta nel fatto che se Format riturna ad una String,
quest'ultima non puo' essere trasformata in unn numero, mentre un
Variant si.
Ciao

Variant si.
Uhm, poche idee, ma confuse :-(
Se entrare in disquisizioni sui tipi di dati, cito un passo dal
Microsoft Office 2000/Visual Basic Programmer's Guide:
------ inizio citazione ------------------
Note   
Some of the VBA string functions come in two varieties, one that returns a string, 
and one that returns a string-type Variant value. 
The names of the functions that return a string include a dollar sign ("$"); 
for example, Chr$, Format$, LCase$, Left$, LTrim$, Mid$, Right$, RTrim$, Space$, Trim$, 
and UCase$. 
The functions that return a string-type Variant value have no dollar sign; 
for example, Chr, Format, LCase, Left, LTrim, Mid, Right, RTrim, Space, Trim, 
and UCase. 
The string-returning functions are faster; however, you'll get an error if you call 
them with a value that is Null. The functions that return a string-type Variant value 
handle Null values without an error. 
Code examples in this chapter use the string-returning functions where appropriate.
------------ fine citazione
Morale: Le funzioni stringa che terminano con il carattere $ restituiscono
una String (cioe', detto approssimattivamente, un puntatore ad un blocco di memoria), 
mentre quelle senza restituiscono una Variant (che e' una struttura con dei campi
che contengono la descrizione del tipo di dato contenuto e, se possibile, il valore
stesso, altrimenti il puntatore alla zona di memoria contenente il valore).
Ovviamente, la convenienza ad usare le funzioni$ rispetto a quelle senza $
dipende da caso a caso (anche se penso quasi sempre convengano le prime).
-- 
ciao, hal

Aggiungo un piccolo esperimento per dimostrare quanto detto nel precedente post.
In un nuovo progetto vb eliminare il form di default ed inserire un modulo,
ove copiare il seguente codice:
-------- inizio codice   -------------
Option Explicit
Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" ( _
                    ByRef Destination As Any, ByRef Source As Any, _
                    ByRef Length As Long)
Public Sub main()
    '// Ricevera' la copia di quanto c'e' in memoria, senza che
    '// visual basic faccia conversioni di ipo
    Dim buffer() As Byte
 
 
    ' -------- FORMAT che ritorna una Variant passato per riferimento
    '// Allochiamo un buffer sufficientemente grande per non rischiare un
    '// overflow a sorpresa, che provocherebb un crash irreparabile
    ReDim buffer(0 To 511)
    '// copiamo il riferimento ritorno di Format nel nostro blocco di byte
    CopyMemory buffer(0), Format(1234, ""), ByVal 4
    Debug.Print "----- ByRef Format(1234, """")"
    Debug.Print Chr$(buffer(0)), Chr$(buffer(1)), Chr$(buffer(2)), Chr$(buffer(3))
    Debug.Print ""
 
    '// Questo manda in crash visual basic, salvare il codice prima di eseguire
'    ReDim buffer(0 To 511)
'    CopyMemory buffer(0), ByVal Format(1234, ""), ByVal 4
'    Debug.Print "----- ByVal Format(1234, """")"
'    Debug.Print Chr$(buffer(0)), Chr$(buffer(1)), Chr$(buffer(2)), Chr$(buffer(3))
'    Debug.Print ""
    ' -------- FORMAT che ritorna una String
    '// copiamo per riferimento: in realta' non viene copiata la stringa, ma il suo puntatore
    ReDim buffer(0 To 511)
    CopyMemory buffer(0), Format$(1234, ""), ByVal 4
    Debug.Print "----- ByRef Format$(1234, """")"
    Debug.Print Chr$(buffer(0)), Chr$(buffer(1)), Chr$(buffer(2)), Chr$(buffer(3))
    Debug.Print ""
 
    '// Questa volta copiamo ByVal, cioe' il contenuto della stringa
    ReDim buffer(0 To 511)
    CopyMemory buffer(0), ByVal Format$(1234, ""), ByVal 4
    Debug.Print "----- ByVal Format$(1234, """")"
    Debug.Print Chr$(buffer(0)), Chr$(buffer(1)), Chr$(buffer(2)), Chr$(buffer(3))
    Debug.Print ""
 
End Sub
--------------------- fine codice ----------------------
Questo e' l' output del microprogramma, da eseguire nell' IDE:
----- ByRef Format(1234, "")
 
----- ByRef Format$(1234, "")
¬             ç                            
----- ByVal Format$(1234, "")
1             2             3             4
Solo nell' ultimo caso leggiamo le cifre 1234, quindi possiamo dire che 
Format$  restituisce una String, mentre Format ritorna una Variant.
-- 
ciao, hal



Cavolo, ti sei proprio accanito! :-))))))
Bhe, grazie a nome di tutti.....
Un'unica nota:
Manca l'OutPut di ByVal Format :-))))))))))))))))))
Ciao


Finalmente siamo giunti alla fine..... Tutto chiaro ora!
Thanks
Ciao

 Ciao
miao!...scusa hal!

Thread interessante ed estenuante sulla restituzione di valori String o
Variant
Si sappia che la funzione Money$() restituisce dollari, Money() restituisce
Euro! :))
Fabio

On Wed, 05 Dec 2001 10:53:42 GMT, "Wodka4U" <marc_cHa_o@mar_Xp_tek.it>
wrote:

Se per accanito intendi dire che posto per ringraziare del tempo speso
per una spiegazione, allora sono accanito.
Poi faccio notare che il Threed non e' mio.
Ciao a tutti!

 ha scritto nel messaggio
news:3c0e658e...@news.libero.it...
CVD

per una spiegazione
Grazie :-)
L' avevo capito e mi era anche piaciuto lo spirito della tua risposta :)
Ma Wodka4U, sai com'e', e' un peperino, un toscanaccio, contribuisce a tenere
vivo il ng ... ehi Marco, ho detto NG, non RING ! :PPP
-- 
ciao, hal$

On Tue, 04 Dec 2001 19:49:37 GMT, wrsoft...@NOSPAMtiscalinet.it
(WRSoft) wrote:

GRAZIE A TUTTI PER IL CHIARIMENTO....
NG RULES!
; )


 ha scritto nel messaggio
news:fWoP7.243311$sq5.11...@news.infostrada.it...

Ovvio, altrimenti sarebbe stata Money€() :)
E' interessante notare l'abbreviazione di Money$() --> M$() :)
Ciao