Explication détaillée des exportations en js

Cet article partage principalement avec vous l'explication détaillée des exports en js, principalement sous forme de code, j'espère qu'il pourra aider tout le monde.

Recommandations vidéo associées : 1.JavaScript Quick Start_Jade Girl Heart Sutra Series
Recommandations manuelles associées : 1.JavaScript Manuel de référence chinois

Écriture 1

exports.hello = function(){
    console.log(‘world’);
}

Écriture 2

var f = {
    hello : function(){
        console.log(‘world’);
    }
}
module.exports = f;

Supposons que le nom de fichier du module que nous écrivons soit hello.js, exécutez le code suivant

var h = require(‘hello’);
h.hello();

Pour les deux méthodes d'écriture ci-dessus, le résultat après l'exécution de ce code est le même.

module.exports :

Par exemple :

1,

//a.js
module.exports = ['aaa',18]
//b.js
var a= require('a')console.log(a[1]) //输出18

2,

//a.js
module.exports =function(){
this.show=function(){
console.log('hahah~');
}
}
//b.js
var a= require('a');
var obj = new a();obj .show();//输出hahah~
module.exports

Je crois comprendre que : vous attribuez quelque chose à module.exports, et vous obtiendrez quelque chose après require

exports ： 

//a.js
exports.show =function(){
console.log('hahah~');
}
//b.js
var a= require('a');
a.show();//输出hahah~

exports est déjà un objet, vous pouvez ajouter des attributs à cet objet , et après require, vous obtiendrez l’objet exports.

Mais vous ne pouvez pas attribuer un nouvel objet aux exports, comme exports={}

Il convient également de noter que si module.exports a déjà du contenu, alors toutes les opérations d'exports seront invalides . Rappelez-vous

Parlons encore du prototype. A quoi sert le prototype ? C'est pour ajouter des attributs au prototype. Le prototype est comme la classe parent en C++.

//a.js
module.exports =function(){
}
module.exports.prototype.show = function(){
console.log('hahah~');
}
//b.js
var a= require('a');
var obj = new a()
obj.show()//输出hahah~

Enfin, parlons des méthodes de classe. En ce qui concerne les classes, module.exports doit être utilisé.

Les châtaignes sont là

1.

//a.js
module.exports =function(){
}
module.exports.show = function(){
console.log('hahah~');
}
//b.js
var a= require('a');
a.show()//输出hahah~
##module.exports与exports的区别

Chaque fichier d'exécution node.js crée automatiquement un objet module. créé Un attribut appelé exports, la valeur initialisée est {}

module.exports = {};
Node.js为了方便地导出功能函数，node.js会自动地实现以下这个语句
foo.js
exports.a = function(){
console.log('a')
}
exports.a = 1 
test.js
var x = require('./foo');
console.log(x.a)

En voyant cela, je pense que tout le monde a vu la réponse, exports fait référence à la valeur de module.exports.

Lorsque module.exports est modifié, les exportations ne seront pas modifiées, et lorsque le module est exporté, l'exécution réelle exportée est module.exports, pas exports

Regardez l'exemple suivant

foo.js
exports.a = function(){
 console.log('a')
}
module.exports = {a: 2}
exports.a = 1 
test.js
var x = require('./foo');
console.log(x.a)
result:
2

les exportations deviendront invalides après la modification de module.exports.

Commencez-vous à vous sentir un peu éclairé ? Voici quelques méthodes d'utilisation couramment utilisées dans les modules open source.

##module.exports = View
function View(name, options) { 
  options = options || {};
  this.name = name;
  this.root = options.root;
  var engines = options.engines;
  this.defaultEngine = options.defaultEngine;
  var ext = this.ext = extname(name);
  if (!ext && !this.defaultEngine) throw new Error('No default engine was specified and no         extension was provided.');
  if (!ext) name += (ext = this.ext = ('.' != this.defaultEngine[0] ? '.' : '') +     this.defaultEngine);
  this.engine = engines[ext] || (engines[ext] = require(ext.slice(1)).__express);
  this.path = this.lookup(name);
}
module.exports = View;

Il y a un dicton en JavaScript selon lequel la fonction est un objet, la vue est un objet, module.export =View, ce qui équivaut à exporter l'intégralité de l'objet de vue.

Lorsqu'un module externe l'appelle, il peut appeler toutes les méthodes de View. Cependant, il convient de noter que seules les méthodes statiques de View peuvent être appelées. Les méthodes créées par prototype sont des méthodes privées de View.

foo.js
function View(){
}
View.prototype.test = function(){
 console.log('test')
}
View.test1 = function(){
 console.log('test1')
}
module.exports = View
test.js
var x = require('./foo');
console.log(x) //{ [Function: View] test1: [Function] }
console.log(x.test) //undefined
console.log(x.test1) //[Function]
x.test1() //test1
##var app = exports = module.exports = {};

En fait, quand on comprend le principe, il n'est pas difficile de comprendre que cette façon d'écrire est un peu redondante. En fait, il s'agit de garantir l'environnement d'initialisation du. le module est propre. En même temps, cela nous convient également. Même après avoir modifié l'objet pointé par module.exports, nous pouvons toujours utiliser les caractéristiques de l'export

exports = module.exports = createApplication;
/**
 * Expose mime.
 */
exports.mime = connect.mime;

par exemple, dans quel module. exports = createApplication modifie module.exports, laissez Exports n'est pas valide et la méthode exports = module.exports peut être utilisée pour restaurer ses caractéristiques d'origine.

##exports.init= function(){}

Il s'agit de la méthode d'initialisation de module la plus simple et directement exportée.

##var mongoose = module.exports = exports = new Mongoose;

Il a plusieurs fonctions, mais d'après la description ci-dessus, vous ne devriez pas pouvoir obtenir la réponse.

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!