Parametri opzionali di Ruby

Se definisco un Ruby funziona in questo modo:

def ldap_get ( base_dn, filter, scope=LDAP::LDAP_SCOPE_SUBTREE, attrs=nil )

Come posso chiamarlo fornendo solo i primi 2 e gli ultimi argomenti? Perché non è qualcosa di simile

ldap_get( base_dn, filter, , X)

possibile o se è possibile, come si può fare?

Questo non è possibile con Ruby attualmente. Non puoi passare attributi "vuoti" ai metodi. Il più vicino che puoi ottenere è passare zero:

ldap_get(base_dn, filter, nil, X)

Tuttavia, questo imposterà l'ambito su nil, non su LDAP :: LDAP_SCOPE_SUBTREE.

Quello che puoi fare è impostare il valore predefinito all'interno del tuo metodo:

def ldap_get(base_dn, filter, scope = nil, attrs = nil)
  scope ||= LDAP::LDAP_SCOPE_SUBTREE
  ... do something ...
end

Ora se chiami il metodo come sopra, il comportamento sarà come ti aspetti.

Stai quasi sempre meglio usando un hash delle opzioni.

def ldap_get(base_dn, filter, options = {})
  options[:scope] ||= LDAP::LDAP_SCOPE_SUBTREE
  ...
end

ldap_get(base_dn, filter, :attrs => X)

Il tempo è passato e dalla versione 2 Ruby supporta parametri denominati:

def ldap_get ( base_dn, filter, scope: "some_scope", attrs: nil )
  p attrs
end

ldap_get("first_arg", "second_arg", attrs: "attr1, attr2") # => "attr1, attr2"

Non è possibile farlo nel modo che hai definito ldap_get. Tuttavia, se definisci in ldap_getquesto modo:

def ldap_get ( base_dn, filter, attrs=nil, scope=LDAP::LDAP_SCOPE_SUBTREE )

Ora puoi:

ldap_get( base_dn, filter, X )

Ma ora hai il problema di non poterlo chiamare con i primi due arg e l'ultimo arg (lo stesso problema di prima ma ora l'ultimo arg è diverso).

La logica di ciò è semplice: non è necessario che ogni argomento in Ruby abbia un valore predefinito, quindi non puoi chiamarlo nel modo in cui hai specificato. Nel tuo caso, ad esempio, i primi due argomenti non hanno valori predefiniti.

1) Non è possibile sovraccaricare il metodo ( perché ruby ​​non supporta il sovraccarico del metodo? ) Quindi perché non scrivere un nuovo metodo del tutto?

2) Ho risolto un problema simile usando l'operatore splat * per un array di zero o più lunghezza. Quindi, se voglio passare un parametro (i) posso, viene interpretato come un array, ma se voglio chiamare il metodo senza alcun parametro, non devo passare nulla. Vedere Ruby Programming Language alle pagine 186/187

Recentemente ho trovato un modo per aggirare questo problema. Volevo creare un metodo nella classe array con un parametro opzionale, per mantenere o scartare gli elementi nell'array.

Il modo in cui l'ho simulato è stato passando un array come parametro e quindi controllando se il valore in quell'indice era nullo o meno.

class Array
  def ascii_to_text(params)
    param_len = params.length
    if param_len > 3 or param_len < 2 then raise "Invalid number of arguments #{param_len} for 2 || 3." end
    bottom  = params[0]
    top     = params[1]
    keep    = params[2]
    if keep.nil? == false
      if keep == 1
        self.map{|x| if x >= bottom and x <= top then x = x.chr else x = x.to_s end}
      else
        raise "Invalid option #{keep} at argument position 3 in #{p params}, must be 1 or nil"
      end
    else
      self.map{|x| if x >= bottom and x <= top then x = x.chr end}.compact
    end
  end
end

Provando il nostro metodo di classe con diversi parametri:

array = [1, 2, 97, 98, 99]
p array.ascii_to_text([32, 126, 1]) # Convert all ASCII values of 32-126 to their chr value otherwise keep it the same (That's what the optional 1 is for)

produzione: ["1", "2", "a", "b", "c"]

Va bene, va bene, funziona come previsto. Ora controlliamo e vediamo cosa succede se non passiamo la terza opzione parametro (1) nell'array.

array = [1, 2, 97, 98, 99]
p array.ascii_to_text([32, 126]) # Convert all ASCII values of 32-126 to their chr value else remove it (1 isn't a parameter option)

produzione: ["a", "b", "c"]

Come puoi vedere, la terza opzione nell'array è stata rimossa, iniziando così una sezione diversa nel metodo e rimuovendo tutti i valori ASCII che non sono nel nostro intervallo (32-126)

In alternativa, avremmo potuto emettere il valore come nil nei parametri. Che sarebbe simile al seguente blocco di codice:

def ascii_to_text(top, bottom, keep = nil)
  if keep.nil?
    self.map{|x| if x >= bottom and x <= top then x = x.chr end}.compact
  else
    self.map{|x| if x >= bottom and x <= top then x = x.chr else x = x.to_s end}
end

È possibile :) Basta cambiare la definizione

def ldap_get ( base_dn, filter, scope=LDAP::LDAP_SCOPE_SUBTREE, attrs=nil )

per

def ldap_get ( base_dn, filter, *param_array, attrs=nil )
scope = param_array.first || LDAP::LDAP_SCOPE_SUBTREE

l'ambito sarà ora in matrice al primo posto. Quando fornisci 3 argomenti, allora avrai assegnato base_dn, filtro e attrs e param_array sarà [] Quando 4 e più argomenti, param_array sarà [argomento1, or_more e_more]

Il rovescio della medaglia è ... non è una soluzione chiara, davvero brutta. Questo per rispondere che è possibile omettere l'argomento nel mezzo della chiamata di funzione in ruby ​​:)

Un'altra cosa che devi fare è riscrivere il valore predefinito di scope.

Puoi farlo con un'applicazione parziale, anche se l'uso di variabili denominate porta sicuramente a un codice più leggibile. John Resig ha scritto un articolo sul blog nel 2008 su come farlo in JavaScript: http://ejohn.org/blog/partial-functions-in-javascript/

Function.prototype.partial = function(){
  var fn = this, args = Array.prototype.slice.call(arguments);
  return function(){
    var arg = 0;
    for ( var i = 0; i < args.length && arg < arguments.length; i++ )
      if ( args[i] === undefined )
        args[i] = arguments[arg++];
    return fn.apply(this, args);
  };
};

Probabilmente sarebbe possibile applicare lo stesso principio in Ruby (eccetto per l'eredità prototipale).