Ruby

Quan una crida de mètode passa un Hash a l’últim argument, i quan no passa paraules clau, i quan el mètode cridat accepta paraules clau, s’emet un avís. Per continuar tractant el hash com a paraules clau, afegiu un operador de doble splat per evitar l’avís i garantir un comportament correcte a Ruby 3.

    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

Quan una crida de mètode passa paraules clau a un mètode que accepta paraules clau, però no passa suficients arguments posicionals obligatoris, les paraules clau es tracten com un argument posicional obligatori final, i s’emet un avís. Passeu l’argument com un hash en lloc de paraules clau per evitar l’avís i garantir un comportament correcte a 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

Quan un mètode accepta paraules clau específiques però no un splat de paraula clau, i es passa un hash o un splat de paraules clau al mètode que inclou tant claus de símbol com de no símbol, el hash continuarà dividint-se, i s’emetrà un avís. Haureu d’actualitzar el codi de crida per passar hashos separats per garantir un comportament correcte a Ruby 3.

    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

Si un mètode no accepta paraules clau, i es crida amb paraules clau, les paraules clau encara es tracten com un hash posicional, sense avís. Aquest comportament continuarà funcionant a Ruby 3.

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

Els no símbols es permeten com a claus d’argument de paraula clau si el mètode accepta paraules clau arbitràries.

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

**nil es permet en definicions de mètode per marcar explícitament que el mètode no accepta paraules clau. Cridar un mètode així amb paraules clau donarà lloc a un 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

Passar un splat de paraula clau buit a un mètode que no accepta paraules clau ja no passa un hash buit, tret que el hash buit sigui necessari per a un paràmetre obligatori, en què cas s’emetrà un avís. Elimineu el doble splat per continuar passant un hash posicional.

    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)    # {}