Kaedah Ruby

Syntax

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
   expr..
end

Jadi, anda boleh mentakrifkan kaedah mudah seperti ini:

def method_name 
   expr..
end

Anda boleh menentukan kaedah yang menerima parameter seperti ini:

Anda boleh menetapkan nilai lalai untuk parameter, yang akan digunakan jika parameter yang diperlukan tidak diluluskan semasa memanggil kaedah:

def method_name (var1, var2)
   expr..
end

Apabila anda ingin memanggil kaedah, hanya gunakan nama kaedah, seperti yang ditunjukkan di bawah:

def method_name (var1=value1, var2=value2)
   expr..
end

Walau bagaimanapun, apabila anda memanggil kaedah dengan parameter, anda juga perlu membawa parameter semasa menulis nama kaedah, contohnya:

method_name

Kelemahan terbesar menggunakan kaedah dengan parameter ialah apabila memanggil kaedah Perlu ingat bilangan parameter. Sebagai contoh, jika anda menghantar hanya dua parameter kepada kaedah yang menerima tiga parameter, Ruby akan memaparkan ralat.

Instance

method_name 25, 30

Contoh di atas menjalankan hasil output ialah:

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

def test(a1="Ruby", a2="Perl")
   puts "编程语言为 #{a1}"
   puts "编程语言为 #{a2}"
end
test "C", "C++"
test

Nilai pulangan daripada kaedah

Ruby Every kaedah mengembalikan nilai secara lalai. Nilai yang dikembalikan ialah nilai pernyataan terakhir. Contohnya:

编程语言为 C
编程语言为 C++
编程语言为 Ruby
编程语言为 Perl

Apabila kaedah ini dipanggil, pembolehubah yang diisytiharkan terakhir k akan dikembalikan.

Ruby return Pernyataan

Penyataan return dalam Ruby digunakan untuk mengembalikan satu atau lebih nilai ​​daripada kaedah Ruby.

Sintaks

def test
   i = 100
   j = 10
   k = 0
end

Jika lebih daripada dua ungkapan diberikan, tatasusunan yang mengandungi nilai tersebut akan menjadi nilai pulangan. Jika tiada ungkapan diberikan, nil akan menjadi nilai pulangan.

Contoh

return [expr[`,' expr...]]

Lihat contoh berikut:

return

或

return 12

或

return 1,2,3

Hasil keluaran contoh di atas ialah:

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

Bilangan parameter berubah

Katakan anda mengisytiharkan kaedah dengan dua parameter Apabila anda memanggil kaedah, anda juga perlu lulus dua parameter.

Walau bagaimanapun, Ruby membenarkan anda mengisytiharkan kaedah dengan bilangan parameter yang berubah-ubah. Mari lihat contoh berikut:

100
200
300

Dalam kod ini, anda telah mengisytiharkan sampel kaedah yang menerima ujian parameter. Walau bagaimanapun, parameter ini adalah parameter berubah. Ini bermakna bahawa parameter boleh mengambil bilangan pembolehubah yang berbeza. Hasil keluaran contoh di atas ialah:

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

def sample (*test)
   puts "参数个数为 #{test.length}"
   for i in 0...test.length
      puts "参数值为 #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

Kaedah kelas

Apabila kaedah ditakrifkan di luar kelas, kaedah ditandakan peribadi secara lalai. Sebaliknya, jika kaedah ditakrifkan dalam kelas, ia ditandakan awam secara lalai. Keterlihatan lalai kaedah

dan teg peribadi boleh ditukar melalui modul awam atau peribadi modul.

Apabila anda ingin mengakses kaedah kelas, anda perlu membuat seketika kelas tersebut. Kemudian, menggunakan objek, anda boleh mengakses mana-mana ahli kelas.

Ruby menyediakan cara untuk mengakses kaedah tanpa instantiasi. Mari lihat cara mengisytiharkan dan mengakses kaedah kelas:

参数个数为 3
参数值为 Zara
参数值为 6
参数值为 F
参数个数为 4
参数值为 Mac
参数值为 36
参数值为 M
参数值为 MCA

Kita sudah tahu bagaimana kaedah return_date diisytiharkan. Ia diisytiharkan dengan mengikut nama kelas dengan noktah, diikuti dengan nama kaedah. Anda boleh mengakses kaedah kelas secara langsung seperti berikut:

class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end

Untuk mengakses kaedah ini, anda tidak perlu mencipta objek Akaun kelas.

Ruby alias pernyataan

Pernyataan ini digunakan untuk alias kaedah atau pembolehubah global. Alias ​​tidak boleh ditakrifkan dalam badan kaedah. Alias ​​kaedah mengekalkan definisi semasa kaedah walaupun kaedah itu ditindih.

Aliasing pembolehubah global bernombor ($1, $2,...) adalah dilarang. Mengatasi pembolehubah global terbina dalam boleh menyebabkan masalah yang serius.

Sintaks

Accounts.return_date

Contoh

alias 方法名 方法名
alias 全局变量 全局变量

Di sini, kami telah mentakrifkan alias untuk bar sebagai foo dan alias untuk $& sebagai $MATCH.

Ruby undef Pernyataan

Pernyataan ini digunakan untuk menyahtakrifkan kaedah. undef tidak boleh muncul dalam badan kaedah.

Dengan menggunakan undef dan alias, antara muka kelas boleh diubah suai secara bebas daripada kelas induk, tetapi sila ambil perhatian bahawa ia mungkin memecahkan atur cara semasa memanggil kaedah dalam dirinya sendiri.

Sintaks

alias foo bar
alias $MATCH $&

Contoh

Contoh berikut membatalkan takrif kaedah bernama bar:

undef 方法名