குழாய் செயல்பாடு

இம்மொழிபெயர்ப்பு இற்றைப்ப்டுத்தப்பட்டுள்ளது.

ஒருகோவையின் வெளியீட்டை, மற்றொருகோவையின் முதல் உள்ளீடாக அனுப்ப குழாய் செயல்பாடு |> பயன்படுகிறது.

பொருளடக்கம்

அறிமுகம்

நிரலெழுதும்போது குளறுபடிகள் ஏற்படலாம். சங்கிலித்தொடர்போல செயற்கூறுகளை அழைத்துக்கொண்டேபோகும்போது இக்குழப்பம் மேலும் அதிகரிக்கலாம். ஒன்றுக்குள் ஒன்றாக அழைக்கப்படும் பின்வரும் செயற்கூறுகளைஎடுத்துக்கொள்ளலாம்:

foo(bar(baz(new_function(other_function()))))

இங்கே, other_function/0இன் வெளியீட்டை new_function/1க்கு உள்ளீடாகவும், new_function/1இன் வெளியீட்டை baz/1க்கும், baz/1 இன் வெளியீட்டை, bar/1 க்கும், bar/1இன் வெளியீட்டை foo/1க்கு உள்ளீடாகவும் கொடுக்கிறோம். குழாய்செயல்பாட்டின்மூலம், இந்த தொடரியல்சிக்கலுக்கு ஒரு நடைமுறைத்தீர்வை எலிக்சர் வழங்குகிறது. |> என்ற குறிப்பிடப்படும் குழாய்செயல்பாடு ஒருகோவையின் பலனை அடுத்தகோவைக்கு கடத்துகிறது. மேற்கண்ட எடுத்துக்காட்டில், குழாய்செயல்பாட்டைப்பயன்படுத்தி, பின்வருமாறு மாற்றியெழுதலாம்.

other_function() |> new_function() |> baz() |> bar() |> foo()

இடப்புறமுள்ளகோவையின் பலனை வலப்புறமுள்ளகோவைக்கு குழாய் செலுத்துகிறது.

எடுத்துக்காட்டுகள்

பின்வரும் எடுத்துக்காட்டுகளுக்கு, எலிக்சரின் சரம் கூறினைப்பயன்படுத்துகிறோம்.

  • சரத்தினை சிறுகூறுகளாக உடைக்க
iex> "Elixir rocks" |> String.split()
["Elixir", "rocks"]
  • சரத்தின் கூறுகளனைத்தையும் பெரியஎழுத்துக்கு மாற்ற
iex> "Elixir rocks" |> String.upcase() |> String.split()
["ELIXIR", "ROCKS"]
  • சரத்தின் முடிவினைச்சோதிக்க
iex> "elixir" |> String.ends_with?("ixir")
true

நற்பழக்கங்கள்

ஒன்றைவிடப்பெரிய உருபெண்கொண்ட செயற்கூறுகளை அழைக்கும்போது அடைப்புக்குறிக்குள் உருபுகளைக்குறிப்பிடுவது அவசியம். எலிக்சரைப்பொருத்தமட்டில் இது ஒரு பெரியவிசயமல்ல. ஆனால், பிற நிரல்மொழிகளில் பரிச்சயம்பெற்ற நிரலர்கள் உங்கள் நிரலைத்தவறாகபுரிந்துகொள்ளாமலிருக்க இது அவசியமாகிறது. அதேபோல், குழாய்செயல்பாட்டைப்பயன்படுத்தும்போதும், இது அவசியமாகிறது. இதற்குச்சான்றாக, நமது மூன்றாவது எடுத்துக்காட்டிலுள்ள அடைப்புக்குறிகளை நீக்கிவிட்டு இயக்கும்போது பின்வரும் எச்சரிக்கை வழங்கப்படுகிறது.

iex> "elixir" |> String.ends_with? "ixir"
warning: parentheses are required when piping into a function call. For example:

  foo 1 |> bar 2 |> baz 3

is ambiguous and should be written as

  foo(1) |> bar(2) |> baz(3)

true