L'optimisation des performances Web est le principal problème auquel chaque développeur d'applications Web fait attention. Les coureurs de taches tels que Grunt jouent un r?le clé dans le processus de développement. Nous utiliserons une gamme de plugins grognés pour garantir que les applications AngularJS peuvent être compressées en toute sécurité. Avant de discuter desjs Angular et de la compression, je tiens à souligner que les développeurs de tous les niveaux de compétence peuvent bénéficier de ce tutoriel, mais il est préférable d'avoir les bases du grognement. Dans cet article, nous utiliserons Grunt pour générer de nouveaux dossiers, donc les débutants grogn peuvent également avoir une bonne compréhension de son fonctionnement.

Points clés

• Les coureurs de taches comme Grunt automatisent les coutures et la compression du code, optimisant la vitesse de la page pendant le développement. Le plug-in grunt garantit que les applications AngularJS peuvent être compressées en toute sécurité.
• Par défaut, les applications AngularJS ne sont pas compressibles et doivent être écrites dans la syntaxe du tableau. Lorsque UglifyJS est en cours d'exécution, il renommée les paramètres, mais l'existence d'annotations DI dans le tableau les empêche d'être renommés, garantissant que les paramètres renommés ont toujours accès aux dépendances nécessaires.
• Le grognement peut être utilisé pour automatiser les processus d'annotation, d'épissage et de compression des applications AngularJS. Après avoir installé les plug-ins et configurer le grogne pour lire le fichier "package.json", la tache sera chargée et enregistrée. Configurez ensuite le plugin pour localiser des fichiers spécifiques.
• Grunt aide à écrire du code angulaire plus s?r en automatisant des taches qui capturent et empêchent les erreurs. Il peut exécuter des tests unitaires sur le code chaque fois que le fichier est enregistré, envoyant immédiatement une alerte d'erreur au développeur. L'automatisation fait gagner du temps et garantit que les taches importantes ne sont pas ignorées.

Problème de compression des applications angulaires

Les applications ArticleJS ne sont pas compressibles en toute sécurité par défaut. Ils doivent être écrits dans la syntaxe de la table. Si vous n'êtes pas s?r de la syntaxe du tableau, vous avez probablement écrit du code pour l'utiliser. Examinons deux exemples de contr?leurs angularjs qui passent les paramètres $scope et $http. Dans le premier exemple ci-dessous, l'usine et le contr?leur du module sont enveloppés dans un tableau commen?ant par une annotation Di, qui, comme vous pouvez le voir, ne suit pas le principe sec (ne vous répétez pas).

var form = angular.module('ControllerOne', [])
form.factory('Users', ['$http', function($http) {
    return {
        get: function() {
            return $http.get('/api/users');
        },
        create: function(userData) {
            return $http.post('/api/users', userData);
        },
        delete: function(id) {
            return $http.delete('/api/users/' + id);
        }
    };
}]);

form.controller('InputController', ['$scope', '$http', 'Users', function($scope, $http, Users) {
    formData = {};
    $scope.createUser = function () {
        if ($scope.formData != undefined) {
            Users.create($scope.formData)
                .success(function (data) {
                $scope.users = data;
                $scope.formData = {};
                $scope.myForm.$setPristine(true);
            });
        }
    };   
}]);

Dans l'exemple suivant, le code du module crud.config n'est toujours pas compressible, mais le code est plus court que les précédents. Il nomme simplement les services, puis transmet les dépendances nécessaires dans la fonction comme des paramètres sans les écrire comme des cha?nes en premier. Tant qu'il n'y a pas de compression, ce code s'exécutera normalement. Par conséquent, il est facile de comprendre pourquoi les gens choisissent souvent cette syntaxe lors de la rédaction du code AngularJS.

var form = angular.module('ControllerTwo', [])
form.factory('Users', function($http) {
    return {
        get: function() {
            return $http.get('/api/users');
        },
        create: function(userData) {
            return $http.post('/api/users', userData);
        },
        delete: function(id) {
            return $http.delete('/api/users/' + id);
        }
    };
});

form.controller('InputController', function($scope, $http, Users) {
    formData = {};
    $scope.createUser = function() {
        if ($scope.formData != undefined) {
            Users.create($scope.formData)
            .success(function(data) {
                $scope.users = data;
                $scope.formData = {};
                $scope.myForm.$setPristine(true);
            });        
        }
    };
});

Maintenant que vous avez compris les différences physiques entre ces deux pièces de code, j'expliquerai rapidement pourquoi cette syntaxe ne convient pas à la compression.

Comment fonctionne la notation du tableau

Comme mentionné ci-dessus, la notation du tableau commence par les annotations DI, qui joue un r?le clé dans la sécurité de la compression de code. Lorsque Uglifyjs est exécuté, il renommée nos paramètres de $scope et $http à a et b respectivement. L'existence d'annotations di a été transmise sous forme de cordes dans un tableau les empêche d'être renommés. Par conséquent, ces paramètres renommés ont toujours accès aux dépendances nécessaires. Si ces annotations n'existent pas, le code se cassera. Comme vous pouvez le voir, il est très inefficace d'écrire du code manuellement de cette manière. Pour vous aider à éviter cela, je vais maintenant vous montrer comment annoter, épisser et compresser les applications AngularJS de manière complètement optimisée en utilisant le grognement et les préparer à la production.

Utiliser grogn

L'ensemble du référentiel du projet peut être trouvé sur GitHub, y compris les fichiers que nous localiserons. Pour ceux qui ont l'habitude d'utiliser Grunt, vous pouvez continuer et créer votre propre version ou ajouter ce code à un projet existant. Si vous utilisez un répertoire vide, vous devez vous assurer qu'il existe un fichier "package.json" dans le répertoire. Ce fichier peut être créé en exécutant la commande npm init. Une fois que vous avez le fichier "package.json" dans votre projet, vous pouvez télécharger le plugin en exécutant la commande suivante:

var form = angular.module('ControllerOne', [])
form.factory('Users', ['$http', function($http) {
    return {
        get: function() {
            return $http.get('/api/users');
        },
        create: function(userData) {
            return $http.post('/api/users', userData);
        },
        delete: function(id) {
            return $http.delete('/api/users/' + id);
        }
    };
}]);

form.controller('InputController', ['$scope', '$http', 'Users', function($scope, $http, Users) {
    formData = {};
    $scope.createUser = function () {
        if ($scope.formData != undefined) {
            Users.create($scope.formData)
                .success(function (data) {
                $scope.users = data;
                $scope.formData = {};
                $scope.myForm.$setPristine(true);
            });
        }
    };   
}]);

Cela installera le grognement dans votre projet, et les trois plugins que nous utiliserons:

• grunt-contrib-concat
• grunt-contrib-uglify
• grunt-ng-annotate

Bien que Ng-Annotate puisse être utilisé sans grognement, vous verrez bient?t à quel point le grogne transparente fait le processus d'annoting, d'épissage et de compression de votre code. Il fournit une solution simple et efficace pour compresser le code AngularJS. Si vous suivez ce projet à partir de zéro, vous devriez avoir un gruntfile.js dans le répertoire racine du projet, qui contiendra tout le code grogn. Si vous ne l'avez pas déjà fait, créez-le maintenant.

Trois étapes pour générer du code de compression

étape 1 - Configurez Grunt pour lire le fichier "package.json"

Pour accéder au plugin que nous avons installé plus t?t, vous devez d'abord configurer la propriété pkg du gruntfile pour lire le contenu du fichier "package.json". L'objet config commence en haut de la fonction de wrapper grunt et s'étend de la ligne 3 à la ligne 5 dans l'exemple suivant, mais inclura bient?t la plupart du code.

var form = angular.module('ControllerTwo', [])
form.factory('Users', function($http) {
    return {
        get: function() {
            return $http.get('/api/users');
        },
        create: function(userData) {
            return $http.post('/api/users', userData);
        },
        delete: function(id) {
            return $http.delete('/api/users/' + id);
        }
    };
});

form.controller('InputController', function($scope, $http, Users) {
    formData = {};
    $scope.createUser = function() {
        if ($scope.formData != undefined) {
            Users.create($scope.formData)
            .success(function(data) {
                $scope.users = data;
                $scope.formData = {};
                $scope.myForm.$setPristine(true);
            });        
        }
    };
});

étape 2 - Chargement et enregistrement des taches de grognement

Après avoir configuré Grunt pour lire nos fichiers "package.json", les plugins doivent être chargés afin que le grognement puisse y accéder. Cela se fait en passant le nom du plugin en tant que cha?ne dans grunt.loadNpmTask(). Assurez-vous de vous assurer que ces plugins sont chargés à l'intérieur de la fonction de wrapper mais en dehors de l'objet . Si ces conditions ne sont pas remplies, le grognement ne fonctionnera pas correctement. Ce que nous devons faire ensuite, c'est créer une tache par défaut qui sera effectuée lorsque Grunt est appelé sans cible spécifique. Vous devez faire attention à l'ordre dans lequel ces taches sont ajoutées, car elles s'exécuteront en fonction de leur configuration. Ici, NganNotate est configuré pour s'exécuter en premier, puis Concat et UglifyJS, ce qui, je crois, est le meilleur moyen de créer votre code. De plus, il est important de se rappeler que config doit être placé après le chargement du plugin. Sur la base de ce que nous venons de discuter, GruntFile.js devrait ressembler à ceci: grunt.registerTask()

étape 3 - Configuration du plug-in

var form = angular.module('ControllerOne', [])
form.factory('Users', ['$http', function($http) {
    return {
        get: function() {
            return $http.get('/api/users');
        },
        create: function(userData) {
            return $http.post('/api/users', userData);
        },
        delete: function(id) {
            return $http.delete('/api/users/' + id);
        }
    };
}]);

form.controller('InputController', ['$scope', '$http', 'Users', function($scope, $http, Users) {
    formData = {};
    $scope.createUser = function () {
        if ($scope.formData != undefined) {
            Users.create($scope.formData)
                .success(function (data) {
                $scope.users = data;
                $scope.formData = {};
                $scope.myForm.$setPristine(true);
            });
        }
    };   
}]);

ngannotate

Maintenant que notre gruntfile est prêt, revenons à l'objet

et spécifions le fichier que nous voulons que le plugin ngannotate localise. Pour ce faire, nous devons d'abord créer une pièce pour ngannotate et créer une cible, appelée

dans ce cas. Dans cette cible, vous spécifiez le fichier dans lequel vous souhaitez ajouter des annotations DI et le dossier auquel il doit être généré. Dans cet exemple, Grunt prend les trois fichiers spécifiés dans

et les génère dans un nouveau dossier nommé config. Une fois la configuration terminée, vous pouvez exécuter spApp et voir comment le code est généré. De plus, vous pouvez visiter la page GitHub de grunt-ng-annotate et voir les différentes options qu'il vous permet de spécifier. public/js public/min-safe grunt ngAnnotate Split

var form = angular.module('ControllerTwo', [])
form.factory('Users', function($http) {
    return {
        get: function() {
            return $http.get('/api/users');
        },
        create: function(userData) {
            return $http.post('/api/users', userData);
        },
        delete: function(id) {
            return $http.delete('/api/users/' + id);
        }
    };
});

form.controller('InputController', function($scope, $http, Users) {
    formData = {};
    $scope.createUser = function() {
        if ($scope.formData != undefined) {
            Users.create($scope.formData)
            .success(function(data) {
                $scope.users = data;
                $scope.formData = {};
                $scope.myForm.$setPristine(true);
            });        
        }
    };
});

Maintenant que vous avez généré un dossier avec le code AngularJS avec les nouvelles annotations, continuons en compilant ou en épissant ce code dans un seul fichier. De la même manière que nous avons créé la section pour ngannotate, nous ferons maintenant de même pour Concat et UglifyJS. Comme NganNotate, les deux taches acceptent une cible, dans ce cas

. De nombreuses options de configuration peuvent être transmises dans ces taches, mais nous spécifions simplement

et

pour pointer vers le fichier correct. Comme vous pouvez le deviner, ces plugins obtiendront le contenu du fichier transmis à l'objet js et les traiteront dans le dossier spécifié après src. Essayons de comprendre ce qui se passe ici. Vous pouvez tester cela en exécutant dest dans votre terminal, cela devrait entra?ner la création de src. dest

var form = angular.module('ControllerOne', [])
form.factory('Users', ['$http', function($http) {
    return {
        get: function() {
            return $http.get('/api/users');
        },
        create: function(userData) {
            return $http.post('/api/users', userData);
        },
        delete: function(id) {
            return $http.delete('/api/users/' + id);
        }
    };
}]);

form.controller('InputController', ['$scope', '$http', 'Users', function($scope, $http, Users) {
    formData = {};
    $scope.createUser = function () {
        if ($scope.formData != undefined) {
            Users.create($scope.formData)
                .success(function (data) {
                $scope.users = data;
                $scope.formData = {};
                $scope.myForm.$setPristine(true);
            });
        }
    };   
}]);

Compression

La dernière chose que nous devons faire est de supprimer l'espace inutile du code en le compressant. C'est là que le plugin Uglifyjs entre en jeu. Lorsque vous utilisez UGLIFYJS, nous voulons que Grunt termine le processus final de compression de l'application. Par conséquent, nous voulons localiser le fichier contenant tous les nouveaux codes d'épissage, dans ce cas public/min/app.js. Pour tester cela, exécutez grunt uglify et affichez votre fichier nouvellement compressé. Voici les configurations pertinentes pour cette tache:

var form = angular.module('ControllerTwo', [])
form.factory('Users', function($http) {
    return {
        get: function() {
            return $http.get('/api/users');
        },
        create: function(userData) {
            return $http.post('/api/users', userData);
        },
        delete: function(id) {
            return $http.delete('/api/users/' + id);
        }
    };
});

form.controller('InputController', function($scope, $http, Users) {
    formData = {};
    $scope.createUser = function() {
        if ($scope.formData != undefined) {
            Users.create($scope.formData)
            .success(function(data) {
                $scope.users = data;
                $scope.formData = {};
                $scope.myForm.$setPristine(true);
            });        
        }
    };
});

Dans ce cours, nous avons utilisé toutes ces taches séparément. Maintenant, utilisons la tache par défaut que nous avons créée plus t?t. Il permet à Grunt d'exécuter toutes les taches spécifiées une par une dans l'ordre d'enregistrement. Maintenant, exécutez simplement grunt dans votre projet et votre code sera annoté, épissé et compressé.

Conclusion

J'espère qu'avec ce court tutoriel, vous pourrez bien comprendre la notation du tableau et pourquoi il est essentiel de rendre la compression de l'application AngularJS en sécurité. Si vous êtes nouveau dans le grognement, je vous recommande fortement d'essayer ces plugins ainsi que d'autres car ils peuvent gagner beaucoup de temps. Comme toujours, n'hésitez pas à commenter ci-dessous ou si vous avez des questions, veuillez m'envoyer un e-mail à l'adresse dans mon profil.

FAQ (FAQ) sur le code angulaire sécurisé de compression avec grogn

(La même partie FAQ doit être incluse ici que dans le texte d'origine, mais la langue est plus lisse et plus naturelle)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!