Het verschil tussen require(x) en import x

Ik ben net begonnen met het werken aan een klein knooppuntproject dat zal communiceren met een MongoDB. Ik krijg de relevante node-modules echter niet correct geïmporteerd, ook al heb ik ze correct geïnstalleerd via npm.

Bijvoorbeeld, de volgende code geeft een foutmelding, die me vertelt dat “express geen standaard export heeft”:

import express from "express";

Deze code werkt echter:

const express = require("express");

Dus mijn vraag is, wat is het verschil in de manier waarop de import- en variabele/vereiste-methoden werken?Ik zou graag willen repareren wat mijn importen in het project teistert, aangezien het waarschijnlijk lijkt te zijn later extra problemen veroorzaken.

Antwoord 1, autoriteit 100%

Dit eenvoudige diagram helpt me het verschil te begrijpen tussen requireen import.

Afgezien daarvan,

Je kuntniet selectief alleen de stukken laden die je nodig hebt met requiremaar met importskun je selectief alleen de stukken laden die je nodig hebt . Dat kan geheugen besparen.

Het laden is synchroon(stap voor stap) voor requireaan de andere kant kan importasynchroon zijn (zonder te wachten op eerdere import), dus het kan iets beter presteren danrequire.

Antwoord 2, autoriteit 33%

Het belangrijkste verschil tussen requireen importis dat requireautomatisch node_modulesscant om modules te vinden, maar import, dat van ES6 komt, doet dat niet.

De meeste mensen gebruiken babelom importen exportte compileren , waardoor importhetzelfde werkt als require.

De toekomstige versie van Node.js ondersteunt mogelijk importzelf (eigenlijk de experimentele versie doet dat al), en te oordelen naar de opmerkingen van Node.js, zal importnode_modulesniet ondersteunen, het is gebaseerd op ES6 en moet het pad van de module specificeren.

Dus ik raad je aan om importniet te gebruiken met babel, maar deze functie is nog niet bevestigd, het zou in de toekomst node_moduleskunnen ondersteunen, wie weet?

Ter referentie, hieronder is een voorbeeld van hoe babel de import-syntaxis van ES6 kan converteren naar de require-syntaxis van CommonJS.

Stel dat het bestandapp_es6.jsdeze import bevat:

import format from 'date-fns/format';

Dit is een instructie om de functie formatte importeren uit het node-pakket date-fns.

Het gerelateerde bestand package.jsonkan zoiets als dit bevatten:

"scripts": {
    "start": "node app.js",
    "build-server-file": "babel app_es6.js --out-file app.js",
    "webpack": "webpack"
}

Het gerelateerde .babelrc-bestand kan er ongeveer zo uitzien:

{
    "presets": [
        [
            "env",
            {
                "targets":
                {
                    "node": "current"
                }
            }
        ]
    ]
}

Dit build-server-file-script gedefinieerd in het bestand package.jsonis een instructie voor babel om het bestand app_es6.jste ontleden en voer het bestand app.jsuit.

Na het uitvoeren van het build-server-filescript, als u app.jsopent en zoekt naar de date-fnsimport, zal zien dat het in dit is omgezet:

var _format = require("date-fns/format");
var _format2 = _interopRequireDefault(_format);

Het grootste deel van dat bestand is voor de meeste mensen gobbledygook, maar computers begrijpen het.

Ook ter referentie, als voorbeeld van hoe een module kan worden gemaakt en geïmporteerd in uw project, als u date-fnsinstalleert en vervolgens node_modules/date-fns/get_year/index.jsje kunt zien dat het het volgende bevat:

var parse = require('../parse/index.js')
function getYear (dirtyDate) {
  var date = parse(dirtyDate)
  var year = date.getFullYear()
  return year
}
module.exports = getYear

Als je het bovenstaande babel-proces gebruikt, kan je bestand app_es6.jshet volgende bevatten:

import getYear from 'date-fns/get_year';
// Which year is 2 July 2014?
var result = getYear(new Date(2014, 6, 2))
//=> 2014

En babel zou de invoer converteren naar:

var _get_year = require("date-fns/get_year");
var _get_year2 = _interopRequireDefault(_get_year);

En behandel alle verwijzingen naar de functie dienovereenkomstig.

Antwoord 3, autoriteit 9%

Laat me een voorbeeld geven voor het opnemen van een express-module met required & importeren

-vereist

var express = require('express');

-importeren

import * as  express from 'express';

Dus na het gebruik van een van de bovenstaande uitspraken hebben we een variabele met de naam ‘express’ bij ons. Nu kunnen we de ‘app’-variabele definiëren als,

var app = express(); 

Dus we gebruiken ‘require’ met ‘CommonJS’ en ‘import’ met ‘ES6’.

Voor meer informatie over ‘vereisen’ & ‘import’, lees onderstaande links door.

require – Modules vereist in Node.js: Alles wat u moet weten

importeren – Een update over ES6-modules in Node.js

Antwoord 4, autoriteit 3%

Ik zal het eenvoudig maken,

• Importeren en exporteren zijn ES6-functies (Next gen JS).
• Vereist is een ouderwetse methode om code uit andere bestanden te importeren

Groot verschil zit in de vereiste, het gehele JS-bestand wordt aangeroepen of geïmporteerd. Zelfs als je een deel ervan niet nodig hebt.

var myObject = require('./otherFile.js'); //This JS file will be imported fully.

Terwijl u bij het importeren alleen objecten/functies/variabelen kunt extraheren die vereist zijn.

import { getDate }from './utils.js'; 
//Here I am only pulling getDate method from the file instead of importing full file

Een ander groot verschil is dat je requireoveral in het programma kunt gebruiken waar importaltijd bovenaan het bestand moet staan

Bewerken: in de nieuwste knooppuntversies kunt u destructuring gebruiken. Het ziet er zo uit

const { getDate } = require('./date.js');

Antwoord 5, autoriteit 3%

nieuwe ES6:

‘import’ moet worden gebruikt met ‘export’ sleutelwoorden om variabelen/arrays/objecten te delen tussen js-bestanden:

export default myObject;
//....in another file
import myObject from './otherFile.js';

old skool:

‘require’ moet worden gebruikt met ‘module.exports’

module.exports = myObject;
//....in another file
var myObject = require('./otherFile.js');