Recentemente, eu estava lendo o Guia Autoritativo do AngularJS. Por várias razões (principalmente porque não tenho dinheiro, eu odeio, então escolhi baixar a versão eletrônica online (porque não custa dinheiro, haha ...). A fonte é bastante clara e o efeito geral é muito bom. Aprenda, mas não quer aprender o número da página, mas não quer aprender?
Felizmente, antes de ler e-books, eu era um pouco básico. Aprendi um pouco de assistir a vídeos, desde a ligação de dados bidirecionais aos serviços e, em seguida, ao sistema de instruções, tive mais ou menos contato. Além disso, durante uma tarefa de seleção de cursos especiais da Web, um sistema simples de gerenciamento de classe de estudantes foi construído através do AngularJS no front end e NodeJs no back -end e o Mongoose no back -end. Como não tenho dinheiro, só posso colocá -lo no Github. Endereço do GitHub: Sistema de gerenciamento de estudantes, bem -vindo ao Fork, vamos ao tópico abaixo ...
=============================================================================================================
Geralmente, existem três maneiras de um objeto obter controle sobre sua dependência:
(1) criar dependências internamente;
(2) referências através de variáveis globais;
(3) Passe pelos parâmetros quando necessário.
A injeção de dependência é alcançada da terceira maneira. Os outros dois métodos trarão vários problemas, como poluir o escopo global, tornando extremamente difícil o isolamento, etc. A injeção de dependência é um padrão de design que remove as dependências codificadas, para que as dependências possam ser alteradas ou até removidas em tempo de execução.
A capacidade de modificar as dependências em tempo de execução é ideal para testes, pois nos permite criar um ambiente isolado, onde objetos ridicularizados podem ser usados em vez de objetos reais no ambiente de produção.
De uma perspectiva funcional, a injeção de dependência encontrará automaticamente a dependência antecipadamente e informará o recurso dependente do alvo de injeção, para que o recurso possa ser injetado imediatamente quando o destino precisar.
Ao escrever componentes que dependem de outros objetos ou bibliotecas, precisamos descrever as dependências entre os componentes. Durante o tempo de execução, o injetor cria uma instância da dependência e é responsável por transmiti -lo ao consumidor dependente.
// Excelente exemplo da Função de documentação angular Someclass (cumprimentador) {this.Greeter = greater;} someclass.prototype.greetName = function (name) {this.Greeter.Greet (nome);}; // Observe que o código da amostra cria um controlador do escopo global, que não é uma boa idéia.Someclass é capaz de acessar o cumprimento interno em tempo de execução, mas não se importa como obter uma referência ao cumprimento. Para obter uma referência à instância do cumprimento, o criador do Someclass é responsável por construir suas dependências e passá -las.
Pelas razões acima, o AngularJS usa $ injetor (serviço injetor) para gerenciar consultas e instanciação de dependências. De fato, o $ inletor é responsável por instantar todos os componentes do AngularJs, incluindo os módulos, instruções e controladores do aplicativo.
Em tempo de execução, o $ inletor é responsável por instantar qualquer módulo quando iniciar e passar todas as dependências em que precisa.
Por exemplo, o código a seguir. Este é um aplicativo simples que declara um módulo e um controlador:
angular.module ('myApp', []).Quando o AngularJS instancia este módulo, ele procura um cumprimento e passa naturalmente referências a ele:
<div ng-app = "myApp"> <div ng-controller = "myController"> <button ng-click = "sayhello ()"> hello </butut> </div> </div>
Internamente, o processo de processamento do AngularJS é o seguinte:
// usa o injetor para carregar o aplicativo var injector = angular.injector (['ng', 'myApp']); // carrega o serviço $ controlador através do injetor var $ controlador = injetor.get ('$ controlador); MyController = $ controlador ('MyController', {$ SCOPE: SCOPE});O código acima não especifica como encontrar um cumprimento, mas funciona corretamente porque o $ injetor será responsável por encontrá -lo e carregá -lo para nós.
AngularJS extrai a lista de parâmetros da função passada durante a instanciação através da função de anotação. Digite o código a seguir nas ferramentas de desenvolvedor do Chrome para visualizar esta função:
> injetor.annotate (function ($ q, cumprimentador) {}) ["$ q", "Greeter"]Em qualquer aplicativo AngularJS, o $ injetor está funcionando, sabendo ou não. Ao escrever um controlador, se nenhuma tag [] for usada ou a declaração explícita for feita, o $ injetor tenta inferir dependências por nomes de parâmetros.
Declaração de injeção inferida
Se não houver declaração explícita, o AngularJS assume que o nome do parâmetro é o nome da dependência. Portanto, ele chamará internamente o método tostring () do objeto de função, analisará e extrairá a lista de parâmetros da função e injetará esses parâmetros na instância do objeto através de $ injetor. O processo de injeção é o seguinte:
injetor.inVoke (função ($ http, cumprimentador) {});Observe que esse processo é aplicável apenas ao código não compactado e ofuscado, pois o AngularJS requer uma lista de parâmetros não compactados brutos para análise. Com esse processo de inferir com base em nomes de parâmetros, a ordem dos parâmetros é de pouco significado, porque o AngularJS nos ajudará a injetar propriedades na ordem correta.
Injetar explicitamente declarações
O AngularJS fornece métodos explícitos para definir claramente as dependências que uma função precisa usar quando é chamada. A declaração de dependências dessa maneira ainda pode funcionar corretamente, mesmo que o código -fonte seja compactado e o nome do parâmetro mude. A propriedade $ inject pode ser usada para implementar a função da injeção explícita de declarações. A propriedade $ injeção de um objeto de função é uma matriz, o tipo de elemento da matriz é uma string e seus valores são o nome do serviço que precisa ser injetado.
Aqui está o código de amostra:
var acontrollerFactory = function acontroller ($ scope, cumprimentador) {console.log ("controlador carregado", cumprimentador); // ... controlador}; acontrollerFactory. $ inject = ['$ scope', 'Greeter']; // cumprimentador Console.log ("Serviço Greeters");} // Nosso controlador de aplicativos angular.module ('myApp', []). 'myApp']), controlador = injetor.get ('$ controlador'), rootscope = injetor.get ('$ rootscope'), newscope = rootscope.Para este método de declaração, a ordem dos parâmetros é muito importante, porque a ordem dos elementos de matriz $ inject deve corresponder um por um à ordem dos parâmetros injetados. Esse método de declaração pode ser executado no código compactado porque as informações relevantes da declaração já estão vinculadas à própria função.
Declaração de injeção intra-linha
A última maneira de injetar declarações fornecidas pelo AngularJS é uma declaração de injeção em linha que pode ser usada a qualquer momento. Esse método é na verdade um açúcar sintático, o que é exatamente o mesmo que o princípio mencionado acima para injetar declarações através da propriedade $ inject, mas nos permite passar parâmetros de dentro da linha quando a função é definida. Além disso, evita o uso de variáveis temporárias durante o processo de definição.
Ao definir um objeto AngularJS, a declaração em linha nos permite passar uma matriz de parâmetros diretamente em vez de uma função. Os elementos da matriz são strings, que representam os nomes de dependências que podem ser injetados no objeto. O último parâmetro é o objeto em si da injeção de dependência.
Exemplos são os seguintes:
angular.module ('myApp').Como o que precisa ser processado é uma lista de strings, as declarações de injeção em linha também podem ser executadas normalmente no código compactado. Geralmente é usado por colchetes e o símbolo [] que declara a matriz.
A injeção de dependência do AngularJS acima é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.