Ruby

Wanneer een methode-aanroep een Hash doorgeeft bij het laatste argument, en wanneer deze geen trefwoorden doorgeeft, en wanneer de aangeroepen methode trefwoorden accepteert, wordt er een waarschuwing afgegeven. Om de hash als sleutelwoorden te blijven behandelen, voeg je een dubbele splat-operator toe om de waarschuwing te voorkomen en correct gedrag in Ruby 3 te garanderen.

    def foo(key: 42); end; foo({key: 42})   # warned
    def foo(**kw);    end; foo({key: 42})   # warned
    def foo(key: 42); end; foo(**{key: 42}) # OK
    def foo(**kw);    end; foo(**{key: 42}) # OK

Wanneer een methode aanroep trefwoorden doorgeeft aan een methode die trefwoorden accepteert, maar niet voldoende vereiste positionele argumenten doorgeeft, worden de trefwoorden behandeld als een laatste vereist positioneel argument en wordt er een waarschuwing afgegeven. Geef het argument door als hash in plaats van trefwoorden om de waarschuwing te vermijden en te zorgen voor correct gedrag in Ruby 3.

    def foo(h, **kw); end; foo(key: 42)      # warned
    def foo(h, key: 42); end; foo(key: 42)   # warned
    def foo(h, **kw); end; foo({key: 42})    # OK
    def foo(h, key: 42); end; foo({key: 42}) # OK

Wanneer een methode specifieke trefwoorden accepteert, maar geen trefwoord splat, en een hash of trefwoorden splat wordt doorgegeven aan de methode die zowel symbool- als niet-symbooltoetsen bevat, wordt de hash verder gesplitst en wordt er een waarschuwing afgegeven. Je moet de aanroepcode bijwerken om afzonderlijke hashes door te geven om correct gedrag in Ruby 3 te garanderen.

    def foo(h={}, key: 42); end; foo("key" => 43, key: 42)   # warned
    def foo(h={}, key: 42); end; foo({"key" => 43, key: 42}) # warned
    def foo(h={}, key: 42); end; foo({"key" => 43}, key: 42) # OK

Als een methode geen trefwoorden accepteert en wordt aangeroepen met trefwoorden, worden de trefwoorden nog steeds behandeld als een positionele hash, zonder waarschuwing. Dit gedrag blijft werken in Ruby 3.

    def foo(opt={});  end; foo( key: 42 )   # OK

Niet-symbolen zijn toegestaan als sleutelwoord argumentsleutels als de methode willekeurige sleutelwoorden accepteert.

    def foo(**kw); p kw; end; foo("str" => 1) #=> {"str"=>1}

**nil is toegestaan in methodedefinities om expliciet aan te geven dat de methode geen trefwoorden accepteert. Het aanroepen van een dergelijke methode met trefwoorden resulteert in een ArgumentError.

    def foo(h, **nil); end; foo(key: 1)       # ArgumentError
    def foo(h, **nil); end; foo(**{key: 1})   # ArgumentError
    def foo(h, **nil); end; foo("str" => 1)   # ArgumentError
    def foo(h, **nil); end; foo({key: 1})     # OK
    def foo(h, **nil); end; foo({"str" => 1}) # OK

Het doorgeven van een leeg trefwoord splat aan een methode die geen zoekwoorden accepteert, geeft niet langer een lege hash door, tenzij de lege hash nodig is voor een vereiste parameter, in welk geval een waarschuwing wordt afgegeven. Verwijder de dubbele splat om door een positionele hash te gaan.

    h = {}; def foo(*a) a end; foo(**h) # []
    h = {}; def foo(a) a end; foo(**h)  # {} and warning
    h = {}; def foo(*a) a end; foo(h)   # [{}]
    h = {}; def foo(a) a end; foo(h)    # {}