Funktion mit unbestimmter Anzahl von Parametern

Du möchtest den Aufruf parsen? Also als Ergebnis in etwa:

>> Funktion: _EineFunc
>> Param_1: "Bla"
>> Param_2: "Blub"

Soll das in SciTE passieren oder im kompilierten Skript?

ConsoleWrite(_Until_10_Param('Bla', 'Blub', 'Blob') & @CRLF)


Func _Until_10_Param($_1, $_2=Null, $_3=Null, $_4=Null, $_5=Null, $_6=Null, $_7=Null, $_8=Null, $_9=Null, $_0=Null) ; min. 1 parameter
	Local $aParam[] = [$_1, $_2, $_3, $_4, $_5, $_6, $_7, $_8, $_9, $_0]
	Local $aParamStr[] = ['$_1', '$_2', '$_3', '$_4', '$_5', '$_6', '$_7', '$_8', '$_9', '$_0']
	Local $sOut = 'Func: _Until_10_Param' & @CRLF & '$_1: ' & $_1 & @CRLF
	For $i = 1 To UBound($aParam) -1
		If $aParam[$i] = Null Then ExitLoop
		$sOut &= $aParamStr[$i] & ': ' & $aParam[$i] & @CRLF
	Next
	Return $sOut
EndFunc

Out:
Func: _Until_10_Param
$_1: Bla
$_2: Blub
$_3: Blob

EDIT:

Manche Funktionen gestaltet man ja auch mit einem Leerstring als Vorbelegung für eine Variable, aber es folgen trotzdem noch besetzte Parameter. Deshalb verwende ich für echte leere Variablen die Vorbelegung: NULL.

Moin,

was hältst Du davon, der Funktion eine Parameter-Array zu übergeben? Damit hast Du immer Alles sicher im Griff.

War auch mein erster Gedanke Velted .
Bzw. würde ich eine Map nutzen.

Meine Frage wäre DOheim , warum du überhaupt so eine Funktion hast oder brauchst, mit beliebig vielen Parametern?
Vielleicht kannst du das ganz vermeiden dann musst du auch nicht mit Eval etc. arbeiten.

Wenn du mit den angebotenen Lösungen zufrieden bist, ist das auch für mich in Ordnung, doch persönlich würde ich dem "warum" auf den Grund gehen und es gar nicht erst dazu kommen lassen.

My 13 Cents dazu 😀 .

Viele Grüße
Sven

------------------------

Zitat von BugFix

Manche Funktionen gestaltet man ja auch mit einem Leerstring als Vorbelegung für eine Variable, aber es folgen trotzdem noch besetzte Parameter. Deshalb verwende ich für echte leere Variablen die Vorbelegung: NULL.

Finde ich super BugFix , mit NULL zu arbeiten. So initialisiere ich Maps i. d. R. in AutoIt auch, um genau den Leerstring Fall berücksichtigen zu können 🤝 .

Als Ergänzung:

Du kannst auch mit @NumParams die Anzahl der übergebenen Parameter ausgeben lassen.
Dann ist immer bekannt, ob die Variable übergeben wurde oder nicht, ohne den Inhalt prüfen zu müssen.

ConsoleWrite("-------------------"&@crlf)
_test(1)
ConsoleWrite("-------------------"&@crlf)
_test(2,3,4)
ConsoleWrite("-------------------"&@crlf)
_testReqParams(1, 2, 3, 4)

Func _test($p0=Default, $p1=Default, $p2=Default, $p3=Default, $p4=Default, $p5=Default, $p6=Default, $p7=Default, $p8=Default, $p9=Default, $p10=Default)
	For $i=0 To @NumParams-1
		ConsoleWrite($i&": "&Eval("p"&$i)&@crlf)
	Next
EndFunc

Func _testReqParams($someRequiredParam, $otherParam, $p0=Default, $p1=Default, $p2=Default, $p3=Default, $p4=Default, $p5=Default, $p6=Default, $p7=Default, $p8=Default, $p9=Default, $p10=Default)
	ConsoleWrite($someRequiredParam&@crlf)
	ConsoleWrite($otherParam&@crlf)
	For $i=0 To @NumParams-3
		ConsoleWrite($i&": "&Eval("p"&$i)&@crlf)
	Next
EndFunc

Beliebig viele Parameter werden aber recht selten genutzt (weshalb es in AutoIt auch keine wirkliche Implementierung dafür gibt, ohne Umwege wie Eval zu nutzen).
Andere Sprachen ermöglichen es z.B., dass der letzte Parameter z.B. als public static void func(String something, String... optional) angegeben wird, wo man beliebig viel übergeben kann und das wird dann in ein Array umgewandelt => String[] optional.
Es hat aber wenige Anwendungsfälle, die normal auch anders gelöst werden können.

Schau dir also deinen Anwendungsfall nochmal genau an, ob du das wirklich brauchst. In den meisten Fällen deutet das auf einen Design Fehler in deiner Software Architektur hin

LG, Kanashius

Vielleicht hilft Dir "Call" wobei Du die Parameter in einen Array packst und Element 0 des Array den Schlüsselwert "CallArgArray" enthält.
Details und Beispiel in der Hilfe

Hmm wieder was gelernt^^ Das @NumParams kannte ich auch noch nicht.

Aber anstatt X Parameter zu übergeben, würde ich, wenn irgendwie möglich, eher dazu übergehen wenige, dafür z.B. sinnvoll in Array(s) gepackt diese zu übergeben. Aber das hängt wohl auch stark vom Anwendungsfall ab.