Rubin optionale Parameter

Question

Wenn ich definieren eine Ruby-Funktionen wie folgt aus:

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

Wie kann ich es nennen liefert nur die ersten 2 und die letzten args? Warum ist nicht so etwas wie

ldap_get( base_dn, filter, , X)

möglich oder wenn es möglich ist, wie kann es getan werden?

Answer 1

Dies ist nicht möglich mit Rubin derzeit. Sie können nicht ‚leer‘ Attribute an Methoden übergeben. Die nächstgelegene Sie bekommen kann, ist gleich Null weitergeben müssen:

ldap_get(base_dn, filter, nil, X)

Dies wird jedoch den Umfang auf Null gesetzt, nicht LDAP :: LDAP_SCOPE_SUBTREE.

Was Sie tun können, um den Standardwert innerhalb Ihrer Methode festgelegt ist:

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

Wenn Sie nun das Verfahren, wie oben nennen, wird das Verhalten sein, wie Sie es erwarten.

Answer 2

Sie sind fast immer besser ein Options Hash verwendet wird.

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

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

Answer 3

Zeit hat sich weiterentwickelt und seit Version 2 Rubin unterstützt benannte Parameter:

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"

Answer 4

Es ist nicht möglich, es so zu tun Sie ldap_get definiert haben. Wenn Sie jedoch definieren ldap_get wie folgt aus:

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

Jetzt können Sie:

ldap_get( base_dn, filter, X )

Aber jetzt haben Sie Problem, dass Sie es nicht mit den ersten beiden args und dem letzten arg (das gleiche Problem wie vorher, aber jetzt der letzte arg ist unterschiedlich) aufrufen können.

Der Grund dafür ist einfach: Jedes Argument in Ruby ist nicht erforderlich, einen Standardwert hat, so dass Sie es nicht die Art und Weise rufen Sie angegeben haben. In Ihrem Fall zum Beispiel die ersten beiden Argumente haben Standardwerte nicht.

Answer 5

1) Sie können die Methode nicht überlasten ( Warum doesn‘ t Rubin Unterstützung Methode Überlastung? ) warum also nicht eine neue Methode überhaupt schreiben?

2) löste ich ein ähnliches Problem, den Splat-Operator * für eine Reihe von null oder mehr Länge verwenden. Dann, wenn ich einen Parameter übergeben werden soll (en) ich kann, wird es als ein Array interpretiert, aber wenn ich die Methode ohne Parameter aufgerufen werden soll, dann muss ich nichts passieren. Siehe Programmiersprache Ruby Seiten 186/187

Answer 6

Vor kurzem fand ich einen Weg, um dieses. Ich wollte eine Methode in der Array-Klasse mit einem optionalen Parameter erstellen, um Elemente in der Anordnung zu halten oder zu verwerfen.

So wie ich dies simuliert wurde durch einen Array als Parameter übergeben, und dann überprüft, ob der Wert an diesem Index Null war oder nicht.

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

Der Versuch, unsere Klassenmethode mit unterschiedlichen Parametern aus:

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)

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

Okay, kühl, das funktioniert wie geplant. Lassen Sie sich jetzt überprüfen und sehen, was passiert, wenn wir in dem dem dritten Parameter Option (1) in der Anordnung nicht passieren.

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)

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

Wie Sie sehen können, hat die dritte Option in dem Array entfernt worden ist, so einen anderen Abschnitt in dem Verfahren zu initiieren und der Beseitigung aller ASCII-Werte, die nicht in unserem Sortiment sind (32-126)

Alternativ könnten wir hatten den Wert als Null in den Parametern ausgegeben. Welche der folgenden Codeblock ähnlich aussehen würde:

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

Answer 7

Es ist möglich :) Ändern Sie einfach Definition

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

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

Anwendungsbereich wird nun auf dem ersten Platz in der Reihe sein. Wenn Sie drei Argumente liefern, dann werden Sie base_dn zugewiesen haben, Filter und attrs und param_array wird [] Wenn 4 und mehr Argumente dann param_array sein [argument1, or_more, and_more]

Nachteil ist, ... es ist unklar Lösung, wirklich hässlich. Dies ist zu antworten, dass es möglich ist, Argument in der Mitte des Funktionsaufrufes in Ruby ommit:)

Eine andere Sache, die Sie tun müssen, ist auf Standardwert Umfang zu umschreiben.

Answer 8

Sie können dies mit teilweise Anwendung zu tun, obwohl auf jeden Fall mit dem Namen Variablen lesbarer Code führt. John Resig einen Blog-Artikel im Jahr 2008 über schrieb, wie es in JavaScript zu tun: 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);
  };
};

Es wäre wahrscheinlich möglich sein, das gleiche Prinzip in Ruby anzuwenden (mit Ausnahme der prototypische Vererbung).