angularJS: Cómo llamar a la función de alcance secundario en el alcance principal

¿Cómo se puede llamar a un método definido en el ámbito secundario desde su ámbito principal?

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

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

http://jsfiddle.net/wUPdW/

Puede usar $broadcastde padre a hijo:

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";    
    }
}

Violín de trabajo: http://jsfiddle.net/wUPdW/2/

ACTUALIZACIÓN : Hay otra versión, menos acoplada y más comprobable:

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";    
    }
}

Violín: http://jsfiddle.net/uypo360u/

Permítanme sugerirles otra solución:

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


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

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

Menos código y usando herencia prototípica.

Ruido sordo

Registre la función del niño en el padre cuando el niño se está inicializando. Usé la notación "como" para mayor claridad en la plantilla.

MODELO

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

CONTROLADORES

...
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";    
  };
}

"Pero", dices, "¡ ng-init no se supone que se use de esta manera !". Bueno si pero

1. que la documentación no explica por qué no, y
2. No creo que los autores de la documentación hayan considerado TODOS los posibles casos de uso.

Digo que este es un buen uso para él. Si quieres rechazarme, ¡comenta con las razones! :)

Me gusta este enfoque porque mantiene los componentes más modulares. Los únicos enlaces están en la plantilla y significa que

• el controlador secundario no tiene que saber nada sobre a qué objeto agregar su función (como en la respuesta de @ canttouchit)
• el control principal se puede usar con cualquier otro control secundario que tenga una función de obtención
• no requiere transmisión, lo que se pondrá muy feo en una gran aplicación a menos que controle estrictamente el espacio de nombres del evento

Este enfoque se acerca más a la idea de Tero de modularizar con directivas (nótese que en su ejemplo modularizado, contestantsse pasa de directiva padre a "hijo" EN LA PLANTILLA).

De hecho, otra solución podría ser considerar implementar el ChildCntlcomo una directiva y usar el &enlace para registrar el initmétodo.

Puedes hacer un objeto secundario.

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";    
    };
});

Aquí el niño está probando el destino del método get.