वेबपैक में पर्यावरण पर निर्भर चर पास करना


306

मैं एक कोणीय ऐप को गल्प से वेबपैक में बदलने की कोशिश कर रहा हूं। gulp में मैं NODE_ENV के आधार पर html पृष्ठ (जैसे डेटाबेस नाम) में कुछ चर को बदलने के लिए gulp-preprocess का उपयोग करता हूं। वेबपैक के साथ समान परिणाम प्राप्त करने का सबसे अच्छा तरीका क्या है?


1
क्या उर्फ ​​आपके लिए काम करता है?
जुहो वेपसैलीन

1
@bebraw: इससे पहले कि मैं एलियास के आसपास अपना सिर पाने में सक्षम था, मैंने डेफिनप्लगिन () के आधार पर आपके द्वारा सुझाए गए अन्य समाधान को लागू किया। अब मैं देख रहा हूं कि अलियास एक बेहतर समाधान होगा और शायद कभी-कभी रिफ्लेक्टर होगा - धन्यवाद। यदि आप अपने दो समाधानों को एक उत्तर में शामिल करना चाहते हैं तो मैं इसे खुशी से स्वीकार करूंगा।
kpg

2
कंसोल संदेश के माध्यम से यहां निर्देशित किया गया था। Browserify में इसे कैसे ठीक करें?
जीएन।

2
क्या यह प्रश्न बिल्ड समय या लोड समय पर एसपीए को कॉन्फ़िगर करने की कोशिश कर रहा है? मैं एसपीए के लिए दो प्रकार के कॉन्फ़िगरेशन पर ध्यान देता हूं: 1) विकास या उत्पादन मोड, और 2) परिनियोजन वातावरण, जैसे विकास, मंचन, उत्पादन। मुझे लगता है कि NODE_ENV का उपयोग बिल्ड समय पर (1) के लिए कॉन्फ़िगर करने के लिए किया जा सकता है लेकिन हम तैनाती के लिए (2) को कैसे कॉन्फ़िगर करते हैं, उदाहरण के लिए अलग-अलग परिनियोजन वातावरणों के लिए उत्पादन मोड कॉन्फ़िगर करना। मुझे उम्मीद है कि यह इस सवाल के लिए प्रासंगिक है।
एशले ऐटकन

1
@AshleyAitken का महान प्रश्न, जिसके बारे में मुझे इस सूत्र पर कोई उत्तर नहीं मिला (हो सकता है कि मैं इसे याद करूँ), लेकिन इस नए सूत्र को पोस्ट किया: stackoverflow.com/questions/44464504/…
डेविड टेसर

जवाबों:


427

इसे प्राप्त करने के दो मूल तरीके हैं।

DefinePlugin

new webpack.DefinePlugin({
    'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development')
}),

ध्यान दें कि यह केवल मैचों को "जैसा है" को बदल देगा। यही कारण है कि स्ट्रिंग प्रारूप में है। आपके पास अधिक जटिल संरचना हो सकती है, जैसे कि वहां एक वस्तु लेकिन आपको विचार मिलता है।

EnvironmentPlugin

new webpack.EnvironmentPlugin(['NODE_ENV'])

EnvironmentPluginDefinePluginआंतरिक रूप से उपयोग करता है और इसके माध्यम से कोड करने के लिए पर्यावरण के मूल्यों को मैप करता है। Terser सिंटैक्स।

उपनाम

वैकल्पिक रूप से आप अलियास मॉड्यूल के माध्यम से कॉन्फ़िगरेशन का उपभोग कर सकते हैं । उपभोक्ता की ओर से यह इस तरह दिखेगा:

var config = require('config');

कॉन्फ़िगरेशन स्वयं इस तरह दिख सकता है:

resolve: {
    alias: {
        config: path.join(__dirname, 'config', process.env.NODE_ENV)
    }
}

आइए बताते process.env.NODE_ENVहै development। यह ./config/development.jsतब में मैप होगा । इस तरह से इसे मैप करने वाला मॉड्यूल कॉन्फ़िगरेशन को निर्यात कर सकता है:

module.exports = {
    testing: 'something',
    ...
};

3
इस तथ्य को इंगित करने के लिए धन्यवाद कि यह मैचों को "जैसा है" बदलता है। मैं थोड़ी देर के लिए यह जानने के लिए संघर्ष कर रहा था कि मेरा कोड एक त्रुटि क्यों निकाल रहा था और ऐसा इसलिए था क्योंकि मैं मान को एक में नहीं लपेट रहा थाJSON.stringify()
pbojinov

4
यदि आप ES2015 का उपयोग कर रहे हैं, तो आप 'process.env.NODE_ENV': `"${process.env.NODE_ENV || 'development'}"`
user2688473

1
@ tybro0103 JSON.stringify('development')जैसा कि वास्तव में उपयोगी नहीं हो सकता है। इसके बजाय JSON.stringify(someVariable)काफी हो सकता है!
सुपरजोस

1
आपको NODE_ENVऐसा करने के लिए तैयार होना चाहिए । कैसे सेट करें कि आपके प्लेटफ़ॉर्म पर निर्भर करता है।
जुहो वेपसैलीन 16

1
@AnyulRivas हाँ। रिएक्ट process.env.NODE_ENVपैटर्न का उपयोग करता है और यह काम करता है।
जुहो वेपसैलीन

109

बस एक और विकल्प, यदि आप केवल एक क्लि इंटरफ़ेस का उपयोग करना चाहते हैं, तो बस defineवेबपैक के विकल्प का उपयोग करें। मैं निम्नलिखित स्क्रिप्ट को अपने में जोड़ता हूं package.json:

"build-production": "webpack -p --define process.env.NODE_ENV='\"production\"' --progress --colors"

इसलिए मुझे बस दौड़ना है npm run build-production


2
क्या इसके लिए प्रलेखन है? मैं Google --define नहीं कर सकता :(
रिचर्ड

5
Webpack @ 2 के लिए, "-p" पहले से ही शॉर्टकट के लिए है-optimize-minimal -define process.env.NODE_ENV = "प्रोडक्शन"
okm

@okm डॉक्स का उल्लेख -p-to -imize-मिनीमाइज़-अपॉइंटमेंट-घटना-क्रम के बराबर है, इसलिए --define process.env.NODE_ENV = "उत्पादन" का कोई उल्लेख नहीं है। क्या यह कुछ ऐसा है जिसे हटा दिया गया है?
नादर घनबारी

1
@NaderHadjiGhanbari यह वेबपैक संस्करण 2 में है webpack.js.org/api/cli/#shortcuts
okm

73

मैंने पर्यावरण-विशिष्ट चर सेट करने के तरीके पर कुछ विकल्पों की जांच की और इसके साथ समाप्त हुआ:

मेरे पास वर्तमान में 2 वेबपैक कॉन्फ़िगर हैं:

webpack.production.config.js

new webpack.DefinePlugin({
  'process.env':{
    'NODE_ENV': JSON.stringify('production'),
    'API_URL': JSON.stringify('http://localhost:8080/bands')
  }
}),

webpack.config.js

new webpack.DefinePlugin({
  'process.env':{
    'NODE_ENV': JSON.stringify('development'),
    'API_URL': JSON.stringify('http://10.10.10.10:8080/bands')
  }
}),

मेरे कोड में मुझे इस (संक्षिप्त) तरीके से API_URL का मान मिलता है:

const apiUrl = process.env.API_URL;

नवंबर, 2016 का EDIT 3rd

वेबपैक डॉक्स का एक उदाहरण है: https://webpack.js.org/plugins/define-plugin/#usage

new webpack.DefinePlugin({
    PRODUCTION: JSON.stringify(true),
    VERSION: JSON.stringify("5fa3b9"),
    BROWSER_SUPPORTS_HTML5: true,
    TWO: "1+1",
    "typeof window": JSON.stringify("object")
})

ESLint के साथ आपको विशेष रूप से कोड में अपरिभाषित चर की अनुमति देने की आवश्यकता है, यदि आपके पास no-undefशासन है। http://eslint.org/docs/rules/no-undef इस तरह:

/*global TWO*/
console.log('Running App version ' + TWO);

EDIT 7 सितंबर, 2017 (बनाएँ-प्रतिक्रिया-ऐप विशिष्ट)

यदि आप बहुत अधिक कॉन्फ़िगर नहीं कर रहे हैं, तो Create-React-App: Create-React-App - कस्टम एनवायरमेंट वेरिएबल्स को जोड़कर देखें । हुड के तहत सीआरए वैसे भी वेबपैक का उपयोग करता है।


2
क्या आपने पाया कि यह किसी भी पर्यावरण चर को रन टाइम में पारित होने से रोकता है? यदि आप पूरे की जगह लेते हैं process.envतो process.env.PORTउदाहरण undefinedके लिए वेबपैक के निर्माण के दौरान हल नहीं होता है जिसका अर्थ है कि आप अब पर्यावरण से बंदरगाह को ओवरराइड नहीं कर सकते हैं?
djskinner

बहुत बहुत धन्यवाद। अंत में इस मुद्दे पर एक जवाब जो समझ में आता है!
डेव सग

प्रक्रिया क्या है? यह कहां से आ रहा है? यदि यह एक नोड ऑब्जेक्ट है, तो यह ब्राउज़र में कैसे मिलता है?
डैनियल बिरोव्स्की पोप्सकी

यह एक भयानक समाधान है, आपके पास NODE_ENV और API_URL
ब्रायन ऑग्डेन

1
@BrianOgden हां, यह वास्तव में है, आपको इसके लिए वेबपैक -मर्ज जैसी किसी चीज का उपयोग करना चाहिए: npmjs.com/package/webpack-merge - यह इस प्रश्न IMO के लिए थोड़ा बाहर है।
Thevangelist

24

आप पास कर सकते हैं किसी भी कमांड लाइन तर्क अतिरिक्त प्लगइन के बिना का उपयोग कर --envwebpack 2 के बाद से:

webpack --config webpack.config.js --env.foo=bar

Webpack.config.js में चर का उपयोग करना:

module.exports = function(env) {
    if (env.foo === 'bar') {
        // do something
    }
}

स्रोत


22

आप सीधे EnvironmentPluginउपलब्ध में उपयोग कर सकते हैंwebpack ट्रांसप्लिकेशन के दौरान किसी भी पर्यावरण चर का उपयोग करने के लिए ।

आपको बस अपनी webpack.config.jsफ़ाइल में प्लगइन की घोषणा करनी है :

var webpack = require('webpack');

module.exports = {
    /* ... */
    plugins = [
        new webpack.EnvironmentPlugin(['NODE_ENV'])
    ]
};

ध्यान दें कि आपको स्पष्ट रूप से उस पर्यावरण चर का नाम घोषित करना होगा जिसका आप उपयोग करना चाहते हैं।


4
इस उपयोग के मामले के साथ वेबपैक डॉक्स में एक उदाहरण है। github.com/webpack/docs/wiki/list-of-plugins#environmentplugin
Technetium

1
यदि आप अपने पर्यावरण चर को .env फ़ाइल में रखना चाहते हैं, तो आप dotenv पैकेज का उपयोग कर सकते हैं और इसे webpack.config.js में आरंभ कर सकते हैं। npmjs.com/package/dotenv
जस्टिन

13

व्यक्तिगत रूप से उत्तरों का गुच्छा जोड़ने के लिए मैं निम्नलिखित पसंद करता हूं:

const webpack = require('webpack');
const prod = process.argv.indexOf('-p') !== -1;

module.exports = {
  ...
  plugins: [
    new webpack.DefinePlugin({
      process: {
        env: {
          NODE_ENV: prod? `"production"`: '"development"'
        }
      }
    }),
    ...
  ]
};

इसका उपयोग करना कोई फंकी एनवी वैरिएबल या क्रॉस-प्लेटफ़ॉर्म समस्याएँ (एनवी वर्सेस के साथ) नहीं है। आप जो कुछ भी करते हैं वह क्रमशः सामान्य webpackया webpack -pदेव या उत्पादन के लिए चलाया जाता है।

संदर्भ: जीथब मुद्दा


जब प्रक्रिया के लिए परिभाषित मान 'process.env.NODE_ENV': JSON.stringify('production')खत्म हो जाते हैं process: { env: { NODE_ENV: JSON.stringify('production') } }। उत्तरार्द्ध का उपयोग करने से प्रक्रिया ऑब्जेक्ट को अधिलेखित कर देगा जो कुछ मॉड्यूल के साथ संगतता को तोड़ सकता है जो प्रक्रिया ऑब्जेक्ट पर अन्य मूल्यों को परिभाषित करने की अपेक्षा करते हैं।
slorenzo

13

चूंकि thevangelist द्वारा उपरोक्त पोस्ट पर मेरे संपादन को मंजूरी नहीं दी गई थी , अतिरिक्त जानकारी पोस्ट करना।

यदि आप एक निर्धारित संस्करण संख्या की तरह package.json से मान चुनना चाहते हैं और जावास्क्रिप्ट के अंदर DefinePlugin के माध्यम से इसे एक्सेस करना चाहते हैं ।

{"version": "0.0.1"}

फिर, आयात package.json संबंधित अंदर webpack.config , पहुँच विशेषता आयात चर का उपयोग कर, बाद में विशेषता का उपयोग DefinePlugin

const PACKAGE = require('../package.json');
const _version = PACKAGE.version;//Picks the version number from package.json

उदाहरण के लिए webpack.config पर कुछ कॉन्फ़िगरेशन, DefinePlugin के लिए METADATA का उपयोग कर रहा है:

const METADATA = webpackMerge(commonConfig({env: ENV}).metadata, {
  host: HOST,
  port: PORT,
  ENV: ENV,
  HMR: HMR,
  RELEASE_VERSION:_version//Version attribute retrieved from package.json
});

new DefinePlugin({
        'ENV': JSON.stringify(METADATA.ENV),
        'HMR': METADATA.HMR,
        'process.env': {
          'ENV': JSON.stringify(METADATA.ENV),
          'NODE_ENV': JSON.stringify(METADATA.ENV),
          'HMR': METADATA.HMR,
          'VERSION': JSON.stringify(METADATA.RELEASE_VERSION)//Setting it for the Scripts usage.
        }
      }),

इसे किसी भी टाइपस्क्रिप्ट फ़ाइल के अंदर एक्सेस करें:

this.versionNumber = process.env.VERSION;

सबसे स्मार्ट तरीका इस तरह होगा:

// webpack.config.js
plugins: [
    new webpack.DefinePlugin({
      VERSION: JSON.stringify(require("./package.json").version)
    })
  ]

रॉस एलन को धन्यवाद


11

बस एक और उत्तर जो @ zer0chain के उत्तर के समान है। हालांकि, एक भेद के साथ।

सेटिंग webpack -pपर्याप्त है।

यह इस प्रकार है:

--define process.env.NODE_ENV="production"

और यह जैसा है वैसा ही है

// webpack.config.js
const webpack = require('webpack');

module.exports = {
  //...

  plugins:[
    new webpack.DefinePlugin({
      'process.env.NODE_ENV': JSON.stringify('production')
    })
  ]
};

तो आपको केवल package.jsonनोड फ़ाइल में कुछ इस तरह की आवश्यकता हो सकती है :

{
  "name": "projectname",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "debug": "webpack -d",
    "production": "webpack -p"
  },
  "author": "prosti",
  "license": "ISC",
  "dependencies": {    
    "webpack": "^2.2.1",
    ...
  }
}

DefinePlugin से बस कुछ सुझाव :

डेफिनप्लगिन आपको वैश्विक स्थिरांक बनाने की अनुमति देता है जिसे संकलन समय पर कॉन्फ़िगर किया जा सकता है। यह विकास बिल्ड और रिलीज़ बिल्ड के बीच विभिन्न व्यवहार की अनुमति देने के लिए उपयोगी हो सकता है। उदाहरण के लिए, आप यह निर्धारित करने के लिए एक वैश्विक स्थिरांक का उपयोग कर सकते हैं कि क्या लॉगिंग होती है; शायद आप अपने विकास बिल्ड में लॉगिंग करते हैं, लेकिन रिलीज़ बिल्ड में नहीं। परिदृश्य की तरह यह DefinePlugin सुविधा है।


यदि आप टाइप करते हैं तो यह आप देख सकते हैं webpack --help

Config options:
  --config  Path to the config file
                         [string] [default: webpack.config.js or webpackfile.js]
  --env     Enviroment passed to the config, when it is a function

Basic options:
  --context    The root directory for resolving entry point and stats
                                       [string] [default: The current directory]
  --entry      The entry point                                          [string]
  --watch, -w  Watch the filesystem for changes                        [boolean]
  --debug      Switch loaders to debug mode                            [boolean]
  --devtool    Enable devtool for better debugging experience (Example:
               --devtool eval-cheap-module-source-map)                  [string]
  -d           shortcut for --debug --devtool eval-cheap-module-source-map
               --output-pathinfo                                       [boolean]
  -p           shortcut for --optimize-minimize --define
               process.env.NODE_ENV="production" 

                      [boolean]
  --progress   Print compilation progress in percentage                [boolean]

3

उत्तरों के गुच्छा में जोड़ने के लिए:

DefinePlugin के बजाय ExtendedDefinePlugin का उपयोग करें

npm install extended-define-webpack-plugin --save-dev.

ExtendedDefinePlugin उपयोग करने के लिए बहुत सरल है और प्रलेखित है :-) लिंक

क्योंकि DefinePlugin में अच्छे प्रलेखन का अभाव है, मैं यह कहकर मदद करना चाहता हूं कि यह वास्तव में #DEFINE की तरह c # में काम करता है ।

#if (DEBUG)
        Console.WriteLine("Debugging is enabled.");
#endif

इस प्रकार, यदि आप यह समझना चाहते हैं कि DefinePlugin कैसे काम करता है, तो c # #define डॉक्यूमेंटेशन पढ़ें। संपर्क


2

मैं विभिन्न पर्यावरण के लिए .env फ़ाइल का उपयोग करना पसंद करता हूं।

  1. env.devजड़ फ़ोल्डर में .env की प्रतिलिपि बनाने के लिए webpack.dev.config का उपयोग करें
  2. .Env की प्रतिलिपि बनाने के env.prodलिए webpack.prod.config का उपयोग करें

और कोड में

उपयोग

require('dotenv').config(); const API = process.env.API ## which will store the value from .env file


2

मैंने वेबपैक 2 के लिए पर्यावरण चर को सेटअप करने में सबसे आसान होने के लिए निम्नलिखित समाधान पाया:

उदाहरण के लिए हमारे पास एक वेबपैक सेटिंग है:

var webpack = require('webpack')

let webpackConfig = (env) => { // Passing envirmonment through
                                // function is important here
    return {
        entry: {
        // entries
        },

        output: {
        // outputs
        },

        plugins: [
        // plugins
        ],

        module: {
        // modules
        },

        resolve: {
        // resolves
        }

    }
};

module.exports = webpackConfig;

Webpack में पर्यावरण चर जोड़ें:

plugins: [
    new webpack.EnvironmentPlugin({
       NODE_ENV: 'development',
       }),
]

प्लगइन चर को परिभाषित करें और इसे इसमें जोड़ें plugins:

    new webpack.DefinePlugin({
        'NODE_ENV': JSON.stringify(env.NODE_ENV || 'development')
    }),

अब वेबपैक कमांड चलाते समय, env.NODE_ENVतर्क के रूप में पास करें :

webpack --env.NODE_ENV=development

// OR

webpack --env.NODE_ENV development

अब आप NODE_ENVअपने कोड में चर का उपयोग कर सकते हैं ।


1

Webpack v4 के बाद से, बस modeअपने Webpack कॉन्फ़िगरेशन में सेटिंग आपके NODE_ENVलिए (माध्यम से DefinePlugin) सेट हो जाएगी । यहां डॉक्स।


1

यहाँ एक तरीका है कि मेरे लिए काम किया है और मुझे एक json फ़ाइल का पुन: उपयोग करके मेरे पर्यावरण चर DRY रखने की अनुमति दी है।

const webpack = require('webpack');
let config = require('./settings.json');
if (__PROD__) {
    config = require('./settings-prod.json');
}

const envVars = {};
Object.keys(config).forEach((key) => {
    envVars[key] = JSON.stringify(config[key]);
});

new webpack.DefinePlugin({
    'process.env': envVars
}),

0

मैं बहुत बड़ा प्रशंसक नहीं हूं ...

new webpack.DefinePlugin({
  'process.env': envVars
}),

... क्योंकि यह किसी भी प्रकार की सुरक्षा प्रदान नहीं करता है। इसके बजाय, आप अपने गुप्त सामान को बढ़ाते हैं, जब तक कि आप एक वेबपैक को gitignore में नहीं जोड़ते हैं, जब तक कि एक बेहतर समाधान न हो।

मूल रूप से इस कॉन्फ़िगरेशन के साथ एक बार जब आप अपना कोड संकलित करते हैं, तो सभी प्रक्रिया env चरों को पूरे कोड से हटा दिया जाएगा, एक भी प्रक्रिया नहीं होने वाली है। transform-inline-environment-variables यदि आप समाप्त नहीं करना चाहते हैं तो babel प्लगइन PS को धन्यवाद दें। अपरिभाषितों के एक पूरे समूह के साथ, सुनिश्चित करें कि आप env.js को कॉल करते हैं इससे पहले कि वेबपैक babel-loader को कॉल करता है, इसीलिए यह पहली बात webpack कॉल है। babel.config.js फ़ाइल में var का सरणी env.js. पर ऑब्जेक्ट से मेल खाना चाहिए अब केवल एक ही काम करना है। .envवहां अपने सभी env वेरिएबल्स में एक फ़ाइल जोड़ें , फ़ाइल प्रोजेक्ट के रूट पर होनी चाहिए या इसे बेझिझक जोड़ना होगा जहां आप कभी भी चाहें, बस env.js फ़ाइल पर उसी स्थान को सेट करना सुनिश्चित करें और इसे भी जोड़ें gitignore

const dotFiles = ['.env'].filter(Boolean);

if (existsSync(dotFiles)) {
    require("dotenv-expand")(require("dotenv").config((dotFiles)));
}

यदि आप संपूर्ण babel + webpack + ts देखना चाहते हैं तो इसे हीव से प्राप्त करें https://github.com/EnetoJara/Node-typescript-babel-webpack.git

और यही तर्क प्रतिक्रिया और अन्य सभी पर लागू होता है

config
---webpack.js
---env.js
src
---source code world
.env
bunch of dotFiles

env.js

"use strict";
/***
I took the main idea from CRA, but mine is more cooler xD
*/
const {realpathSync, existsSync} = require('fs');
const {resolve, isAbsolute, delimiter} = require('path');

const NODE_ENV = process.env.NODE_ENV || "development";

const appDirectory = realpathSync(process.cwd());

if (typeof NODE_ENV !== "string") {
    throw new Error("falle and stuff");
}

const dotFiles = ['.env'].filter(Boolean);

if (existsSync(dotFiles)) {
    require("dotenv-expand")(require("dotenv").config((dotFiles)));
}

process.env.NODE_PATH = (process.env.NODE_PATH || "")
    .split(delimiter)
    .filter(folder => folder && isAbsolute(folder))
    .map(folder => resolve(appDirectory, folder))
    .join(delimiter);

const ENETO_APP = /^ENETO_APP_/i;

module.exports = (function () {
    const raw = Object.keys ( process.env )
        .filter ( key => ENETO_APP.test ( key ) )
        .reduce ( ( env, key ) => {
                env[ key ] = process.env[ key ];
                return env;
            },
            {
                BABEL_ENV: process.env.ENETO_APP_BABEL_ENV,
                ENETO_APP_DB_NAME: process.env.ENETO_APP_DB_NAME,
                ENETO_APP_DB_PASSWORD: process.env.ENETO_APP_DB_PASSWORD,
                ENETO_APP_DB_USER: process.env.ENETO_APP_DB_USER,
                GENERATE_SOURCEMAP: process.env.ENETO_APP_GENERATE_SOURCEMAP,
                NODE_ENV: process.env.ENETO_APP_NODE_ENV,
                PORT: process.env.ENETO_APP_PORT,
                PUBLIC_URL: "/"
            } );

    const stringyField = {
        "process.env": Object.keys(raw).reduce((env, key)=> {
            env[key]=JSON.stringify(raw[key]);
            return env;
        },{}),

    };

    return {
        raw, stringyField
    }
})();

कोई प्लगइन्स ट्रोल के साथ webpack फ़ाइल

"use strict";

require("core-js");
require("./env.js");

const path = require("path");
const nodeExternals = require("webpack-node-externals");

module.exports = env => {
    return {
        devtool: "source-map",
        entry: path.join(__dirname, '../src/dev.ts'),
        externals: [nodeExternals()],
        module: {
            rules: [
                {
                    exclude: /node_modules/,
                    test: /\.ts$/,
                    use: [
                        {
                            loader: "babel-loader",
                        },
                        {
                            loader: "ts-loader"
                        }
                    ],
                },
                {
                    test: /\.(png|jpg|gif)$/,
                    use: [
                        {
                            loader: "file-loader",
                        },
                    ],
                },
            ],
        },
        node: {
            __dirname: false,
            __filename: false,
        },
        optimization: {
            splitChunks: {
                automaticNameDelimiter: "_",
                cacheGroups: {
                    vendor: {
                        chunks: "initial",
                        minChunks: 2,
                        name: "vendor",
                        test: /[\\/]node_modules[\\/]/,
                    },
                },
            },
        },
        output: {
            chunkFilename: "main.chunk.js",
            filename: "name-bundle.js",
            libraryTarget: "commonjs2",
        },
        plugins: [],
        resolve: {
            extensions: ['.ts', '.js']
        }   ,
        target: "node"
    };
};

babel.config.js

module.exports = api => {

    api.cache(() => process.env.NODE_ENV);

    return {

        plugins: [
            ["@babel/plugin-proposal-decorators", { legacy: true }],
            ["@babel/plugin-transform-classes", {loose: true}],
            ["@babel/plugin-external-helpers"],
            ["@babel/plugin-transform-runtime"],
            ["@babel/plugin-transform-modules-commonjs"],
            ["transform-member-expression-literals"],
            ["transform-property-literals"],
            ["@babel/plugin-transform-reserved-words"],
            ["@babel/plugin-transform-property-mutators"],
            ["@babel/plugin-transform-arrow-functions"],
            ["@babel/plugin-transform-block-scoped-functions"],
            [
                "@babel/plugin-transform-async-to-generator",
                {
                    method: "coroutine",
                    module: "bluebird",
                },
            ],
            ["@babel/plugin-proposal-async-generator-functions"],
            ["@babel/plugin-transform-block-scoping"],
            ["@babel/plugin-transform-computed-properties"],
            ["@babel/plugin-transform-destructuring"],
            ["@babel/plugin-transform-duplicate-keys"],
            ["@babel/plugin-transform-for-of"],
            ["@babel/plugin-transform-function-name"],
            ["@babel/plugin-transform-literals"],
            ["@babel/plugin-transform-object-super"],
            ["@babel/plugin-transform-shorthand-properties"],
            ["@babel/plugin-transform-spread"],
            ["@babel/plugin-transform-template-literals"],
            ["@babel/plugin-transform-exponentiation-operator"],
            ["@babel/plugin-proposal-object-rest-spread"],
            ["@babel/plugin-proposal-do-expressions"],
            ["@babel/plugin-proposal-export-default-from"],
            ["@babel/plugin-proposal-export-namespace-from"],
            ["@babel/plugin-proposal-logical-assignment-operators"],
            ["@babel/plugin-proposal-throw-expressions"],
            [
                "transform-inline-environment-variables",
                {
                    include: [
                        "ENETO_APP_PORT",
                        "ENETO_APP_NODE_ENV",
                        "ENETO_APP_BABEL_ENV",
                        "ENETO_APP_DB_NAME",
                        "ENETO_APP_DB_USER",
                        "ENETO_APP_DB_PASSWORD",
                    ],
                },
            ],
        ],
        presets: [["@babel/preset-env",{
            targets: {
                node: "current",
                esmodules: true
            },
            useBuiltIns: 'entry',
            corejs: 2,
            modules: "cjs"
        }],"@babel/preset-typescript"],
    };
};

"आप अंत में अपने गुप्त सामान को बढ़ाते हैं, जब तक कि आप एक वेबपैक को gignignore में नहीं जोड़ते।" क्या आप उस पर विस्तार कर सकते हैं?
केटी बायर्स

मूल रूप से आपके बंडल की प्रक्रिया समाप्त हो जाती है ।env.BLAHBLAH और वास्तविक मूल्य डालता है। उदाहरण के लिए, प्रक्रिया के बजाय .env.NODE_ENV u अंत में "उत्पादन" के साथ, मेरा मतलब है कि यह सबसे अच्छा उदाहरण नहीं है, लेकिन एक गुप्त कुंजी की कल्पना करें। आपके बंडल का वास्तविक मूल्य होगा और जो जानता है कि उस तार को 🤷♀️ will के लिए खड़ा किया गया है
अर्नेस्टो

हम्म्म - हाँ, उन मूल्यों को निर्मित संस्करण में प्रक्षेपित किया जाएगा , लेकिन संभवतः आप
केटी बायर्स

-4

मुझे नहीं पता, लेकिन किसी ने भी वास्तव में सबसे सरल समाधान का उल्लेख नहीं किया है। यह मेरे लिए नोडज और ग्रंट के लिए काम करता है। कई लोगों के लिए जैसा कि वेबपैक भ्रमित कर सकता है आप बस नीचे की रेखा का उपयोग कर सकते हैं:

process.env.NODE_ENV = 'production';

उपरोक्त समाधान के साथ आपको वास्तव में envify या webpack का उपयोग करने की आवश्यकता नहीं है। कभी-कभी सरल हार्डकोड समाधान कुछ लोगों के लिए काम कर सकते हैं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.