it-swarm.com.de

Was ist der Unterschied zwischen '@' und '=' im Richtlinienbereich in AngularJS

Ich habe die AngularJS-Dokumentation zu diesem Thema sorgfältig gelesen und dann mit einer Anweisung herumgespielt. Hier ist die Geige .

Und hier sind einige relevante Ausschnitte:

  • Aus dem HTML:

    <pane bi-title="title" title="{{title}}">{{text}}</pane>
    
  • Aus der Bereichsanweisung:

    scope: { biTitle: '=', title: '@', bar: '=' },
    

Es gibt einige Dinge, die ich nicht verstehe:

  • Warum muss ich "{{title}}" mit '@' und "title" mit '=' verwenden?
  • Kann ich auch direkt auf den übergeordneten Bereich zugreifen, ohne mein Element mit einem Attribut zu versehen?
  • Die Dokumentation sagt "Oft ist es wünschenswert, Daten aus dem isolierten Bereich über einen Ausdruck und an den übergeordneten Bereich zu übergeben", aber das scheint auch bei bidirektionaler Bindung gut zu funktionieren. Warum sollte der Ausdruck besser sein?

Ich habe eine andere Geige gefunden, die auch die Ausdruckslösung zeigt: http://jsfiddle.net/maxisam/QrCXh/

1025
iwein

Warum muss ich "{{title}}" mit "@" und "title" mit "=" verwenden?

@ bindet eine lokale/Direktive-Bereichseigenschaft an den auswerteten Wert des DOM-Attributs. Wenn Sie title=title1 oder title="title1" verwenden, ist der Wert des DOM-Attributs "title" einfach die Zeichenfolge title1. Wenn Sie title="{{title}}" verwenden, ist der Wert des DOM-Attributs "title" der interpolierte Wert von {{title}}. Daher wird die Zeichenfolge der aktuellen Eigenschaft des übergeordneten Bereichs "title" zugewiesen. Da Attributwerte immer Zeichenfolgen sind, erhalten Sie bei Verwendung von @ immer einen Zeichenfolgenwert für diese Eigenschaft im Gültigkeitsbereich der Direktive.

= bindet eine lokale/Direktive-Bereichseigenschaft an eine übergeordnete Bereichseigenschaft. Mit = verwenden Sie also den Namen der übergeordneten Modell-/Bereichseigenschaft als Wert des DOM-Attributs. Sie können {{}}s nicht mit = verwenden.

Mit @ können Sie Folgendes tun: title="{{title}} and then some" - {{title}} wird interpoliert, dann wird die Zeichenfolge "und einige davon" damit verkettet. Die abschließende verkettete Zeichenfolge ist das, was die Eigenschaft local/direct erhält. (Mit = ist dies nicht möglich, nur mit @.)

Mit @ müssen Sie attr.$observe('title', function(value) { ... }) verwenden, wenn Sie den Wert in Ihrer Link (ing) -Funktion verwenden müssen. Zum Beispiel funktioniert if(scope.title == "...") nicht wie erwartet. Beachten Sie, dass Sie nur auf dieses Attribut zugreifen können asynchron . Sie müssen $ observ () nicht verwenden, wenn Sie nur den Wert in einer Vorlage verwenden. Zum Beispiel template: '<div>{{title}}</div>'.

Mit = müssen Sie $ observ nicht verwenden.

Kann ich auch direkt auf den übergeordneten Bereich zugreifen, ohne mein Element mit einem Attribut zu versehen?

Ja, aber nur, wenn Sie keinen Isolatbereich verwenden. Entfernen Sie diese Zeile aus Ihrer Anweisung 

scope: { ... } 

und dann wird Ihre Anweisung keinen neuen Bereich erstellen. Der übergeordnete Bereich wird verwendet. Sie können dann direkt auf alle Eigenschaften des übergeordneten Bereichs zugreifen.

In der Dokumentation heißt es "Oft ist es wünschenswert, Daten aus dem isolierten Bereich über einen Ausdruck und an den übergeordneten Bereich zu übergeben", aber das scheint auch bei bidirektionaler Bindung gut zu funktionieren. Warum sollte der Ausdruck besser sein?

Ja, bei bidirektionaler Bindung können der lokale/Direktive-Bereich und der übergeordnete Bereich Daten gemeinsam nutzen. Mit "Ausdruckbindung" kann die Direktive einen Ausdruck (oder eine Funktion) aufrufen, der durch ein DOM-Attribut definiert ist. Außerdem können Sie Daten als Argumente an den Ausdruck oder die Funktion übergeben. Wenn Sie also keine Daten mit dem übergeordneten Element teilen möchten - Sie möchten nur eine im übergeordneten Gültigkeitsbereich definierte Funktion aufrufen - können Sie die Syntax & verwenden.

Siehe auch

1127
Mark Rajcok

Hier gibt es viele großartige Antworten, aber ich möchte meine Perspektive auf die Unterschiede zwischen @, = und &-Bindung anbieten, die sich für mich als nützlich erwiesen haben.

Mit allen drei Bindungen können Sie Daten aus Ihrem übergeordneten Bereich an den isolierten Bereich Ihrer Anweisung über die Attribute des Elements übergeben:

  1. @ Bindung dient zum Übergeben von Strings. Diese Zeichenketten unterstützen {{}}-Ausdrücke für interpolierte Werte. Zum Beispiel: . Der interpolierte Ausdruck wird gegen .__ ausgewertet. übergeordneter Geltungsbereich der Richtlinie.

  2. = Bindung ist für die bidirektionale Modellbindung. Das Modell im übergeordneten Bereich ist im isolierten Geltungsbereich der Richtlinie mit dem Modell verknüpft. Änderungen an Ein Modell beeinflusst das andere und umgekehrt.

  3. & binding dient zum Übergeben einer Methode in den Geltungsbereich Ihrer Direktive, sodass es kann in Ihrer Direktive aufgerufen werden. Die Methode ist an .__ gebunden. der übergeordnete Bereich der Direktive und unterstützt Argumente. Wenn die Methode beispielsweise im übergeordneten Bereich Hallo (Name) ist, dann in Um die Methode aus Ihrer Direktive heraus auszuführen, müssen Sie call $ scope.hello ({name: 'world'})

Ich finde, dass es einfacher ist, sich an diese Unterschiede zu erinnern, indem auf die Bereichsbindungen durch eine kürzere Beschreibung Bezug genommen wird:

  • @Attributstringbindung
  • =Zweiwege-Modellbindung
  • &Callback-Methodenbindung

Die Symbole machen auch klarer, was die Gültigkeitsbereichsvariable in der Implementierung Ihrer Direktive darstellt:

  • @string
  • =model
  • &method

In der Reihenfolge des Nutzens (für mich sowieso):

  1. =
  2. @
  3. &
531
pixelbits

= bedeutet bidirektionales Binden, also einen Verweis auf eine Variable auf den übergeordneten Bereich. Das heißt, wenn Sie die Variable in der Direktive ändern, wird sie auch im übergeordneten Bereich geändert.

@ bedeutet, dass die Variable in die Direktive kopiert (geklont) wird.

Soweit ich weiß, sollte auch <pane bi-title="{{title}}" title="{{title}}">{{text}}</pane> funktionieren. bi-title erhält den Wert der übergeordneten Bereichsvariablen, der in der Direktive geändert werden kann.

Wenn Sie mehrere Variablen im übergeordneten Bereich ändern müssen, können Sie eine Funktion im übergeordneten Bereich in der Direktive ausführen (oder Daten über einen Dienst übergeben).

62
asgoth

Wenn Sie mehr darüber erfahren möchten, wie dies mit einem Live-Beispiel funktioniert. http://jsfiddle.net/juanmendez/k6chmnch/

var app = angular.module('app', []);
app.controller("myController", function ($scope) {
    $scope.title = "binding";
});
app.directive("jmFind", function () {
    return {
        replace: true,
        restrict: 'C',
        transclude: true,
        scope: {
            title1: "=",
            title2: "@"
        },
        template: "<div><p>{{title1}} {{title2}}</p></div>"
    };
});
39
Juan Mendez

@get as string

  • Dadurch entstehen keinerlei Bindungen. Sie erhalten einfach das Wort, das Sie als Zeichenfolge übergeben haben

=2-Wege-Bindung

  • Änderungen, die vom Controller vorgenommen werden, werden in der Referenz der Richtlinie wiedergegeben und umgekehrt

& Dies verhält sich etwas anders, da der Gültigkeitsbereich eine Funktion erhält, die das in übergebene Objekt zurückgibt. Ich gehe davon aus, dass dies notwendig war, damit es funktioniert. Die Geige sollte das klarstellen.

  • Nach dem Aufruf dieser Getter-Funktion verhält sich das resultierende Objekt wie folgt:
    • wenn ein function übergeben wurde: dann wird die Funktion beim Aufruf des übergeordneten (Controller) Schließens ausgeführt
    • wenn ein Nicht-Funktion übergeben wurde: Holen Sie sich einfach eine lokale Kopie des Objekts ohne Bindungen


Diese Geige soll zeigen, wie sie funktionieren . Achten Sie besonders auf die Bereichsfunktionen mit get... im Namen, um hoffentlich besser zu verstehen, was ich mit & meine.

36
geg

Es gibt drei Möglichkeiten, in die Richtlinie einen Bereich hinzuzufügen:

  1. Parent scope: Dies ist die Standardvererbung des Bereichs. 

Die Direktive und ihr übergeordneter Bereich (Controller/Direktive, in dem sie liegt) sind gleich .. .. Daher werden alle Änderungen, die an den Gültigkeitsbereichsvariablen in der Direktive vorgenommen werden, auch im übergeordneten Controller angezeigt. Sie müssen dies nicht angeben, da es die Standardeinstellung ist.

  1. Child-Bereich: Die Direktive erstellt einen untergeordneten Bereich, der vom übergeordneten Bereich erbt, wenn Sie die Bereichsvariable der Direktive als wahr angeben. 

Wenn Sie die Bereichsvariablen innerhalb der Direktive ändern, wird dies nicht im übergeordneten Bereich angezeigt. Wenn Sie jedoch die Eigenschaft einer Bereichsvariablen ändern, wird dies im übergeordneten Bereich angezeigt, da Sie die Bereichsvariable des übergeordneten Objekts tatsächlich geändert haben .

Beispiel,

app.directive("myDirective", function(){

    return {
        restrict: "EA",
        scope: true,
        link: function(element, scope, attrs){
            scope.somvar = "new value"; //doesnot reflect in the parent scope
            scope.someObj.someProp = "new value"; //reflects as someObj is of parent, we modified that but did not override.
        }
    };
});
  1. Isolated scope: Dies wird verwendet, wenn Sie einen Bereich erstellen möchten, der nicht vom Controller-Bereich erbt. 

Dies geschieht beim Erstellen von Plugins, da die Direktive dadurch generisch wird, da sie in beliebigem HTML-Code platziert werden kann und nicht durch ihren übergeordneten Bereich beeinflusst wird.

Wenn Sie keine Interaktion mit dem übergeordneten Bereich wünschen, können Sie den Bereich einfach als leeres Objekt angeben. mögen,

scope: {} //this does not interact with the parent scope in any way

Meistens ist dies nicht der Fall, da wir eine Interaktion mit dem übergeordneten Bereich benötigen. Daher möchten wir, dass einige Werte/Änderungen durchlaufen werden .. .. Aus diesem Grund verwenden wir:

1. "@"   (  Text binding / one-way binding )
2. "="   ( Direct model binding / two-way binding )
3. "&"   ( Behaviour binding / Method binding  )

@ bedeutet, dass die Änderungen des Controller-Bereichs im Direktive-Bereich angezeigt werden. Wenn Sie jedoch den Wert im Direktive-Bereich ändern, wirkt sich dies nicht auf die Controller-Bereichsvariable aus. 

@ erwartet immer, dass das zugeordnete Attribut ein Ausdruck ist. Dies ist sehr wichtig; Damit das Präfix „@“ funktioniert, müssen wir den Attributwert in {{}} einschließen. 

= ist bidirektional. Wenn Sie also die Variable im Gültigkeitsbereich ändern, wirkt sich dies auch auf die Controller-Bereichsvariable aus

& wird verwendet, um die Controller-Bereichsmethode zu binden, sodass wir sie bei Bedarf über die Direktive aufrufen können

Der Vorteil hierbei ist, dass der Name der Variablen im Controller- und im Direct-Geltungsbereich nicht identisch sein muss. 

Beispielsweise hat die Direktive scope eine Variable "dirVar", die mit der Variablen "contVar" des Controller-Bereichs synchronisiert wird. Dies verleiht der Direktive viel Leistung und Verallgemeinerung, da ein Controller mit der Variablen v1 synchronisieren kann, während ein anderer Controller, der dieselbe Direktive verwendet, DirVar mit der Variable v2 synchronisieren kann.

Unten ist das Anwendungsbeispiel:

Die Direktive und der Controller sind:

 var app = angular.module("app", []);
 app.controller("MainCtrl", function( $scope ){
    $scope.name = "Harry";
    $scope.color = "#333333";
    $scope.reverseName = function(){
     $scope.name = $scope.name.split("").reverse().join("");
    };
    $scope.randomColor = function(){
        $scope.color = '#'+Math.floor(Math.random()*16777215).toString(16);
    };
});
app.directive("myDirective", function(){
    return {
        restrict: "EA",
        scope: {
            name: "@",
            color: "=",
            reverse: "&"
        },
        link: function(element, scope, attrs){
           //do something like
           $scope.reverse(); 
          //calling the controllers function
        }
    };
});

Und die HTML (beachten Sie den Unterschied zwischen @ und =):

<div my-directive
  class="directive"
  name="{{name}}"
  reverse="reverseName()"
  color="color" >
</div>

Hier ist ein link zum Blog, der es schön beschreibt. 

33
Kop4lyf

Einfach können wir verwenden: - 

  1. @ : - für String-Werte für die einfache Datenanbindung. In einer Hinsicht können Datenbindungen nur an die Direktive übergeben werden

  2. = : - für den Objektwert für die bidirektionale Datenbindung. Bei der bidirektionalen Datenbindung können Sie den Gültigkeitsbereich sowohl in der Direktive als auch in der HTML-Datei ändern. 

  3. & : - für Methoden und Funktionen.

BEARBEITEN

In unserer Component Definition für Angular Version 1.5 und darüber
Es gibt vier verschiedene Arten von Bindungen:

  1. = wechselseitige Datenbindung : - wenn wir den Wert ändern, wird er automatisch aktualisiert
  2. < one way binding : - wenn wir einen Parameter nur aus einem übergeordneten Bereich lesen und nicht aktualisieren möchten.

  3. @ ist für String-Parameter

  4. & Dies ist für Callbacks falls Ihre Komponente etwas in den übergeordneten Bereich ausgeben muss

20
ojus kulkarni

Ich habe eine kleine HTML-Datei erstellt, die Angular-Code enthält, der die Unterschiede zwischen ihnen veranschaulicht:

<!DOCTYPE html>
<html>
  <head>
    <title>Angular</title>
    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.3.15/angular.min.js"></script>
  </head>
  <body ng-app="myApp">
    <div ng-controller="myCtrl as VM">
      <a my-dir
        attr1="VM.sayHi('Juan')" <!-- scope: "=" -->
        attr2="VM.sayHi('Juan')" <!-- scope: "@" -->
        attr3="VM.sayHi('Juan')" <!-- scope: "&" -->
      ></a>
    </div>
    <script>
    angular.module("myApp", [])
    .controller("myCtrl", [function(){
      var vm = this;
      vm.sayHi = function(name){
        return ("Hey there, " + name);
      }
    }])
    .directive("myDir", [function(){
      return {
        scope: {
          attr1: "=",
          attr2: "@",
          attr3: "&"
        },
        link: function(scope){
          console.log(scope.attr1);   // =, logs "Hey there, Juan"
          console.log(scope.attr2);   // @, logs "VM.sayHi('Juan')"
          console.log(scope.attr3);   // &, logs "function (a){return h(c,a)}"
          console.log(scope.attr3()); // &, logs "Hey there, Juan"
        }
      }
    }]);
    </script>
  </body>
</html>
11
RobertAKARobin

Der = Weg ist 2-Wege-Bindung, wodurch Sie live Änderungen in Ihrer Direktive vornehmen können. Wenn jemand diese Variable außerhalb der Direktive ändert, werden diese Daten in Ihrer Direktive geändert, aber @ ist keine bidirektionale Bindung. Es funktioniert wie Text. Sie binden einmal und Sie haben nur ihren Wert.

Um es klarer zu machen, können Sie diesen großartigen Artikel verwenden:

AngularJS-Richtlinie "@" und "="

6

Die lokale Bereichseigenschaft @ wird für den Zugriff auf Zeichenfolgenwerte verwendet, die außerhalb der Direktive definiert sind.

= In Fällen, in denen eine bidirektionale Bindung zwischen dem äußeren Bereich und dem Isolatebereich der Direktive erstellt werden muss, können Sie das Zeichen = verwenden.

& Mit der local-Bereichseigenschaft kann der Benutzer einer Direktive eine Funktion übergeben, die von der Direktive aufgerufen werden kann. 

Bitte überprüfen Sie den untenstehenden Link, der Ihnen ein klares Verständnis mit Beispielen vermittelt. Ich fand es sehr nützlich, also dachte ich darüber nach.

http://weblogs.asp.net/dwahlin/creating-custom-angularjs-directives-part-2-isolate-scope

3
Raphael

Selbst wenn der Bereich lokal ist, wie in Ihrem Beispiel, können Sie über die Eigenschaft $parent auf den übergeordneten Bereich zugreifen. Nehmen Sie im folgenden Code an, dass title im übergeordneten Bereich definiert ist. Sie können dann auf den Titel als $parent.title zugreifen:

link : function(scope) { console.log(scope.$parent.title) },
template : "the parent has the title {{$parent.title}}"

In den meisten Fällen wird der gleiche Effekt jedoch besser mit Attributen erzielt.

Ein Beispiel dafür, wo ich die "&" - Notation gefunden habe, die verwendet wird, um Daten aus dem isolierten Bereich über einen Ausdruck und an den übergeordneten Bereich zu übergeben. " für das Rendern einer speziellen Datenstruktur in einem Wiederholungsreport.

<render data = "record" deleteFunction = "dataList.splice($index,1)" ng-repeat = "record in dataList" > </render>

Ein Teil des Renderings war ein Delete-Button. Hier war es hilfreich, eine Deletefunktion von außerhalb mit & zu verknüpfen. In der Render-Direktive sieht es so aus

scope : { data = "=", deleteFunction = "&"},
template : "... <button ng-click = "deleteFunction()"></button>"

2-Wege-Datenbindung, d. H. data = "=" kann nicht verwendet werden, da die Löschfunktion bei jedem $digest-Zyklus ausgeführt wird, was nicht gut ist, da der Datensatz sofort gelöscht und niemals gerendert wird.

3
user3750988

Ich habe alle möglichen Optionen in einer Geige umgesetzt.

Es befasst sich mit allen Möglichkeiten:

scope:{
    name:'&'
},

scope:{
    name:'='
},

scope:{
    name:'@'
},

scope:{

},

scope:true,

https://jsfiddle.net/rishulmatta/v7xf2ujm

3
Rishul Matta

der Hauptunterschied zwischen ihnen ist nur 

@ Attribute string binding
= Two-way model binding
& Callback method binding
2
Ashish Kamble

@ Und = Sehen andere Antworten.

Eins gotcha ungefähr &
TL; DR;
& Erhält Ausdruck (funktioniert nicht nur wie in Beispielen in anderen Antworten) von einem übergeordneten Element und setzt es als Funktion in der Direktive, die den Ausdruck aufruft. Und diese Funktion kann jede Variable ersetzen (auch Funktionsname) des Ausdrucks, indem ein Objekt mit den Variablen übergeben wird.

erklärt
& Ist eine Ausdrucksreferenz, das heißt, wenn Sie etwas wie <myDirective expr="x==y"></myDirective> Übergeben
in der Direktive ist dieses expr eine Funktion, die den Ausdruck aufruft, wie:
function expr(){return x == y}.
also wird in der HTML-Anweisung <button ng-click="expr()"></button> den Ausdruck aufrufen. In js der Direktive wird nur $scope.expr() auch den Ausdruck aufrufen.
Der Ausdruck wird mit $ scope.x und $ scope.y des übergeordneten Elements aufgerufen.
Sie haben die Möglichkeit, die Parameter zu überschreiben!
Wenn Sie sie per Anruf einstellen, z. <button ng-click="expr({x:5})"></button>
dann wird der Ausdruck mit Ihrem Parameter x und dem übergeordneten Parameter y aufgerufen.
Sie können beide überschreiben.
Jetzt wissen Sie, warum <button ng-click="functionFromParent({x:5})"></button> funktioniert.
Da nur der Ausdruck von parent aufgerufen wird (z. B. <myDirective functionFromParent="function1(x)"></myDirective>) und mögliche Werte durch die angegebenen Parameter ersetzt werden, in diesem Fall x.
es könnte sein:
<myDirective functionFromParent="function1(x) + 5"></myDirective>
oder
<myDirective functionFromParent="function1(x) + z"></myDirective>
mit Kinderanruf:
<button ng-click="functionFromParent({x:5, z: 4})"></button>.
oder auch mit Funktionsersatz:
<button ng-click="functionFromParent({function1: myfn, x:5, z: 4})"></button>.

es ist nur ein Ausdruck, es spielt keine Rolle, ob es sich um eine Funktion oder um viele Funktionen handelt oder nur um einen Vergleich. Und Sie können beliebige Variable dieses Ausdrucks ersetzen.

Beispiele:
Direktivenvorlage vs aufgerufener Code:
Eltern haben $ scope.x, $ scope.y definiert:
übergeordnete Vorlage: <myDirective expr="x==y"></myDirective>
<button ng-click="expr()"></button> ruft $scope.x==$scope.y auf
<button ng-click="expr({x: 5})"></button> ruft 5 == $scope.y auf
<button ng-click="expr({x:5, y:6})"></button> ruft 5 == 6 auf

Eltern haben $ scope.function1, $ scope.x, $ scope.y definiert:
übergeordnete Vorlage: <myDirective expr="function1(x) + y"></myDirective>

<button ng-click="expr()"></button> ruft $scope.function1($scope.x) + $scope.y auf
<button ng-click="expr({x: 5})"></button> ruft $scope.function1(5) + $scope.y auf
<button ng-click="expr({x:5, y:6})"></button> ruft $scope.function1(5) + 6 auf
Die Direktive hat die Funktion $ scope.myFn:
<button ng-click="expr({function1: myFn, x:5, y:6})"></button> ruft $scope.myFn(5) + 6 auf

1
ya_dimon

@ bindet eine lokale/Direktive-Bereichseigenschaft an den ausgewerteten Wert des DOM-Attributs = bindet eine lokale/Direktive-Bereichseigenschaft an eine übergeordnete Bereichseigenschaft. & binding dient zum Übergeben einer Methode in den Geltungsbereich Ihrer Direktive, sodass sie innerhalb Ihrer Direktive aufgerufen werden kann.

@ Attributzeichenfolgenbindung = Zweiwege-Modellbindung & Callback-Methodenbindung

0
Ashish Kamble

Warum muss ich "{{title}}" mit "@" und "title" mit "=" verwenden?

Wenn Sie {{title}} verwenden, wird nur der übergeordnete Bereichswert an die Direktionsansicht übergeben und ausgewertet. Dies ist auf eine Möglichkeit beschränkt, was bedeutet, dass Änderungen nicht im übergeordneten Bereich angezeigt werden. Sie können '=' verwenden, wenn Sie die in der untergeordneten Anweisung vorgenommenen Änderungen auch im übergeordneten Bereich widerspiegeln möchten. Dies ist zwei Wege.

Kann ich auch direkt auf den übergeordneten Bereich zugreifen, ohne mein .__ zu verzieren. Element mit einem Attribut?

Wenn die Anweisung ein Bereichsattribut enthält (scope: {}), können Sie nicht mehr direkt auf den übergeordneten Bereich zugreifen. Es ist jedoch immer noch möglich, über scope. $ Parent usw. darauf zuzugreifen. Wenn Sie scope aus der Direktive entfernen, können Sie direkt darauf zugreifen.

In der Dokumentation heißt es: "Oft ist es wünschenswert, Daten aus dem isolierten Bereich ____ über einen Ausdruck und an den übergeordneten Bereich zu übergeben". scheint auch bei bidirektionaler Bindung gut zu funktionieren. Warum sollte der Ausdruck Weg besser sein?

Das hängt vom Kontext ab. Wenn Sie einen Ausdruck oder eine Funktion mit Daten aufrufen möchten, verwenden Sie & und wenn Sie Daten gemeinsam nutzen möchten, können Sie biderectional mit '=' verwenden.

Die Unterschiede zwischen verschiedenen Arten der Weitergabe von Daten an die Direktive finden Sie unter dem Link:

AngularJS - Isolierte Bereiche - @ vs = vs &

http://www.codeforeach.com/angularjs/angularjs-isolated-scopes-vs-vs

0
Prashanth

@ Attributzeichenfolgenbindung (einseitig) = Zweiwege-Modellbindung & Callback-Methodenbindung

0
Jatin Patel