erl_call - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

erl_call - ໂທ/ເລີ່ມການແຈກຢາຍ Erlang Node

ລາຍລະອຽດ

erl_call ເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະເລີ່ມຕົ້ນແລະ / ຫຼືຕິດຕໍ່ສື່ສານກັບ node Erlang ແຈກຢາຍ. ມັນ
ແມ່ນສ້າງຂຶ້ນຕາມ erl_interface ຫ້ອງສະຫມຸດເປັນຄໍາຮ້ອງສະຫມັກຕົວຢ່າງ. ຈຸດປະສົງຂອງມັນແມ່ນການນໍາໃຊ້
ສະຄຣິບ Unix shell ເພື່ອໂຕ້ຕອບກັບ node Erlang ທີ່ແຈກຢາຍ. ມັນປະຕິບັດທັງຫມົດ
ການ​ສື່​ສານ​ກັບ Erlang ໄດ້​ rex ເຄື່ອງແມ່ຂ່າຍ, ການນໍາໃຊ້ສະຖານທີ່ Erlang RPC ມາດຕະຖານ. ມັນ​ເຮັດ
ບໍ່ຮຽກຮ້ອງໃຫ້ມີຊອບແວພິເສດໃດໆທີ່ຈະດໍາເນີນການຢູ່ໃນ node ເປົ້າຫມາຍ Erlang.

ການ​ນໍາ​ໃຊ້​ຕົ້ນ​ຕໍ​ແມ່ນ​ເພື່ອ​ເລີ່ມ​ຕົ້ນ​ຂໍ້​ມູນ Erlang ແຈກ​ຢາຍ​ຫຼື​ເພື່ອ​ເຮັດ​ໃຫ້​ການ​ທໍາ​ງານ​ທໍາ​ມະ​ດາ​
ໂທ. ຢ່າງໃດກໍ່ຕາມ, ມັນກໍ່ເປັນໄປໄດ້ທີ່ຈະທໍ່ໂມດູນ Erlang erl_call ແລະມີມັນ
ລວບລວມ, ຫຼືທໍ່ລໍາດັບຂອງສໍານວນ Erlang ທີ່ຈະປະເມີນ (ຄ້າຍຄືກັນກັບ
ແກະ Erlang).

ທາງເລືອກ, ເຊິ່ງກໍ່ໃຫ້ເກີດ stdin ທີ່ຈະອ່ານ, ສາມາດນໍາໃຊ້ໄດ້ປະໂຫຍດເປັນ scripts ຈາກພາຍໃນ
(Unix) shell scripts. ອີກປະການຫນຶ່ງການນໍາໃຊ້ທີ່ດີຂອງ erl_call ອາດຈະມາຈາກ (http) CGI-bin scripts.

ການສົ່ງອອກ

erl_call

ທຸງທາງເລືອກແຕ່ລະແມ່ນໄດ້ອະທິບາຍຂ້າງລຸ່ມນີ້ດ້ວຍຊື່, ປະເພດ ແລະຄວາມຫມາຍຂອງມັນ.

-a [Mod [ມ່ວນ [Args]]]]:
(ທາງເລືອກ): ນຳໃຊ້ຟັງຊັນທີ່ກຳນົດໄວ້ ແລະສົ່ງຄືນຜົນໄດ້ຮັບ. Mod ຕ້ອງເປັນ
ລະບຸໄວ້, ຢ່າງໃດກໍຕາມ ການເລີ່ມຕົ້ນ ແລະ [] ແມ່ນສົມມຸດວ່າບໍ່ໄດ້ລະບຸ ສະຫນຸກສະຫນານ ແລະ Args,
ຕາມລໍາດັບ. Args ຄວນຈະຢູ່ໃນຮູບແບບດຽວກັນກັບສໍາລັບ erlang:apply/3. ຫມາຍ​ເຫດ​
ວ່າທຸງນີ້ໃຊ້ເວລາການໂຕ້ຖຽງທີ່ແນ່ນອນ, ສະນັ້ນການອ້າງອີງອາດຈະມີຄວາມຈໍາເປັນໃນຄໍາສັ່ງ
ກຸ່ມ Mod, ສະຫນຸກສະຫນານ ແລະ Args, ໃນລັກສະນະທີ່ຂຶ້ນກັບພຶດຕິກໍາຂອງທ່ານ
ແກະຄໍາສັ່ງ.

-c ຄຸກກີ:
(ທາງເລືອກ): ໃຊ້ຕົວເລືອກນີ້ເພື່ອລະບຸຄຸກກີທີ່ແນ່ນອນ. ຖ້າບໍ່ມີຄຸກກີ
ລະບຸ, ໄດ້ ~/.erlang.cookie ໄຟລ໌ຖືກອ່ານແລະເນື້ອຫາຂອງມັນຖືກນໍາໃຊ້ເປັນ
ຄຸກກີ. ໂຫນດ Erlang ທີ່ພວກເຮົາຕ້ອງການສື່ສານກັບຕ້ອງມີ cookie ດຽວກັນ.

-d:
(ທາງເລືອກ): ໂໝດດີບັກ. ອັນນີ້ເຮັດໃຫ້ IO ທັງໝົດຖືກສົ່ງອອກໄປຍັງໄຟລ໌
~/.erl_call.out.ຊື່, ບ່ອນທີ່ ນາມສະກຸນ ແມ່ນຊື່ node ຂອງ Erlang node ໃນ
ຄໍາຖາມ.

- ແລະ:
(ທາງເລືອກ): ອ່ານລໍາດັບຂອງສໍານວນ Erlang, ແຍກໂດຍ ',' ແລະ​ສິ້ນ​ສຸດ​ລົງ​
ກັບ '.', ຈາກ stdin ຈົນກ່ວາ EOF (Control-D). ປະເມີນການສະແດງອອກແລະ
ຕອບຜົນໄດ້ຮັບຈາກການສະແດງຜົນສຸດທ້າຍ. ກັບຄືນ {ຕົກລົງ, ຜົນໄດ້ຮັບ} ຖ້າປະສົບຜົນສໍາເລັດ.

-h ຊື່ທີ່ເຊື່ອງໄວ້:
(ທາງເລືອກ): ລະບຸຊື່ຂອງ node ທີ່ເຊື່ອງໄວ້ວ່າ erl_call ເປັນຕົວແທນ.

-m:
(ທາງເລືອກ): ອ່ານໂມດູນ Erlang ຈາກ stdin ແລະລວບລວມມັນ.

-n ຂໍ້:
(ຫນຶ່ງ​ໃນ -n, - ຊື່​, -ຊື່ is required): ມີຄວາມໝາຍຄືກັນກັບ -yam ແລະສາມາດເຮັດໄດ້
ຍັງຖືກໃຊ້ສໍາລັບເຫດຜົນຄວາມເຂົ້າກັນໄດ້ໃນດ້ານຫລັງ.

-yam ຂໍ້:
(ຫນຶ່ງ​ໃນ -n, - ຊື່​, -ຊື່ ຈໍາ​ເປັນ): node ແມ່ນຊື່ຂອງ node ທີ່ຈະເປັນ
ໄດ້ເລີ່ມຕົ້ນຫຼືຕິດຕໍ່ສື່ສານກັບ. ມັນສົມມຸດວ່າ node ແມ່ນເລີ່ມຕົ້ນດ້ວຍ erl
-yam, ຊຶ່ງຫມາຍຄວາມວ່າຊື່ node ຍາວທີ່ມີຄຸນວຸດທິຢ່າງເຕັມສ່ວນຖືກນໍາໃຊ້. ຖ້າ -s
ທາງ​ເລືອກ​ແມ່ນ​ໄດ້​ຮັບ​, ຂໍ້ Erlang ຈະ (ຖ້າ​ຫາກ​ວ່າ​ມີ​ຄວາມ​ຈໍາ​ເປັນ​) ຈະ​ເລີ່ມ​ຕົ້ນ​ດ້ວຍ​ erl -yam.

-q:
(ທາງເລືອກ): ຢຸດ Erlang node ທີ່ລະບຸດ້ວຍປຸ່ມ -n switch. ສະຫຼັບນີ້
overrides ສະວິດ -s.

-r:
(ທາງເລືອກ): ສ້າງຊື່ແບບສຸ່ມຂອງ node ທີ່ເຊື່ອງໄວ້ວ່າ erl_call
ເປັນຕົວແທນ.

-s:
(ທາງເລືອກ): ເລີ່ມການແຈກຢາຍ Erlang node ຖ້າຈໍາເປັນ. ນີ້ຫມາຍຄວາມວ່າໃນ a
ລໍາດັບຂອງການໂທ, ບ່ອນທີ່ '-s'ແລະ'-n node' ແມ່ນຄົງທີ່, ພຽງແຕ່ທໍາອິດ
ການໂທຈະເລີ່ມໂຫມດ Erlang. ນີ້ເຮັດໃຫ້ສ່ວນທີ່ເຫຼືອຂອງການສື່ສານຫຼາຍ
ໄວ. ທຸງນີ້ປະຈຸບັນມີຢູ່ໃນເວທີ Unix ເທົ່ານັ້ນ.

-ຊື່ ຂໍ້:
(ຫນຶ່ງ​ໃນ -n, - ຊື່​, -ຊື່ ຈໍາ​ເປັນ): node ແມ່ນຊື່ຂອງ node ທີ່ຈະເປັນ
ໄດ້ເລີ່ມຕົ້ນຫຼືຕິດຕໍ່ສື່ສານກັບ. ມັນສົມມຸດວ່າ node ແມ່ນເລີ່ມຕົ້ນດ້ວຍ erl
-ຊື່ ຊຶ່ງຫມາຍຄວາມວ່າຊື່ node ສັ້ນຖືກນໍາໃຊ້. ຖ້າ -s ທາງເລືອກແມ່ນໃຫ້, ເປັນ
ໂຫນດ Erlang ຈະຖືກເລີ່ມຕົ້ນ (ຖ້າຈໍາເປັນ) ກັບ erl -ຊື່.

- ໃນ:
(ທາງເລືອກ): ພິມຫຼາຍ ຄຳເວົ້າ ຂໍ້ມູນ. ນີ້ແມ່ນພຽງແຕ່ເປັນປະໂຫຍດສໍາລັບການ
ຜູ້ພັດທະນາແລະຮັກສາ erl_call.

-x ErlScript:
(ທາງເລືອກ): ລະບຸຊື່ອື່ນຂອງສະຄຣິບເລີ່ມຕົ້ນ Erlang ທີ່ຈະໃຊ້. ຖ້າ
ບໍ່ໄດ້ລະບຸ, ມາດຕະຖານ erl script start-up ຖືກນໍາໃຊ້.

ຕົວຢ່າງ

ເລີ່ມຂໍ້ Erlang ແລະໂທຫາ erlang:ເວລາ/0.

erl_call -s -a 'erlang time' -n madonna
{18,27,34}

ຢຸດໂຫມດ Erlang ໂດຍການໂທຫາ erlang:halt/0.

erl_call -s -a 'erlang halt' -n madonna

ນຳໃຊ້ກັບການໂຕ້ຖຽງຫຼາຍອັນ.

erl_call -s -a 'ລາຍຊື່ແຜນທີ່ [{ math,sqrt},[1,4,9,16,25]]' -n madonna

ປະເມີນສອງສາມສຳນວນ. ໄດ້ ການປ້ອນຂໍ້ມູນ ປາຍ ກັບ EOF (Control-D).

erl_call -s -e -n madonna
ສະ​ຖິ​ຕິ(ແລ່ນ),
X=1,
Y=2,
{_,T}=ສະຖິຕິ(ແລ່ນ),
{X+Y,T}.
^D
{ຕົກລົງ,{3,0}}

ລວບລວມໂມດູນແລະແລ່ນມັນ. ອີກເທື່ອຫນຶ່ງ, ໄດ້ ການປ້ອນຂໍ້ມູນ ປາຍ ກັບ EOF (Control-D). (ໃນຕົວຢ່າງ
ສະແດງໃຫ້ເຫັນ, ຜົນຜະລິດໄດ້ຖືກຈັດຮູບແບບຫຼັງຈາກນັ້ນ).

erl_call -s -m -a lolita -n madonna
-module(lolita).
-compile(export_all).
ເລີ່ມ() ->
P = ຂະ​ບວນ​ການ (),
F = fun(X) -> {X,process_info(X,registered_name)} ສິ້ນສຸດ,
ລາຍການ:ແຜນທີ່(F,[],P).
^D
[{[email protected],0,0> ,
{registered_name,init}},
{<[email protected],2,0> ,
{registered_name,erl_prim_loader}},
{<[email protected],4,0> ,
{registered_name,error_logger}},
{<[email protected],5,0> ,
{registered_name,application_controller}},
{<[email protected],6,0> ,
{registered_name,kernel}},
{<[email protected],7,0> ,
[]},
{<[email protected],8,0> ,
{registered_name,kernel_sup}},
{<[email protected],9,0> ,
{registered_name,net_sup}},
{<[email protected],10,0> ,
{registered_name,net_kernel}},
{<[email protected],11,0> ,
[]},
{<[email protected],12,0> ,
{registered_name,global_name_server}},
{<[email protected],13,0> ,
{registered_name,auth}},
{<[email protected],14,0> ,
{registered_name,rex}},
{<[email protected],15,0> ,
[]},
{<[email protected],16,0> ,
{registered_name,file_server}},
{<[email protected],17,0> ,
{registered_name,code_server}},
{<[email protected],20,0> ,
{registered_name,user}},
{<[email protected],38,0> ,
[]}]

ໃຊ້ erl_call ອອນລາຍໂດຍໃຊ້ບໍລິການ onworks.net