Elixir 1.7 - Mix.Task

मिक्स.टैस्क व्यवहार




elixir

मिक्स.टैस्क व्यवहार

एक सरल मॉड्यूल जो कार्यों को बनाने, लोड करने और हेरफेर करने के लिए उपयुक्तता प्रदान करता है।

मिक्स टास्क से शुरू होने वाले मॉड्यूल में मिक्स टास्क का उपयोग करके एक मिक्स टास्क को परिभाषित किया जा सकता है Mix.Tasks. और run/1 फ़ंक्शन को परिभाषित करना:

defmodule Mix.Tasks.Echo do
  use Mix.Task

  def run(args) do
    Mix.shell.info Enum.join(args, " ")
  end
end

run/1 फ़ंक्शन कमांड लाइन को पारित किए गए सभी तर्कों की एक सूची प्राप्त करेगा।

गुण

मिक्स में उन्हें कॉन्फ़िगर करने के लिए मिक्स कार्यों में कुछ विशेषताएँ उपलब्ध हैं:

  • @shortdoc - mix help पर दिखाई देने वाले संक्षिप्त विवरण के साथ कार्य को सार्वजनिक करता है
  • @recursive - छतरी परियोजनाओं में पुनरावृत्ति से कार्य चलाता है
  • @preferred_cli_env - कार्य चलाने के लिए पर्यावरण की सिफारिश करता है। इसका उपयोग मिक्स प्रोजेक्ट की अनुशंसा, या स्पष्ट MIX_ENV की अनुपस्थिति में किया जाता है, और यह केवल वर्तमान प्रोजेक्ट में कार्यों के लिए काम करता है। @preferred_cli_env निर्भरता से लोड नहीं है, क्योंकि हमें निर्भरता लोड होने से पहले पर्यावरण को जानना होगा।

प्रलेखन

उपयोगकर्ता मिक्स mix help my_task चलाकर सार्वजनिक मिक्स कार्यों के लिए दस्तावेज़ पढ़ सकते हैं। जो डॉक्यूमेंटेशन दिखाया जाएगा, वह टास्क के मॉड्यूल का @moduledoc है।

सारांश

प्रकार

task_module()
task_name()

कार्य

alias?(task)

जाँचता है कि कोई अन्य नाम वाला task मौजूद है या नहीं

all_modules()

सभी लोड किए गए कार्य मॉड्यूल लौटाता है

clear()

सभी लागू किए गए कार्यों को बंद कर देता है, जिससे उन्हें फिर से संगठित किया जा सकता है

get!(task)

एक कार्य नाम प्राप्त करता है और कार्य मॉड्यूल को पुनः प्राप्त करता है

get(task)

एक कार्य नाम प्राप्त करता है और यदि पाया गया तो कार्य मॉड्यूल लौटाता है

load_all()

सभी कार्यों को सभी कोड पथ में लोड करता है

load_tasks(dirs)

दिए गए paths में सभी कार्यों को पूरा करता paths

moduledoc(module)

दिए गए कार्य module लिए moduledoc हो जाता है

preferred_cli_env(task)

कार्य के लिए पसंदीदा CLI वातावरण हो जाता है

recursive(module)

जाँचता है कि क्या कार्य को छतरी परियोजनाओं में सभी उप-ऐप के लिए पुनरावृत्ति से चलाया जाना चाहिए

reenable(task)

दिए गए कार्य को फिर से करता है ताकि इसे स्टैक के नीचे फिर से निष्पादित किया जा सके

रेरुन (कार्य, args \\ [])

दिए गए तर्कों के साथ पुनर्मिलन task

रन (कार्य, args \\ [])

दिए गए args साथ एक task चलाता है

shortdoc(module)

दिए गए टास्क module लिए शॉर्टकोड प्राप्त करता है

task?(module)

यदि दिया मॉड्यूल true तो यह एक कार्य है

task_name(module)

दिए गए module लिए कार्य नाम देता है

कॉलबैक

run(command_line_args)

एक कार्य को run आवश्यकता होती है जो कमांड लाइन आर्ग्स की एक सूची प्राप्त करता है

प्रकार

task_module ()

task_module() :: atom()

कार्य का नाम()

task_name() :: String.t() | atom()

कार्य

उर्फ? (कार्य)

alias?(task_name()) :: boolean()

जाँचता है कि कोई अन्य नाम वाला task मौजूद है या नहीं।

टास्क अलियासिंग के बारे में अधिक जानकारी के लिए, Mix लिए डॉक्स में "एलियासिंग" अनुभाग देखें।

all_modules ()

all_modules() :: [task_module()]

सभी लोड किए गए कार्य मॉड्यूल लौटाता है।

अभी तक लोड नहीं किए गए मॉड्यूल दिखाई नहीं देंगे। यदि आप सभी कार्यों को पहले से लोड करना चाहते हैं, तो load_all() जांचें।

स्पष्ट()

clear() :: :ok

सभी लागू किए गए कार्यों को बंद कर देता है, जिससे उन्हें फिर से संगठित किया जा सकता है।

यह ऑपरेशन पुनरावर्ती नहीं है।

प्राप्त करें! (कार्य)

get!(task_name()) :: task_module() | no_return()

एक कार्य नाम प्राप्त करता है और कार्य मॉड्यूल को पुनः प्राप्त करता है।

अपवाद

  • Mix.NoTaskError - यदि कार्य नहीं मिला तो उठाया जा सकता है
  • Mix.InvalidTaskError - यदि कार्य एक मान्य Mix.Task नहीं है तो उठाया गया

मिल (कार्य)

get(task_name()) :: task_module() | nil

एक कार्य नाम प्राप्त करता है और यदि पाया गया तो कार्य मॉड्यूल लौटाता है।

अन्यथा मॉड्यूल मौजूद होने की स्थिति में nil लौटाता है, लेकिन यह एक कार्य नहीं है या नहीं पाया जा सकता है।

load_all ()

load_all() :: [task_module()]

सभी कार्यों को सभी कोड पथ में लोड करता है।

load_tasks (dirs)

load_tasks([List.Chars.t()]) :: [task_module()]

दिए गए paths में सभी कार्यों को पूरा करता paths

moduledoc (मॉड्यूल)

moduledoc(task_module()) :: String.t() | nil | false

दिए गए कार्य module लिए moduledoc हो जाता है।

Moduledoc या nil लौटाता है।

preferred_cli_env (कार्य)

preferred_cli_env(task_name()) :: atom() | nil

कार्य के लिए पसंदीदा CLI वातावरण हो जाता है।

पर्यावरण लौटाता है (उदाहरण के लिए :test , या :prod ), या nil

पुनरावर्ती (मॉड्यूल)

recursive(task_module()) :: boolean()

जाँचता है कि क्या कार्य को छतरी परियोजनाओं में सभी उप-ऐप के लिए पुनरावृत्ति से चलाया जाना चाहिए।

true या false लौटाता true

पुन: सक्षम करें (कार्य)

reenable(task_name()) :: :ok

दिए गए कार्य को फिर से करता है ताकि इसे स्टैक के नीचे फिर से निष्पादित किया जा सके।

इस फ़ंक्शन को कॉल करने पर उपनाम और नियमित स्टैक दोनों को फिर से कनेक्ट किया जाता है।

यदि एक छाता परियोजना किसी कार्य को पुन: लागू करती है, तो यह सभी बाल परियोजनाओं के लिए फिर से चालू है।

रेरुन (कार्य, args \\ [])

rerun(task_name(), [any()]) :: any()

दिए गए तर्कों के साथ पुनर्मिलन task

यह कार्य दिए गए कार्य को पुन: करता है; ऐसा करने के लिए, यह पहले कार्य को फिर से सक्षम बनाता है और फिर इसे सामान्य रूप से चलाता है।

रन (कार्य, args \\ [])

run(task_name(), [any()]) :: any()

दिए गए args साथ एक task चलाता है।

यदि कार्य अभी तक लागू नहीं किया गया था, तो यह कार्य चलाता है और परिणाम देता है।

यदि समान नाम के साथ कोई अन्य नाम है, तो मूल कार्य के स्थान पर अन्य नाम दिया जाएगा।

यदि कार्य या उपनाम पहले से ही लागू था, तो यह उन्हें फिर से नहीं चलाता है और बस के साथ :noop करता है: नहीं

यदि कोई अन्य कार्य या कार्य अमान्य पाया जा सकता है या कार्य अमान्य है, तो यह एक अपवाद बढ़ा सकता है। अधिक जानकारी के लिए चेक get!(task)

shortdoc (मॉड्यूल)

shortdoc(task_module()) :: String.t() | nil

दिए गए टास्क module लिए शॉर्टकोड प्राप्त करता है।

शॉर्टडॉक या nil लौटाता है।

काम? (मॉड्यूल)

task?(task_module()) :: boolean()

यदि दिया मॉड्यूल true तो यह एक कार्य है।

task_name (मॉड्यूल)

task_name(task_module()) :: task_name()

दिए गए module लिए कार्य नाम देता है।

कॉलबैक

चलाने (command_line_args)

run(command_line_args :: [binary()]) :: any()

एक कार्य को run आवश्यकता होती है जो कमांड लाइन आर्ग्स की एक सूची प्राप्त करता है।