angularJS: come chiamare la funzione dell'ambito figlio nello scopo padre

Come si può chiamare un metodo definito nell'ambito figlio dal suo ambito padre?

function ParentCntl() {
    // I want to call the $scope.get here
}

function ChildCntl($scope) {
    $scope.get = function() {
        return "LOL";    
    }
}

http://jsfiddle.net/wUPdW/

Puoi usare $broadcastdal genitore a un bambino:

function ParentCntl($scope) {

    $scope.msg = "";
    $scope.get = function(){
        $scope.$broadcast ('someEvent');
        return  $scope.msg;        
    }
}

function ChildCntl($scope) {               
    $scope.$on('someEvent', function(e) {  
        $scope.$parent.msg = $scope.get();            
    });

    $scope.get = function(){
        return "LOL";    
    }
}

Violino funzionante: http://jsfiddle.net/wUPdW/2/

AGGIORNAMENTO : esiste un'altra versione, meno accoppiata e più testabile:

function ParentCntl($scope) {
    $scope.msg = "";
    $scope.get = function(){
        $scope.$broadcast ('someEvent');
        return  $scope.msg;        
    }

    $scope.$on('pingBack', function(e,data) {  
        $scope.msg = data;        
    });
}

function ChildCntl($scope) {               
    $scope.$on('someEvent', function(e) {  
        $scope.$emit("pingBack", $scope.get());        
    });

    $scope.get = function(){
        return "LOL";    
    }
}

Fiddle: http://jsfiddle.net/uypo360u/

Lasciami suggerire un'altra soluzione:

var app = angular.module("myNoteApp", []);


app.controller("ParentCntl", function($scope) {
    $scope.obj = {};
});

app.controller("ChildCntl", function($scope) {
    $scope.obj.get = function() {
            return "LOL";    
    };
});

Meno codice e utilizzo dell'ereditarietà prototipica.

Plunk

Registrare la funzione del bambino sul genitore quando il bambino sta inizializzando. Ho usato la notazione "as" per chiarezza nel modello.

MODELLO

<div ng-controller="ParentCntl as p">
  <div ng-controller="ChildCntl as c" ng-init="p.init(c.get)"></div>
</div>

CONTROLLORI

...
function ParentCntl() {
  var p = this;
  p.init = function(fnToRegister) {
    p.childGet = fnToRegister;
  };
 // call p.childGet when you want
}

function ChildCntl() {
  var c = this;
  c.get = function() {
    return "LOL";    
  };
}

"Ma", dici, " ng-init non dovrebbe essere usato in questo modo !". Ebbene sì, ma

1. quella documentazione non spiega perché no, e
2. Non credo che gli autori della documentazione abbiano considerato TUTTI i possibili casi d'uso.

Dico che questo è un buon uso per questo. Se vuoi farmi un downvote, per favore commenta con i motivi! :)

Mi piace questo approccio perché mantiene i componenti più modulari. Le uniche associazioni sono nel modello e significa che

• il Controller figlio non deve sapere nulla su quale oggetto aggiungere la sua funzione (come nella risposta di @ canttouchit)
• il controllo genitore può essere utilizzato con qualsiasi altro controllo figlio che abbia una funzione get
• non richiede la trasmissione, che diventerà molto brutta in una grande app a meno che tu non controlli strettamente lo spazio dei nomi degli eventi

Questo approccio si avvicina più da vicino all'idea di Tero di modularizzare con le direttive (si noti che nel suo esempio modularizzato,contestants è passato dalla direttiva genitore a quella "figlia" NEL MODELLO).

In effetti, un'altra soluzione potrebbe essere quella di considerare l'implementazione ChildCntldi una direttiva e utilizzare l' &associazione per registrare il initmetodo.

Puoi creare un oggetto figlio.

var app = angular.module("myApp", []);


app.controller("ParentCntl", function($scope) {
    $scope.child= {};
    $scope.get = function(){
      return $scope.child.get(); // you can call it. it will return 'LOL'
    }
   // or  you can call it directly like $scope.child.get() once it loaded.
});

app.controller("ChildCntl", function($scope) {
    $scope.obj.get = function() {
            return "LOL";    
    };
});

Qui il bambino si sta dimostrando destinazione del metodo get.