Elixir Language
basisgebruik van bewakingsbepalingen

basisgebruik van bewakingsbepalingen

In Elixir kunt u meerdere implementaties van een functie met dezelfde naam maken en regels opgeven die op de parameters van de functie worden toegepast voordat de functie wordt aangeroepen om te bepalen welke implementatie moet worden uitgevoerd.

Deze regels worden gemarkeerd door het trefwoord when , en ze gaan tussen de def function_name(params) en de do in de functiedefinitie. Een triviaal voorbeeld:

defmodule Math do

  def is_even(num) when num === 1 do
    false
  end
  def is_even(num) when num === 2 do
    true
  end

  def is_odd(num) when num === 1 do
    true
  end
  def is_odd(num) when num === 2 do
    false
  end

end

Stel dat ik Math.is_even(2) met dit voorbeeld. Er zijn twee implementaties van is_even , met verschillende bewakingsbepalingen. Het systeem zal ze in volgorde bekijken en de eerste implementatie uitvoeren waarbij de parameters voldoen aan de bewakingsclausule. De eerste specificeert dat num === 1 wat niet waar is, dus het gaat door naar de volgende. De tweede specificeert dat num === 2 , wat waar is, dus dit is de implementatie die wordt gebruikt, en de retourwaarde zal true .

Wat als ik Math.is_odd(1) ? Het systeem kijkt naar de eerste implementatie en ziet dat, aangezien num 1 de bewakingsclausule van de eerste implementatie is voldaan. Het zal dan die implementatie gebruiken en true retourneren en niet naar andere implementaties kijken.

Bewakers zijn beperkt in het soort operaties dat ze kunnen uitvoeren. De Elixir-documentatie vermeldt elke toegestane bewerking ; kort is_atom staan ze vergelijkingen, wiskunde, binaire bewerkingen, typecontrole (bijv. is_atom ) en een handvol kleine handige functies (bijv. length ) toe. Het is mogelijk om aangepaste bewakingsclausules te definiëren, maar het vereist het maken van macro's en is het beste over voor een meer geavanceerde gids.

Merk op dat bewakers geen fouten maken; ze worden behandeld als normale fouten van de bewakingsbepaling en het systeem gaat verder met het bekijken van de volgende implementatie. Als u merkt dat u (FunctionClauseError) no function clause matching wanneer u een bewaakte functie aanroept met params die u verwacht te werken, kan het zijn dat een bewakingsclausule waarvan u verwacht dat deze werkt, een foutmelding geeft die wordt ingeslikt.

Om dit voor jezelf te zien, maak en roep vervolgens een functie op met een bewaker die geen zin heeft, zoals deze die probeert te delen door nul:

defmodule BadMath do
  def divide(a) when a / 0 === :foo do
    :bar
  end
end

Door BadMath.divide("anything") roepen BadMath.divide("anything") zal de enigszins onbehulpzame fout (FunctionClauseError) no function clause matching in BadMath.divide/1 - terwijl u zou proberen om "anything" / 0 rechtstreeks uit te voeren error: (ArithmeticError) bad argument in arithmetic expression .