प्रतिक्रिया-मूल में पर्यावरण चर स्थापित करना?

152

मैं क्रॉस-प्लेटफ़ॉर्म ऐप बनाने के लिए प्रतिक्रिया-मूलक का उपयोग कर रहा हूं, लेकिन मुझे नहीं पता कि पर्यावरण चर कैसे सेट किया जाए ताकि मैं अलग-अलग वातावरणों के लिए अलग-अलग स्थिरांक रख सकूं।

उदाहरण:

development: 
  BASE_URL: '',
  API_KEY: '',
staging: 
  BASE_URL: '',
  API_KEY: '',
production:
  BASE_URL: '',
  API_KEY: '',
react-native 
— डेमन युआन
स्रोत
आप यह कोशिश कर सकते हैंimport {Platform} from 'react-native'; console.log(Platform);
— प्रवीण प्रसाद

जवाबों:

138

अपने ऐप स्थिरांक को हार्ड-कोडिंग करने और पर्यावरण पर स्विच करने के बजाय (मैं समझाऊँगा कि एक क्षण में कैसे करें), मैं सुझाव देता हूं कि आपके निर्माण की प्रक्रिया को परिभाषित करने के बारह कारक सुझाव का उपयोग करके आप BASE_URLऔर आपके को परिभाषित करें API_KEY।

अपने पर्यावरण को कैसे उजागर किया जाए react-native, इसका जवाब देने के लिए , मैं सुझाव देता हूं कि मैं बैबेल - बैबल -प्लगइन-ट्रांसफ़ॉर्म-इनलाइन-पर्यावरण-चर का उपयोग करूं ।

यह काम करने के लिए आपको प्लगइन डाउनलोड करने की आवश्यकता है और फिर आपको सेटअप करने की आवश्यकता होगी .babelrcऔर इसे कुछ इस तरह दिखना चाहिए:

{
  "presets": ["react-native"],
  "plugins": [
    "transform-inline-environment-variables"
  ]
}

और इसलिए यदि आप API_KEY=my-app-id react-native bundle(या शुरू, रन-आईओएस, या रन-एंड्रॉइड) द्वारा अपने प्रतिक्रिया-मूल कोड को ट्रांसपाइल करते हैं, तो आपको बस इतना करना होगा कि आपका कोड इस तरह दिखाई दे:

const apiKey = process.env['API_KEY'];

और फिर बाबेल उसकी जगह लेंगे:

const apiKey = 'my-app-id';

उम्मीद है की यह मदद करेगा!

— chapinkapa
स्रोत
7
महान समाधान की तरह लगता है, लेकिन RN@0.37.0 पर मेरे लिए काम नहीं करता है। पर एकमात्र संपत्ति process.envहै NODE_ENV।
— एडम फेरीना
2
जैक झेंग द्वारा नीचे दिए गए उत्तर को देखें ... आप इसके माध्यम से चर का उपयोग नहीं कर सकते process.env.API_KEY... process.env['API_KEY']इसके बजाय
— स्टीवन याप
6
मुझे यह प्रक्रिया मिल रही है। मैं ['API_KEY'] अपरिभाषित हूं। क्या कोई मुझे इसे सेट करने में मदद कर सकता है
— user1106888
2
मुझे एक ही समस्या थी: अपरिभाषित
— गुटो मार्रा मरज़ागो
7
मेरे लिए v0.56 में काम करता है। react-native start --reset-cacheहर बार जब आप पर्यावरण चर बदलते हैं तो आपको बंडलर का कैश साफ़ करना होता है।
— सोहिलप्रो
55

मेरे द्वारा पाया गया सबसे सरल ( सबसे अच्छा या आदर्श नहीं ) समाधान, प्रतिक्रिया-मूल-डॉटेनव का उपयोग करना था । आप बस .babelrcप्रोजेक्ट फ़ाइल में "प्रतिक्रिया-मूल-डॉटेनव" प्रीसेट को इस तरह जोड़ते हैं :

{
  "presets": ["react-native", "react-native-dotenv"]
}

एक .envफ़ाइल बनाएँ और गुण जोड़ें:

echo "SOMETHING=anything" > .env

फिर अपने प्रोजेक्ट (JS) में:

import { SOMETHING } from 'react-native-dotenv'
console.log(SOMETHING) // "anything"
— स्लाव वोजसेक
स्रोत
1
मैं .env आधारित समाधान की उम्मीद कर रहा था। धन्यवाद!
— अंशुल कोका
3
@Slavo Vojacek उदाहरण के लिए कॉन्फ़िगर करने के लिए मैं इसका उपयोग कैसे करता हूं और base_urlदोनों के लिए ? stagingproduction
— कॉम्पैक LE2202x
@ CompaqLE2202x मुझे समझ में नहीं आ रहा है? क्या आप अलग-अलग .envफ़ाइलों (प्रति वातावरण) का उपयोग करने के बारे में पूछ रहे हैं , या विभिन्न फ़ाइलों में आपके कुछ मूल्यों का पुन: उपयोग.env कर रहे हैं, इसलिए आप उन्हें डुप्लिकेट नहीं करते हैं, कहते हैं, स्टेजिंग और प्रोडक्शन?
— स्लावो वोजेसेक
5
@SlavoVojacek मैं अलग के बारे में पूछ रहा हूँ .envपर्यावरण प्रति फ़ाइलों मान लें stagingऔर production।
— कॉम्पैक LE2202x
@SlavoVojacek आप CI चरण में या तैनाती पर मूल्यों को अधिलेखित नहीं कर सकते हैं?
— mgamsjager
37

मेरी राय में सबसे अच्छा विकल्प प्रतिक्रिया-देशी-विन्यास का उपयोग करना है । यह 12 फैक्टर को सपोर्ट करता है ।

मुझे यह पैकेज बेहद उपयोगी लगा। आप कई वातावरण सेट कर सकते हैं, जैसे विकास, मंचन, उत्पादन।

एंड्रॉइड के मामले में, जावा कक्षाओं में भी वैरिएबल उपलब्ध हैं, gradle, AndroidManifest.xml आदि। iOS के मामले में, वैरिएबल ओब्ज-सी क्लासेस, Info.plist में भी उपलब्ध हैं।

आप जैसे फाइल बनाते हैं

  • .env.development
  • .env.staging
  • .env.production

आप इन फ़ाइलों को कुंजी, मानों के साथ भरते हैं

API_URL=https://myapi.com
GOOGLE_MAPS_API_KEY=abcdefgh

और फिर इसका उपयोग करें:

import Config from 'react-native-config'

Config.API_URL  // 'https://myapi.com'
Config.GOOGLE_MAPS_API_KEY  // 'abcdefgh'

यदि आप विभिन्न वातावरणों का उपयोग करना चाहते हैं, तो आप मूल रूप से इस तरह ENVFILE चर निर्धारित करते हैं:

ENVFILE=.env.staging react-native run-android

या उत्पादन के लिए ऐप असेंबल करने के लिए (मेरे मामले में Android):

cd android && ENVFILE=.env.production ./gradlew assembleRelease
— पेट्रीक प्रेवुज़नक
स्रोत
9
यह ध्यान देने योग्य हो सकता है कि README में यह कहा गया है कि ध्यान रखें कि यह मॉड्यूल पैकेजिंग के लिए रहस्यों को बाधित या एन्क्रिप्ट नहीं करता है, इसलिए .env में संवेदनशील कुंजियों को संग्रहीत न करें। उपयोगकर्ताओं को रिवर्स इंजीनियरिंग मोबाइल ऐप रहस्यों से रोकना मूल रूप से असंभव है, इसलिए अपने ऐप (और एपीआई) को ध्यान में रखते हुए डिज़ाइन करें
— Marklar
बात यह है कि कहीं भी होगी चहचहाना जैसे कुछ व्यवस्थाएं जो वे अपने .env में com.twitter.sdk.android.CONSUMER_KEY के रूप में कुंजी सेट करने की आवश्यकता है के साथ काम नहीं
— Thibaut नूह
यदि आप मेनिफेस्ट के अंदर चाबी लगाने का मतलब रखते हैं, तो एक्सटेंशन इसका समर्थन करता है। यह केवल इस उत्तर में वर्णित नहीं है। आप एक्सएमएल, जावा और जेएस फाइलों में चर का उपयोग कर सकते हैं।
— ९
4
प्रतिक्रिया-मूल-विन्यास RN 0.56 के साथ काम नहीं करता है, इसमें अनसुलझे मुद्दे हैं और यह 6 महीने से अधिक समय के लिए अस्वीकार्य है। मुद्दा डायन को मारता है आर.एन. में इसके उपयोग है github.com/luggit/react-native-config/issues/267 , यहाँ कुछ यह काम करने के लिए हैकिंग है github.com/luggit/react-native-config/issues/285
— Marecky
24

प्रतिक्रियाशील मूल में वैश्विक चर की अवधारणा नहीं है। यह घटक मॉड्यूलरता और पुन: प्रयोज्य को बढ़ावा देने के लिए सख्ती से मॉड्यूलर गुंजाइश को लागू करता है ।

कभी-कभी, हालांकि, आपको उनके पर्यावरण के बारे में जागरूक होने के लिए घटकों की आवश्यकता होती है। इस मामले में एक Environmentमॉड्यूल को परिभाषित करना बहुत आसान है, जो घटक तब पर्यावरण चर प्राप्त करने के लिए कॉल कर सकते हैं, उदाहरण के लिए:

environment.js

var _Environments = {
    production:  {BASE_URL: '', API_KEY: ''},
    staging:     {BASE_URL: '', API_KEY: ''},
    development: {BASE_URL: '', API_KEY: ''},
}

function getEnvironment() {
    // Insert logic here to get the current platform (e.g. staging, production, etc)
    var platform = getPlatform()

    // ...now return the correct environment
    return _Environments[platform]
}

var Environment = getEnvironment()
module.exports = Environment

मेरी-component.js

var Environment = require('./environment.js')

...somewhere in your code...
var url = Environment.BASE_URL

यह एक सिंगलटन वातावरण बनाता है जिसे आपके ऐप के दायरे में कहीं से भी एक्सेस किया जा सकता है। आपको require(...)पर्यावरण चर का उपयोग करने वाले किसी भी घटक से स्पष्ट रूप से मॉड्यूल लेना होगा, लेकिन यह एक अच्छी बात है।

— tohster
स्रोत
19
मेरी समस्या यह है कि करने के लिए है getPlatform()। मैंने इस तरह की एक फ़ाइल बनाई है, लेकिन यहाँ पर प्रतिक्रियाशील मूल के तर्क को समाप्त नहीं कर सकते
— डेमन युआन
@DamonYuan जो पूरी तरह से इस बात पर निर्भर करता है कि आप अपने पैकेज कैसे सेट कर रहे हैं। मुझे नहीं पता कि क्या stagingया productionयहां तक ​​कि मतलब है, क्योंकि यह आपके पर्यावरण पर निर्भर है। उदाहरण के लिए, अगर आप एंड्रॉयड बनाम आईओएस के लिए विभिन्न स्वादों चाहते तो आप पर्यावरण आयात आपके द्वारा प्रारंभ कर सकते हैं index.ios.jsऔर index.android.jsफ़ाइलों और वहाँ मंच की स्थापना, जैसे Environment.initialize('android')।
— टॉस्टर
@DamonYuan वह करता है जो मैं बिल्कुल मदद करता हूं, या आपको कुछ और स्पष्टीकरण की आवश्यकता है?
— च्पिंकापा
जब आप कोड पर नियंत्रण रखते हैं तो यह बहुत अच्छा होता है। मैं एक तीसरा भाग मॉड्यूल चला रहा हूं, जो प्रक्रिया पर निर्भर करता है। इसलिए, ...
— enapupe
2
यदि आप एक env.jsफ़ाइल बनाते हैं, तो चेक-इन से रिपॉजिटरी में इसे अनदेखा करना सुनिश्चित करें और खाली स्ट्रिंग मान के साथ, उपयोग की गई कुंजियों की प्रतिलिपि बनाएँ, एक और env.js.exampleफ़ाइल में आप चेक-इन करते हैं ताकि अन्य आपके ऐप को अधिक आसानी से बना सकें। यदि आप गलती से प्रोजेक्ट सीक्रेट्स में जांच करते हैं, तो इतिहास को केवल स्रोत से नहीं बल्कि उसके इतिहास को हटाने के लिए पुनर्लेखन पर विचार करें।
— जोश हब्दास
17

मैंने __DEV__इस समस्या को हल करने के लिए पॉलीफ़िल का उपयोग किया है जो कि प्रतिक्रिया-मूल में बनाया गया है। यह स्वचालित रूप से trueइतने लंबे समय तक सेट होता है जब तक कि आप उत्पादन के लिए देशी प्रतिक्रिया नहीं बना रहे हों।

उदाहरण के लिए: 

//vars.js

let url, publicKey;
if (__DEV__) {
  url = ...
  publicKey = ...
} else {
  url = ...
  publicKey = ...
}

export {url, publicKey}

तब बस import {url} from '../vars'और आपको हमेशा सही मिलेगा। दुर्भाग्य से, यह अभ्यस्त काम करता है यदि आप दो से अधिक वातावरण चाहते हैं, लेकिन यह आसान है और इसमें आपकी परियोजना में अधिक निर्भरता शामिल नहीं है।

— Logister
स्रोत
क्या आप एक्सकोड में रिलीज़ बिल्ड बनाते समय भी TRUE को DEV 'करने का एक तरीका जानते हैं ?
— realtebo
1
नहीं। जब मैं देव चर के साथ एक रिलीज बिल्ड करना चाहता हूं, तो मैं सिर्फ प्रोडक्ट वेरिएशन को कमेंट करता हूं और फिर डेव वेरिएंट को पेस्ट सेक्शन में पेस्ट करता हूं।
— लॉगिस्टर
1
मुझे यह सबसे सुरुचिपूर्ण समाधान मिला
— दानी श ०
5

पर्यावरण चर सेट करने के लिए उपयोग की जाने वाली विशिष्ट विधि CI सेवा, निर्माण दृष्टिकोण, प्लेटफ़ॉर्म और आपके द्वारा उपयोग किए जाने वाले टूल द्वारा अलग-अलग होगी।

यदि आप अनुप्रयोग बनाने और पर्यावरण चर का प्रबंधन करने के लिए CI के लिए Buddybuild का उपयोग कर रहे हैं , और आपको JS से कॉन्फ़िगर करने की आवश्यकता है, तो env.js.exampleचेक-इन स्रोत नियंत्रण के लिए कुंजियों के साथ (खाली स्ट्रिंग मानों के साथ) बनाएं, और Buddybuild का उपयोग करके उत्पादन करें env.jsफ़ाइल का निर्माण post-cloneचरण में समय , फ़ाइल सामग्री को बिल्ड लॉग से छुपाना, जैसे:

#!/usr/bin/env bash

ENVJS_FILE="$BUDDYBUILD_WORKSPACE/env.js"

# Echo what's happening to the build logs
echo Creating environment config file

# Create `env.js` file in project root
touch $ENVJS_FILE

# Write environment config to file, hiding from build logs
tee $ENVJS_FILE > /dev/null <<EOF
module.exports = {
  AUTH0_CLIENT_ID: '$AUTH0_CLIENT_ID',
  AUTH0_DOMAIN: '$AUTH0_DOMAIN'
}
EOF

सुझाव: जोड़ने के लिए मत भूलना env.jsके लिए .gitignoreइतना config और रहस्यों को विकास के दौरान गलती से स्रोत नियंत्रण में जाँच नहीं कर रहे हैं।

फिर आप यह प्रबंधित कर सकते हैं कि फ़ाइल को किस तरह से बडीबिल्ड वैरिएबल का उपयोग करके लिखा जाता है BUDDYBUILD_VARIANTS, उदाहरण के लिए, बिल्ड समय में आपके कॉन्फ़िगरेशन का उत्पादन कैसे किया जाता है , इस पर अधिक नियंत्रण प्राप्त करने के लिए।

— जोश हबदास
स्रोत
कुल मिलाकर मुझे यह विचार पसंद है, लेकिन env.js.exampleभाग कैसे काम करता है ? मान लीजिए कि मैं अपने स्थानीय परिवेश में ऐप लॉन्च करना चाहता हूं। अगर मेरी env.jsफ़ाइल gitignore में है और env.js.exampleइसे एक रूपरेखा के रूप में प्रयोग किया जाता है, तो env.js.exampleयह वैध जेएस एक्सटेंशन नहीं है, इसलिए मैं इस हिस्से से आपके बारे में थोड़ा भ्रमित हूं
— volk
@volk कोडबस में env.js.exampleफाइल एक रेफरेंस डॉक्यूमेंट के रूप में बैठती है, सत्य का एक कैनोनिकल सोर्स जो एप्लिकेशन को उपभोग करना चाहता है। यह दोनों ऐप को चलाने के लिए आवश्यक कुंजियों का वर्णन करता है, साथ ही फ़ाइलनाम को एक बार कॉपी और नाम बदलने की उम्मीद करता है। रूबी ऐप्स में डॉटेन रत्न का उपयोग करके पैटर्न सामान्य है , जहां से मैंने पैटर्न को उठाया है।
— जोश हब्दास
3

मुझे लगता है कि निम्नलिखित लाइब्रेरी की तरह कुछ आपको पहेली के गुम बिट को हल करने में मदद कर सकता है, getPlatform () फ़ंक्शन।

https://github.com/joeferraro/react-native-env

const EnvironmentManager = require('react-native-env');

// read an environment variable from React Native
EnvironmentManager.get('SOME_VARIABLE')
  .then(val => {
    console.log('value of SOME_VARIABLE is: ', val);

  })
  .catch(err => {
    console.error('womp womp: ', err.message);
  });

एकमात्र समस्या जो मुझे इसके साथ दिखाई देती है, वह यह है कि यह async कोड है। GetSync का समर्थन करने के लिए एक पुल अनुरोध है। इसे भी देखें।

https://github.com/joeferraro/react-native-env/pull/9

— leonfs
स्रोत
3
उल्लेखित नहीं एक वैकल्पिक दृष्टिकोण प्रदान करने के लिए तैयार किया गया। कोई एक आकार सभी को फिट नहीं है।
— जोश हबदास
— Asynch
5
प्रतिक्रिया-देशी-एनवी Android का समर्थन करने के लिए प्रकट नहीं होता है। क्या बात है?
— जेकलूम
3

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

const fs = require('fs')

let endPoint

if (process.env.MY_ENV === 'dev') {
  endPoint = 'http://my-api-dev/api/v1'
} else if (process.env.MY_ENV === 'test') {
  endPoint = 'http://127.0.0.1:7001'
} else {
  endPoint = 'http://my-api-pro/api/v1'
}

let template = `
export default {
  API_URL: '${endPoint}',
  DEVICE_FINGERPRINT: Math.random().toString(36).slice(2)
}
`

fs.writeFile('./src/constants/config.js', template, function (err) {
  if (err) {
    return console.log(err)
  }

  console.log('Configuration file has generated')
})

और मैंने प्रतिक्रिया-मूल चलाने केnpm run scripts लिए एक प्रथा बनाई है।

मेरा पैकेज-जसन 

"scripts": {
    "start-ios": "node config-generator.js && react-native run-ios",
    "build-ios": "node config-generator.js && react-native run-ios --configuration Release",
    "start-android": "node config-generator.js && react-native run-android",
    "build-android": "node config-generator.js && cd android/ && ./gradlew assembleRelease",
    ...
}

फिर मेरी सेवाओं के घटकों में बस स्वतः उत्पन्न फ़ाइल आयात करें:

import config from '../constants/config'

fetch(`${config.API_URL}/login`, params)
— टोनी चेज़
स्रोत
3

चरण 1: इस घटक नाम की तरह अलग घटक बनाएँ: पेजबेस 2.जज
चरण 2: इस उपयोग कोड के अंदर 

    export const BASE_URL = "http://192.168.10.10:4848/";
    export const API_KEY = 'key_token';

चरण 3: किसी भी घटक में इसका उपयोग करें, इसका उपयोग करने के लिए पहले इस घटक को आयात करें और फिर इसका उपयोग करें। इसे आयात करें और इसका उपयोग करें:

        import * as base from "./pagebase";

        base.BASE_URL
        base.API_KEY
— जितेंद्र सुथार
स्रोत
2

मैं उपयोग करता हूं babel-plugin-transform-inline-environment-variables।

मैंने जो किया वह मेरे अलग-अलग वातावरणों के साथ S3 के भीतर एक विन्यास फाइल रखा।

s3://example-bucket/dev-env.sh
s3://example-bucket/prod-env.sh
s3://example-bucket/stage-env.sh

EACH env फ़ाइल:

FIRSTENV=FIRSTVALUE
SECONDENV=SECONDVALUE

बाद में, मैंने अपनी स्क्रिप्ट में एक नई स्क्रिप्ट जोड़ी जो package.jsonबंडलिंग के लिए एक स्क्रिप्ट चलाता है

if [ "$ENV" == "production" ]
then
  eval $(aws s3 cp s3://example-bucket/prod-env.sh - | sed 's/^/export /')
elif [ "$ENV" == "staging" ]
then
  eval $(aws s3 cp s3://example-bucket/stage-env.sh - | sed 's/^/export /')
else
  eval $(aws s3 cp s3://example-bucket/development-env.sh - | sed 's/^/export /')
fi

react-native start

आपके एप्लिकेशन के भीतर संभवतः आपके पास एक कॉन्फ़िग फ़ाइल होगी, जिसमें:

const FIRSTENV = process.env['FIRSTENV']
const SECONDENV = process.env['SECONDENV']

जिसे बेबल द्वारा प्रतिस्थापित किया जाएगा:

const FIRSTENV = 'FIRSTVALUE'
const SECONDENV = 'SECONDVALUE'

याद रखें कि आपको उपयोग process.env['STRING']नहीं करना है process.env.STRINGया यह ठीक से परिवर्तित नहीं होगा।

— जैक झांग
स्रोत
REMEMBER you have to use process.env['STRING'] NOT process.env.STRING or it won't convert properly.धन्यवाद! यह वह है जो मुझे यात्राएं करता है !!!
— स्टीवन याप
1

[स्रोत] मैंने जो पाया है, वह डिफ़ॉल्ट रूप से दिखता है, यह केवल उत्पादन और विकास कॉन्फिगर करने के लिए संभव है (कोई मंचन या अन्य वातावरण नहीं) - क्या यह सही है?

अभी, मैं एक environment.js फ़ाइल का उपयोग कर रहा हूं जिसका उपयोग एक्सपो रिलीज चैनलों का पता लगाने और उस के आधार पर वापस आए चर को बदलने के लिए किया जा सकता है, लेकिन निर्माण के लिए, मुझे गैर- डीईवी चर को अपडेट करने की आवश्यकता है जो या तो स्टेजिंग हो या prod:

import { Constants } from 'expo';
import { Platform } from 'react-native';
const localhost = Platform.OS === 'ios' ? 'http://localhost:4000/' : 'http://10.0.2.2:4000/';
const ENV = {
  dev: {
    apiUrl: localhost,
  },
  staging: {
    apiUrl: 'https://your-staging-api-url-here.com/'
  },
  prod: {
    apiUrl: 'https://your-prod-api-url-here.com/'
  },
}
const getEnvVars = (env = Constants.manifest.releaseChannel) => {
  // What is __DEV__ ?
  // This variable is set to true when react-native is running in Dev mode.
  // __DEV__ is true when run locally, but false when published.
  if (__DEV__) {
    return ENV.dev;
  } else {
    // When publishing to production, change this to `ENV.prod` before running an `expo build`
    return ENV.staging;
  }
}
export default getEnvVars;

वैकल्पिक

क्या किसी को एक्सपो के साथ निर्मित परियोजनाओं के लिए प्रतिक्रिया-मूल-डॉटेनव का उपयोग करने का अनुभव है? मुझे आपके विचार सुनना अच्छा लगेगा

https://github.com/zetachang/react-native-dotenv

— panchicore
स्रोत
आप जितने चाहें उतने रिलीज चैनल के नामों को परिभाषित कर सकते हैं, और अपने पर्यावरण चर को परिभाषित करने के लिए नाम का परीक्षण कर सकते हैं। जहाँ मैं देख रहा हूँ कि सीमा देव वातावरण में है जहाँ रिलीज़चैनल अपरिभाषित है। तो हो सकता है कि आप babel- प्लगइन-ट्रांसफ़ॉर्म-इनलाइन-एनवायरनमेंट-वेरिएबल्स का उपयोग कर सकते हैं - आप अपनी स्क्रिप्ट्स और रेफरेंस प्रोसेस में पर्यावरण वेरिएबल्स पर पास कर सकते हैं। क्या आपके ईवेंट में 'vAR_NAME'] 's' s 'देव' फाइल है?
— colemerrick
0

आपके पास अलग-अलग env स्क्रिप्ट भी हो सकती हैं: production.env.sh development.env.sh production.env.sh

और फिर काम शुरू करते समय उन्हें स्रोत [जो सिर्फ एक उपनाम से बंधा हुआ है] इसलिए प्रत्येक sh फ़ाइल में प्रत्येक चर चर के लिए निर्यात होता है:

export SOME_VAR=1234
export SOME_OTHER=abc

और फिर बेबल-प्लगइन-ट्रांसफ़ॉर्म-इनलाइन-पर्यावरण-चर जोड़ने से उन्हें कोड में एक्सेस करने की अनुमति मिलेगी:

export const SOME_VAR: ?string = process.env.SOME_VAR;
export const SOME_OTHER: ?string = process.env.SOME_OTHER;
— पिकाचु-जाने
स्रोत
क्या आप कुछ भी जोड़ रहे हैं @chapinkapa ने नहीं कहा?
— मैक्सिमो डोमिंगुएज़
0

@ चापकपा का जवाब अच्छा है। एक दृष्टिकोण जो मैंने मोबाइल सेंटर से लिया है, वह पर्यावरण चर का समर्थन नहीं करता है, एक देशी मॉड्यूल के माध्यम से बिल्ड कॉन्फ़िगरेशन को उजागर करना है:

Android पर:

   @Override
    public Map<String, Object> getConstants() {
        final Map<String, Object> constants = new HashMap<>();
        String buildConfig = BuildConfig.BUILD_TYPE.toLowerCase();
        constants.put("ENVIRONMENT", buildConfig);
        return constants;
    }

या आईओएस पर:

  override func constantsToExport() -> [String: Any]! {
    // debug/ staging / release
    // on android, I can tell the build config used, but here I use bundle name
    let STAGING = "staging"
    let DEBUG = "debug"

    var environment = "release"
    if let bundleIdentifier: String = Bundle.main.bundleIdentifier {
      if (bundleIdentifier.lowercased().hasSuffix(STAGING)) {
        environment = STAGING
      } else if (bundleIdentifier.lowercased().hasSuffix(DEBUG)){
        environment = DEBUG
      }
    }

    return ["ENVIRONMENT": environment]
  }

आप बिल्ड कॉन्फिगरेशन को सिंक्रोनाइज़ करके पढ़ सकते हैं और जावास्क्रिप्ट में तय कर सकते हैं कि आप कैसे व्यवहार करने जा रहे हैं।

— vonovak
स्रोत
0

इसके process.env.blablaबजाय चर को एक्सेस करना संभव है process.env['blabla']। मैंने हाल ही में इसे काम किया और टिप्पणी की कि मैंने इसे GitHub के मुद्दे पर कैसे किया क्योंकि मुझे स्वीकृत उत्तर के आधार पर कैश के साथ कुछ समस्याएं थीं। यहाँ मुद्दा है।

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