पाइप ऑपरेटर में

पाइप ऑपरेटर के बारे में

|> ऑपरेटर को पाइप ऑपरेटर कहा जाता है। इसकी मदद से कई फंक्शन कॉल को एक श्रृंखला में जोड़ा जा सकता है, जिसमें पिछले फंक्शन कॉल से लौटी वैल्यू अगले फंक्शन कॉल को पहले आर्गुमेंट के रूप में दी जाती है।

String.replace_suffix(String.upcase(String.duplicate("go ", 3)), " ", "!")

# versus

"go "
|> String.duplicate(3)
|> String.upcase()
|> String.replace_suffix(" ", "!")

इसे एक ही लाइन में भी इस्तेमाल किया जा सकता है:

"go " |> String.duplicate(3) |> String.upcase() |> String.replace_suffix(" ", "!")

Kernel के फंक्शन आम तौर पर हर जगह Kernel मॉड्यूल का नाम लिखे बिना ही इस्तेमाल किए जाते हैं, लेकिन पाइप चेन में इन फंक्शनों का उपयोग करते समय मॉड्यूल का नाम लिखना ज़रूरी होता है। उदाहरण के लिए, 2 * 3 == 6 को इस तरह भी लिखा जा सकता है:

2 |> Kernel.*(3) |> Kernel.==(6)

पाइप ऑपरेटर का इस्तेमाल कब करना है और कब नहीं, यह निजी पसंद की बात है। Elixir के कुछ डेवलपर इन नियमों का पालन करना पसंद करते हैं:

• जब सिर्फ एक ही फंक्शन कॉल करना हो, तो पाइप ऑपरेटर का इस्तेमाल न कीजिए।

  # do
  String.split("hello", "")
  
  # don't
  "hello" |> String.split("")
  

• पाइप चेन के अंदर सीधे अनाम फंक्शन न बनाइए।

  # do
  take_n_letters = fn n -> Enum.take(?a..?z, n) end
  2 |> Kernel.*(3) |> take_n_letters.()
  
  # don't
  2 |> Kernel.*(3) |> (fn n -> Enum.take(?a..?z, n) end).()
  

• पाइप चेन की शुरुआत हमेशा किसी वेरिएबल या लिटरल वैल्यू से कीजिए, किसी फंक्शन कॉल से नहीं।

  # do
  "hello" |> String.upcase() |> String.split("")
  
  # don't
  String.upcase("hello") |> String.split("")