Fick denna funktion av bj, (portad från Delphi till VB).

<code>
Function str(strp As String, bah As Integer) As String
Dim i As Integer
Dim temp As String
For i = 1 To bah
temp = temp & strp
Next
strp = temp
End Function
</code>

Och använder detta för att kalla på funktionen,
<code>
MsgBox "hej" & str("x", 4) & "då"
</code>

Nu är det så att den egentligen ska visa "hejxxxxdå", men istället visar den
"hejdå". Jag förstår inte varför, och bj kommer inte ihåg hur man får det
att fungera i VB.

Tack på förhand.

function str(strp as string, bah as integer) as string
dim i as integer
dim temp as string
for i = 1 to bah
temp = temp & strp
next
str = temp
end function

ska det vara...

msgbox "hej" & string("x", 4) & "då"

alt. att du vänder på parametrarna till string-funktionen, du får testa eller kolla ii hjälpen... str är hur som helst en funktion i vb...

Njaaa, det skulle vara Next inte End :P,
men nu så funkade det.

Tack :)

MAn behöver ju inte deklarera en variabel:
<code>
Function str(Text As String, Times As Integer) As String
Dim i As Integer
For i = 1 To Times
str = str & Text
Next
End Function
</code>
Fast det är inget effektivt att slå samman större eller många strängar på detta sättet. Eftersom den måste alokeras om för varje loop då den blir större och inte får plats. Det är då effektivare att första alokera plats för variabeln och sedan fylla den:
<code>
Function str(Text As String, Times As Integer) As String
Dim i As Integer, l As Integer, p As Integer
p = 1
l = Len(Text)
str = Space(l * Times)
For i = 1 To Times
Mid(str, p, l) = Text
p = p + l
Next
End Function
</code>
Små och/eller få gånger är skillnaden försumbar. Har för mig att skillnaden sedan är exponensiell med strängens storlek.

Det finns ju en redan en string() funktion som funkar med ett texken:
<code>
MsgBox "hej" & String$( 4,"x") & "då"
</code>

<b>>Det är då effektivare att första alokera plats för variabeln och sedan fylla den:
>...
>Mid(str, p, l) = Text
>... </b>

Att använda Mid utan $ bör väl inte vara så där överdrivet effektivt. Först omvandling till Variant och sen omvandling tillbaks.

>Har för mig att skillnaden sedan är exponensiell med strängens storlek.
Njae... exponentiell tillväxt är inte rimligt.. Det rör sig om en tid som är proportionell mot kvadraten på antalet gånger, men linjärt mot längden på strängen.

Mattematik är inte min starka sida. Skillnaderna med Mid() statement som tar emot stränge eller variant anser jag försumbara. Vill bar visa principen.

Litet test:
<code>
Option Explicit

Private Declare Function GetTickCount Lib "kernel32" () As Long

Function str1(text As String, Times As Long) As String
Dim i As Long
For i = 1 To Times
str1 = str1 & text
Next
End Function

Function str2(text As String, Times As Long) As String
Dim i As Long, l As Long, p As Long
p = 1
l = Len(text)
str2 = Space(l * Times)
For i = 1 To Times
Mid(str2, p, l) = text
p = p + l
Next
End Function

Function str3(text As String, Times As Long) As String
Dim i As Long, l As Long, p As Long
p = 1
l = Len(text)
str3 = Space(l * Times)
For i = 1 To Times
Mid(str3, p, l) = text
p = p + l
Next
End Function


Private Sub Command1_Click()
Dim text As String
Dim Index As Long
Dim Times As Long
Dim Length As Long
Dim Data As Variant
Dim StartTime As Long
Data = Array(100, 1000, 10000, 100000)
For Index = LBound(Data) To UBound(Data)
Times = Data(Index)

For Length = 1 To 5
text = String(Length, "x")
StartTime = GetTickCount
str1 text, Times
str1 text, Times
str1 text, Times
str1 text, Times
str1 text, Times
List1.AddItem "str1 (Times: " & Times & ", Length: " & Length & "): " & GetTickCount() - StartTime

StartTime = GetTickCount
str2 text, Times
str2 text, Times
str2 text, Times
str2 text, Times
str2 text, Times
List1.AddItem "str2 (Times: " & Times & ", Length: " & Length & "): " & GetTickCount() - StartTime

StartTime = GetTickCount
str3 text, Times
str3 text, Times
str3 text, Times
str3 text, Times
str3 text, Times
List1.AddItem "str3 (Times: " & Times & ", Length: " & Length & "): " & GetTickCount() - StartTime
Next
Next
End Sub
</code>
Vilket ger följande resultat hoss mig:

'100
str1 (Times: 100, Length: 1): 0
str2 (Times: 100, Length: 1): 0
str3 (Times: 100, Length: 1): 0

str1 (Times: 100, Length: 2): 0
str2 (Times: 100, Length: 2): 0
str3 (Times: 100, Length: 2): 0

str1 (Times: 100, Length: 3): 0
str2 (Times: 100, Length: 3): 0
str3 (Times: 100, Length: 3): 0

str1 (Times: 100, Length: 4): 0
str2 (Times: 100, Length: 4): 10
str3 (Times: 100, Length: 4): 0

str1 (Times: 100, Length: 5): 0
str2 (Times: 100, Length: 5): 0
str3 (Times: 100, Length: 5): 0

'1000
str1 (Times: 1000, Length: 1): 10
str2 (Times: 1000, Length: 1): 10
str3 (Times: 1000, Length: 1): 0

str1 (Times: 1000, Length: 2): 20
str2 (Times: 1000, Length: 2): 10
str3 (Times: 1000, Length: 2): 0

str1 (Times: 1000, Length: 3): 30
str2 (Times: 1000, Length: 3): 10
str3 (Times: 1000, Length: 3): 0

str1 (Times: 1000, Length: 4): 40
str2 (Times: 1000, Length: 4): 10
str3 (Times: 1000, Length: 4): 0

str1 (Times: 1000, Length: 5): 70
str2 (Times: 1000, Length: 5): 0
str3 (Times: 1000, Length: 5): 0

'10000
str1 (Times: 10000, Length: 1): 1973
str2 (Times: 10000, Length: 1): 40
str3 (Times: 10000, Length: 1): 40

str1 (Times: 10000, Length: 2): 4206
str2 (Times: 10000, Length: 2): 40
str3 (Times: 10000, Length: 2): 41

str1 (Times: 10000, Length: 3): 6589
str2 (Times: 10000, Length: 3): 40
str3 (Times: 10000, Length: 3): 40

str1 (Times: 10000, Length: 4): 8452
str2 (Times: 10000, Length: 4): 40
str3 (Times: 10000, Length: 4): 40

str1 (Times: 10000, Length: 5): 10546
str2 (Times: 10000, Length: 5): 40
str3 (Times: 10000, Length: 5): 40

Jag drar slutsatsen att skilnaden är försumbar vid få antal upprepningar och/eller små texter. Men man bör tänka sig för när man ska behandla fler antal eller störe texter.

<b>>Skillnaderna med Mid() statement som tar emot stränge eller variant anser jag försumbara. Vill bar visa principen.</b>
Men du har inte gjort någon jämförelse. Koden för str2 och str3 är ju identisk... Man kan ju inte anse något vara försumbart om man inte testar.

<b>>Jag drar slutsatsen att skilnaden är försumbar vid få antal upprepningar och/eller små texter. Men man bör tänka sig för när man ska behandla fler antal eller störe texter.</b>

För textens storlek är det ingen skillnad. Dubblar man textens längd så dubblar man tiden. Däremot är antalet kopior avgörande. (sen får man ju tänka på att de allra flesta optimeringar inte har betydelse med dagens datorer ändå...)

Du kan ju göra ett test själv mellan Mid() och Mid$() statment. Se om du hittar någon markant skillnad.

För övrigt tycker jag man alltid bör tänka på att skriva effektiv kod. Effektiv kod skriver man genom att veta vad som tar resurser i koden.

Jag tycker inte du tillfört så mycket postivkritik. Utan mer bara klagar.

Jag hade inte möjlighet att testa, eftersom jag satt på jobbet och VBA inte klarar tilldelningar av typen Mid(...)="...". Jag har nu testat, och det tycks inte vara någon skillnad. Frågan är om VB överhuvudtaget gör en typomvandling i detta fallet.


Jo, visst skall man försöka skriva effektiv kod, men i många fall är det - i och med dagens datorer - onödigt att optimera hårt om man gör koden svårare att förstå eller underhålla.

Syftet är inte att klaga och jag förstår inte varför du tycker att jag klagar. Det enda jag gjort är att ge en generell syn på variant vs string, och klargjort att det inte är en exponentiell tillväxt per stränglängd utan en linjär (syns ju dessutom tydligt på resultaten...), men att det däremot växer aningen starkare än kvadratiskt per antalet kopior.