शुरुआती मॉड्यूल को स्थापित करने का सबसे आसान तरीका क्या है?

Question

मैंने rebar की जांच की, लेकिन यह बहुत जटिल लगता है।

%%%------------------------------------------------------------------- 
%% @doc myapp public API 
%% @end 
%%%------------------------------------------------------------------- 

-module('myapp_app'). 

-behaviour(application). 

%% Application callbacks 
-export([start/2 
     ,stop/1]). 

%%==================================================================== 
%% API 
%%==================================================================== 

start(_StartType, _StartArgs) -> 
    'myapp_sup':start_link(). 

%%-------------------------------------------------------------------- 
stop(_State) -> 
    ok. 

वहाँ शुरुआती के लिए कुछ आसान विकल्प है: शायद किसी को कुछ है कि कहते हैं, %Post your code here निम्नलिखित rebar अनुप्रयोग में पोस्ट कर सकता है?

Answer 1

यदि आप कुछ भी गैर-तुच्छ बनाने के लिए जा रहे हैं तो आप अपनी भाषा के निर्माण प्रणाली को सीखने से बच नहीं सकते हैं। यदि आप जीएनयू से परिचित हैं तो आप रीबर के बजाय erlang.mk का उपयोग कर सकते हैं, लेकिन मेरा मानना ​​है कि रेबर 3 सबसे शुरुआती-अनुकूल है।

rebar3 नए एप्लिकेशन

पर ध्यान न दें स्रोत फ़ाइलें है कि यह बनाता है:

---

आरईपीएल के अंदर किसी के पुस्तकालय कोड चलाने का विशिष्ट समस्या को हल करने के लिए, rebar3 साथ निम्न प्रयास करें अभी के लिए। rebar.config और add dependencies संपादित करें। फिर, एक आरईपीएल (आप src/ निर्देशिका में बनाए गए किसी भी स्रोत फ़ाइलों के साथ) उन निर्भरता लोड है कि लॉन्च:

rebar3 खोल

Answer 2

मैंने पिछले साल एर्लांग सीखना शुरू किया और एरलैंग से परिचित होने के लिए मुझे वास्तव में मदद मिली जो आपकी पसंद के एक सरल नोटपैड में कोड लिख रहा था, और इसे myapp_app.erl के रूप में सहेज रहा था। फिर मैं एरलंग कंसोल खोलूंगा, और संकलन कमांड का उपयोग करूंगा, c, मेरे मॉड्यूल को संकलित करने के लिए जो मुझे मेरे कार्यों को कॉल करने देगा।

> c(myapp_app). 
> myapp_app:start(a,b). 

Answer 3

मुझे नहीं लगता कि एक आसान तरीका है। सीखना रीबर यहां तार्किक कदम की तरह दिखता है। मुझे यह भी लगता है कि एर्लांग को नए लोगों के लिए अपील करने के लिए बहुत सारे प्रयास रीबर और rebar3 में गए हैं।

Answer 4

Erlang कोड पथ में मॉड्यूल के लिए दिखेगा।

आप code:get_path() लागू द्वारा कोड पथ देख सकते हैं:

4> code:get_path(). 
[".","/usr/lib/erlang/lib/kernel-3.0.3/ebin", 
"/usr/lib/erlang/lib/stdlib-2.2/ebin", 
"/usr/lib/erlang/lib/xmerl-1.3.7/ebin", 
... 
... 

आप देख सकते हैं, वर्तमान निर्देशिका शामिल है, और शायद बाकी सब कुछ डिफ़ॉल्ट प्रणाली की स्थापना स्थान में हो जाएगा। मेरे लिए इसका मतलब है कि सब कुछ '/ usr/lib/erlang/lib' के अंतर्गत होगा क्योंकि वह लाइब्रेरी पथ डेबियन लिनक्स के साथ है, और शेष पथ 'एपीपी-संस्करण/ईबिन' लाइब्रेरी पथ से विस्तारित है (देखें नीचे) ...

पुस्तकालय पथ code:lib_dir() लागू करके देखा जा सकता:

5> code:lib_dir(). 
"/usr/lib/erlang/lib" 
6> 

पुस्तकालय पथ इसके तहत सब कुछ है कि हर एक के लिए 'एक आवेदन की तरह दिखता है, यानी पता लगाकर विस्तार किया जाता है app- संस्करण/ebin 'जो इसके अंतर्गत मौजूद है, वह कोड पथ में जोड़ा गया है। इस तरह कोड पथ उत्पन्न होता है। और वर्तमान निर्देशिका निश्चित रूप से जोड़ा जाता है।

code module (पढ़ने लायक) कोड पथ को बदलने के लिए विभिन्न कार्यों है, और वहाँ इस तरह के रूप ERL_LIBS वातावरण चर जो आप अधिक पथ को जोड़ने की अनुमति है, और erl को -pa तर्क में जोड़ने देता है कोड पथ भी।

नोट कि ERL_LIBS एक lib जोड़ता है, जिसे एपीपी-संस्करण/ईबिन घटनाओं के लिए खोजा जाएगा, जहां -पा एक कोड पथ को ठीक उसी तरह जोड़ता है।

तो, एक बार आप यह सब पता है, एक मॉड्यूल स्थापित करने की सबसे सरल तरीका है ...

• कॉपी वर्तमान निर्देशिका के लिए संकलित बीम फ़ाइल।

ठीक है! यही कारण है कि सबसे आसान/usr है, लेकिन एक से थोड़ा अधिक उन्नत समाधान शायद उचित है ...

• पुस्तकालय पथ के तहत कुछ निर्देशिकाओं बनाएँ (मान लीजिए कि 'my_app-1.0/Ebin' करते हैं, तो यह है कि 'होगा /lib/erlang/lib/my_app-1.0/ebin 'मेरे सिस्टम पर), और उस पर अपनी बीम फ़ाइल कॉपी करें।

एक बार ऐसा करने के बाद, एरलांग शुरू करें और इसे कोड पथ में 'my_app-1.0/ebin' जोड़ना चाहिए और वहां कोई भी बीम फाइलें मिलनी चाहिए। वे स्थापित हैं।

नोट कि 'my_app-1.0' कुछ भी हो सकता है। यह केवल सम्मेलन है जो कहता है कि यह ऐप का नाम डैश और संस्करण के साथ होना चाहिए। यद्यपि एक उपयोगी सम्मेलन।

यह सिर्फ एक मॉड्यूल स्थापित कर रहा है, जो आपका प्रश्न था, लेकिन पूर्णता के लिए यह उल्लेखनीय है कि .app फ़ाइल को कोड पथ स्थान पर कॉपी करके एक ऐप इंस्टॉल किया जा सकता है। यह इतना आसान है।

शुरुआती लोगों के लिए, वर्तमान निर्देशिका में मॉड्यूल स्रोत नहीं है (और उन्हें संकलित करना) ठीक है और बहुत मुश्किल नहीं है? और सिस्टम फ़ाइलों में फ़ाइलों को कॉपी करने के लिए यह केवल एक छोटा कदम है। आम तौर पर आपके द्वारा डाउनलोड और संकलित करने वाले तृतीय पक्ष एप्लिकेशन ऐप फ़ाइल और सभी बीम फ़ाइलों के साथ एक ईबिन निर्देशिका उत्पन्न करेंगे, इसलिए यह केवल ebin को my_app-version/ebin पर कॉपी करने का एक प्रश्न है ...

Answer 5

यदि आप चाहते हैं प्रयोगशाला erlang, कुछ खिलौना आवेदन के साथ, भाषा मास्टर, प्रक्रिया निर्माण, संचार और यहां तक ​​कि सरल पर्यवेक्षण पेड़ के लिए, आपको वास्तव में एक आवेदन की आवश्यकता नहीं है, एक साधारण मानक ओटीपी निर्देशिका संरचना पर्याप्त है और इसमें काम शुरू करें।

दूसरी तरफ, यदि आप निर्भरताओं के साथ एक आवेदन बनाने का इरादा रखते हैं, यदि आप एक पुस्तकालय बनाना चाहते हैं, एक रिलीज, एकता परीक्षण और कार्यात्मक परीक्षण प्रबंधित करें ... फिर rebar (और rebar3) आपके जीवन को अधिक सरल बना देगा।

आपको learn you some erlang: Building application with OTP में और निम्न अध्यायों को यह समझने के लिए मूलभूत होगा कि एप्लिकेशन या रिलीज़ को कैसे परिभाषित किया गया है।

Install rebar3:

Answer 6

यहाँ मैं क्या कर समाप्त हो गया है

$ git clone https://github.com/rebar/rebar3.git 
$ cd rebar3 
.../rebar3$ ./bootstrap 

और अब आप स्क्रिप्ट rebar3 है और पिछले अनुभाग में वर्णित के रूप में अपने $ पथ में कहीं करने के लिए इसे कॉपी कर सकते हैं ।

या, आप .zip file डाउनलोड कर सकते हैं, इसे अनज़िप करें, तो rebar3 निर्देशिका में बदल सकते हैं और ./bootstrap आदेश जारी।

जो /rebar3 निर्देशिका के अंदर निष्पादन योग्य rebar3 बनाता है। मैं /usr/local/bin में rebar3 निष्पादन में ले जाया गया है, जो मेरे पथ वातावरण चर में सूचीबद्ध एक निर्देशिका (विभिन्न संभव पथ स्थानों here चर्चा कर रहे हैं) है:

.../rebar3$ sudo mv rebar3 /usr/local/bin 

मुझे किसी भी प्रॉम्प्ट पर rebar3 आदेश का उपयोग करने की अनुमति देता है। an alternative के रूप में, आप अपने अनुप्रयोग बनाने के बाद (अगला चरण देखें) आप अपने ऐप के निर्देशिका में और इस तरह है कि निर्देशिका मुद्दा rebar आदेशों से rebar3 कॉपी कर सकते हैं:

$ ./rebar3 ..... 

तब मैं created a new app:

~/erlang_programs$ rebar3 new app myapp 

तब:

~/erlang_programs$ cd myapp 
~/erlang_programs/myapp$ 

: (MyApp के स्थान पर अपने अनुप्रयोग नाम स्थानापन्न)

निर्भरता deps कुंजी के अंतर्गत rebar.config फ़ाइल में सूचीबद्ध हैं::

{erl_opts, [debug_info]}. 
{deps, [ 
    {jsx, "2.8.0"} 
]}. 

rebar.config यहाँ रहता 91,363,210

आदेश jsx उपयोग करने के लिए एक तीसरी पार्टी JSON पुस्तकालय, मैं jsx एक dependency के रूप में जोड़ा :

~/erlang_programs/myapp$ ls 
LICENSE  _build  rebar.lock 
README.md rebar.config src 

फिर मैंने अपना एरलांग प्रोजेर जोड़ा

my_app/src/my.erl:

-module(my). 
-export([test/0]). 

test() -> 
    jsx:decode(<<"{\"data\": [1, 2, 3]}">>). 

अंत: myapp/src निर्देशिका के लिए कर रहा हूँ

~/erlang_programs/myapp$ rebar3 shell 

===> Verifying dependencies... 
===> Fetching jsx ({pkg,<<"jsx">>,<<"2.8.0">>}) 
===> Version cached at /Users/7stud/.cache/rebar3/hex/default/packages/jsx-2.8.0.tar is up to date, reusing it 
===> Compiling jsx 
===> Compiling myapp 

Erlang/OTP 17 [erts-6.4] [source] [64-bit] [smp:4:4] [async-threads:0] [hipe] [kernel-poll:false] 

Eshell V6.4 (abort with ^G) 
1> my:test(). 
[{<<"data">>,[1,2,3]}] 

यदि आप मेरे मामले फ़ाइल में अपने .erl फ़ाइल में परिवर्तन कर, मेरे .erl, आपको खोल से बाहर निकलने की आवश्यकता नहीं है - बस सामान्य रूप से संकलित करें, उदाहरण के लिए c(my)।