Parameter opsional Ruby

Jika saya mendefinisikan fungsi Ruby seperti ini:

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

Bagaimana saya bisa menyebutnya hanya memasok 2 argumen pertama dan argumen terakhir? Kenapa tidak seperti itu

ldap_get( base_dn, filter, , X)

mungkin atau jika memungkinkan, bagaimana cara melakukannya?

Ini tidak mungkin dengan ruby ​​saat ini. Anda tidak dapat meneruskan atribut 'kosong' ke metode. Yang paling dekat yang bisa Anda dapatkan adalah melewati nihil:

ldap_get(base_dn, filter, nil, X)

Namun, ini akan menyetel cakupan ke nihil, bukan LDAP :: LDAP_SCOPE_SUBTREE.

Apa yang dapat Anda lakukan adalah menyetel nilai default dalam metode Anda:

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

Sekarang jika Anda memanggil metode seperti di atas, perilakunya akan seperti yang Anda harapkan.

Anda hampir selalu lebih baik menggunakan hash opsi.

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

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

Waktu telah berlalu dan sejak versi 2 Ruby mendukung parameter bernama:

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"

Tidak mungkin melakukannya dengan cara yang Anda tentukan ldap_get. Namun, jika Anda mendefinisikan ldap_getseperti ini:

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

Sekarang kamu bisa:

ldap_get( base_dn, filter, X )

Tetapi sekarang Anda memiliki masalah yang tidak dapat Anda sebut dengan dua argumen pertama dan argumen terakhir (masalah yang sama seperti sebelumnya tetapi sekarang argumen terakhir berbeda).

Alasannya sederhana: Setiap argumen di Ruby tidak diharuskan memiliki nilai default, jadi Anda tidak bisa menyebutnya seperti yang Anda tentukan. Dalam kasus Anda, misalnya, dua argumen pertama tidak memiliki nilai default.

1) Anda tidak dapat membebani metode ( Mengapa ruby ​​tidak mendukung metode kelebihan beban? ) Jadi mengapa tidak menulis metode baru sama sekali?

2) Saya memecahkan masalah serupa menggunakan operator percikan * untuk array dengan panjang nol atau lebih. Kemudian, jika saya ingin mengirimkan parameter yang saya bisa, itu diartikan sebagai array, tetapi jika saya ingin memanggil metode tanpa parameter apa pun maka saya tidak perlu melewatkan apa pun. Lihat Bahasa Pemrograman Ruby halaman 186/187

Baru-baru ini saya menemukan jalan keluarnya. Saya ingin membuat metode di kelas array dengan parameter opsional, untuk menyimpan atau membuang elemen dalam array.

Cara saya mensimulasikan ini adalah dengan melewatkan array sebagai parameter, dan kemudian memeriksa apakah nilai pada indeks itu nihil atau tidak.

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

Mencoba metode kelas kami dengan parameter berbeda:

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)

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

Oke, keren itu berfungsi sesuai rencana. Sekarang mari kita periksa dan lihat apa yang terjadi jika kita tidak meneruskan opsi parameter ketiga (1) dalam 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)

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

Seperti yang Anda lihat, opsi ketiga dalam larik telah dihapus, sehingga memulai bagian yang berbeda dalam metode dan menghapus semua nilai ASCII yang tidak berada dalam jangkauan kami (32-126)

Alternatifnya, kita bisa mengeluarkan nilai nihil dalam parameter. Yang akan terlihat mirip dengan blok kode berikut:

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

Mungkin saja :) Ubah saja definisi

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

untuk

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

scope sekarang akan berada dalam array di tempat pertama. Ketika Anda memberikan 3 argumen, maka Anda akan menetapkan base_dn, filter dan attrs dan param_array akan menjadi [] Ketika 4 dan lebih banyak argumen maka param_array akan menjadi [argument1, or_more, and_more]

Kelemahannya adalah ... ini adalah solusi yang tidak jelas, sangat jelek. Ini untuk menjawab bahwa dimungkinkan untuk menghilangkan argumen di tengah pemanggilan fungsi di ruby ​​:)

Hal lain yang harus Anda lakukan adalah menulis ulang nilai default dari scope.

Anda dapat melakukan ini dengan aplikasi parsial, meskipun menggunakan variabel bernama pasti menghasilkan kode yang lebih mudah dibaca. John Resig menulis artikel blog pada tahun 2008 tentang cara melakukannya di JavaScript: http://ejohn.org/blog/p 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);
  };
};

Mungkin akan memungkinkan untuk menerapkan prinsip yang sama di Ruby (kecuali untuk pewarisan prototipe).