Wie können Sie mehrere Anweisungen in einer anonymen MATLAB-Funktion ausführen?

Ich würde gerne etwas wie das hier tun:

>> foo = @() functionCall1() functionCall2()

So, dass wenn ich gesagt habe:

>> foo()

Es würde ausführen functionCall1() und führen Sie dann functionCall2(). (Ich fühle, dass ich brauche so etwas wie die C , operator)

EDIT:

functionCall1 und functionCall2 sind nicht unbedingt die Funktionen, die Werte zurückgeben.

InformationsquelleAutor der Frage Daniel LeCheminant | 2009-02-17

45

Versuchen, alles zu tun, über die Kommandozeile ohne speichern der Funktionen in m-Dateien kann eine komplizierte und unübersichtliche Unterfangen, aber hier ist ein Weg, ich kam mit...

Erstes anonyme Funktionen und setzen Ihre Griffe in einem cell array:
```
fcn1 = @() ...;
fcn2 = @() ...;
fcn3 = @() ...;
fcnArray = {fcn1 fcn2 fcn3};
```
...oder, wenn Sie Funktionen, die bereits definiert (wie in m-Dateien), Stelle die Funktion verarbeitet in einem cell-array in etwa so:
```
fcnArray = {@fcn1 @fcn2 @fcn3};
```
Dann können Sie eine neue anonyme Funktion, die ruft jede Funktion im array mit Hilfe des built-in-Funktionen cellfun und feval:
```
foo = @() cellfun(@feval,fcnArray);
```
Zwar witzig aussieht, es funktioniert.

EDIT:Wenn die Funktionen in fcnArray aufgerufen werden müssen mit der Eingabe-Argumente, würden Sie zunächst sicherstellen, dass ALLE Funktionen im array benötigen DIE GLEICHE Anzahl von Eingängen. In diesem Fall wird das folgende Beispiel zeigt, wie der Aufruf der array-Funktionen mit einem input-argument:
```
foo = @(x) cellfun(@feval,fcnArray,x);
inArgs = {1 'a' [1 2 3]};
foo(inArgs);  %# Passes 1 to fcn1, 'a' to fcn2, and [1 2 3] to fcn3
```
WORT DER WARNUNG: Die Dokumentation für cellfun besagt, dass die umin dem die Ausgabe-Elemente berechnet werden, ist nicht angegeben und sollten nicht als verlässlich angesehen werden. Dies bedeutet, dass es gibt keine Garantien, dass fcn1 wird ausgewertet, bevor fcn2 oder fcn3. Wenn die Bestellung ankommt, ist die obige Lösung nicht verwendet werden sollte.

InformationsquelleAutor der Antwort gnovice
11

Der anonymen Funktion syntax in Matlab (wie einige andere Sprachen) erlaubt nur einen einzigen Ausdruck. Darüber hinaus hat es verschiedene variable Bindung Semantik (Variablen, die nicht in der argument-Liste haben Ihre Werte lexikalisch gebunden an die Erstellung einer Funktion der Zeit, anstatt von Referenzen gebunden werden). Diese Einfachheit erlaubt es Mathworks, um einige Optimierungen hinter den kulissen und vermeiden Sie eine Menge von unordentlichen scoping und Lebensdauer von Objekten Probleme, wenn Sie Sie in Skripts.

Wenn Sie die Definition der anonymen Funktion innerhalb einer Funktion (kein Skript), können Sie benannte innere Funktionen. Innere Funktionen haben normale lexikalische Referenz verbindlich und erlauben eine beliebige Anzahl von Anweisungen.
```
function F = createfcn(a,...)
  F = @myfunc;
  function b = myfunc(...)
    a = a+1; 
    b = a; 
  end
end
```
Manchmal kann man sich mit tricks wie gnovice Vorschlag.

Vorsichtig sein, über die Verwendung von eval,... es ist sehr ineffizient (es umgeht die JIT) und Matlab s-Optimierer verwirrt zwischen den Variablen und Funktionen, die aus dem äußeren Rahmen, die verwendet werden, innerhalb der eval-Ausdruck. Es ist auch schwer zu Debuggen und/oder das Ausmaß code mit eval.

InformationsquelleAutor der Antwort Mr Fooz
6

Hier ist eine Methode, mit der Garantie für die Ausführungsreihenfolge und das, (mit den erwähnten änderungen am Ende) erlaubt die übergabe unterschiedliche Argumente für unterschiedliche Funktionen.
```
call1 = @(a,b) a();
call12 = @(a,b) call1(b,call1(a,b));
```
Den Schlüssel call1 fordert ein erstes argument und ignoriert Ihr zweites. call12 fordert sein erstes argument und dann die zweite, die Rückgabe der Wert aus der zweiten. Es funktioniert, weil eine Funktion nicht ausgewertet werden kann, bevor Ihre Argumente. Erstellen Sie Ihr Beispiel, würden Sie schreiben:
```
foo = @() call12(functionCall1, functionCall2);
```
Test-Code

Hier ist der test-code, den ich verwendet:
```
>> print1=@()fprintf('1\n');
>> print2=@()fprintf('2\n');
>> call12(print1,print2)
1
2
```
Aufrufen weitere Funktionen

Nennen Sie 3 Funktionen, könnten Sie schreiben,
```
call1(print3, call1(print2, call1(print1,print2)));
```
4 Funktionen:
```
call1(print4, call1(print3, call1(print2, call1(print1,print2))));
```
Weitere Funktionen, weiterhin die Verschachtelung Muster.

Argumente Übergeben

Wenn Sie müssen Argumente übergeben werden, Sie können schreiben, eine version von call1 nimmt Argumente und dann machen die offensichtliche änderung call12.
```
call1arg1 = @(a,arg_a,b) a(arg_a);
call12arg1 = @(a, arg_a, b, arg_b) call1arg1(b, arg_b, call1arg1(a, arg_a, b))
```
Können Sie auch Versionen von Ruf 1, die mehrere Argumente und mischen Sie und passen Sie diese entsprechend.

InformationsquelleAutor der Antwort Eponymous
1

Wenn functionCall1() und functionCall2() etwas zurückgeben und denen irgendwas verkettet werden kann, dann können Sie dies tun:

>> foo = @() [functionCall1(), functionCall2()]

oder

>> foo = @() [functionCall1(); functionCall2()]

Ein Nebeneffekt dabei ist, dass foo() zurückkehren wird, die Verkettung von was auch immer functionCall1() und functionCall2() zurück.

Ich weiß nicht, ob die Reihenfolge der Ausführung von functionCall1() und functionCall2() gewährleistet ist.

InformationsquelleAutor der Antwort ManWithSleeve
1

Es ist möglich, mit dem lockig - Funktion, die verwendet wird, um erstellen Sie eine durch Trennzeichen getrennte Liste.
```
curly = @(x, varargin) x{varargin{:}};
f=@(x)curly({exp(x),log(x)})
[a,b]=f(2)
```
InformationsquelleAutor der Antwort Daniel
0

Vielleicht bin ich fehlen, somethign, nur eine Funktion combinationCall aufruft, beide Funktionen für Sie.

InformationsquelleAutor der Antwort MatlabDoug

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.