Apakah double-colon Ruby `::`?

Apa ini double-colon ::? Misalnya Foo::Bar.

Saya menemukan definisi :

Ini ::adalah operator unary yang memungkinkan: konstanta, metode instance dan metode kelas yang didefinisikan dalam kelas atau modul, dapat diakses dari mana saja di luar kelas atau modul.

Apa gunanya ruang lingkup (pribadi, terlindungi) jika Anda bisa menggunakannya ::untuk mengekspos sesuatu?

::pada dasarnya adalah operator resolusi namespace. Ini memungkinkan Anda untuk mengakses item dalam modul, atau item tingkat kelas di kelas. Misalnya, Anda memiliki pengaturan ini:

module SomeModule
    module InnerModule
        class MyClass
            CONSTANT = 4
        end
    end
end

Anda dapat mengakses CONSTANTdari luar modul sebagai SomeModule::InnerModule::MyClass::CONSTANT.

Itu tidak memengaruhi metode instance yang didefinisikan pada kelas, karena Anda mengaksesnya dengan sintaks yang berbeda (titik .).

Catatan yang relevan: Jika Anda ingin kembali ke namespace tingkat atas, lakukan ini: :: SomeModule - Benjamin Oakes

Contoh sederhana ini menggambarkannya:

MR_COUNT = 0        # constant defined on main Object class
module Foo
  MR_COUNT = 0
  ::MR_COUNT = 1    # set global count to 1
  MR_COUNT = 2      # set local count to 2
end

puts MR_COUNT       # this is the global constant: 1
puts Foo::MR_COUNT  # this is the local constant: 2

Diambil dari http://www.tutorialspoint.com/ruby/ruby_operators.htm

::Memungkinkan Anda mengakses konstanta, modul, atau kelas yang ditentukan di dalam kelas atau modul lain. Ini digunakan untuk menyediakan ruang nama sehingga metode dan nama kelas tidak bertentangan dengan kelas lain oleh penulis yang berbeda.

Ketika Anda melihat ActiveRecord::Basedi Rails itu berarti Rails memiliki sesuatu seperti

module ActiveRecord
  class Base
  end
end

yaitu kelas yang disebut Basedi dalam modul ActiveRecordyang kemudian dirujuk sebagai ActiveRecord::Base(Anda dapat menemukan ini di sumber Rails di activerecord-nnn / lib / active_record / base.rb)

Penggunaan umum :: adalah untuk mengakses konstanta yang didefinisikan dalam modul misalnya

module Math
  PI = 3.141 # ...
end

puts Math::PI

The ::operator tidak memungkinkan Anda untuk visibilitas memotong metode ditandai pribadi atau dilindungi.

Apa gunanya ruang lingkup (pribadi, terlindungi) jika Anda bisa menggunakan :: untuk mengekspos sesuatu?

Di Ruby, semuanya terbuka dan semuanya dapat dimodifikasi dari tempat lain.

Jika Anda khawatir tentang fakta bahwa kelas dapat diubah dari luar "definisi kelas", maka Ruby mungkin bukan untuk Anda.

Di sisi lain, jika Anda frustrasi dengan kelas Java dikunci, maka Ruby mungkin adalah yang Anda cari.

Menambahkan ke jawaban sebelumnya, itu sah Ruby untuk digunakan ::untuk mengakses metode contoh. Semua yang berikut ini valid:

MyClass::new::instance_method
MyClass::new.instance_method
MyClass.new::instance_method
MyClass.new.instance_method

_{Sesuai praktik terbaik saya percaya hanya yang terakhir direkomendasikan.}

Tidak, ini bukan untuk mengakses setiap metode, ini adalah operator "resolusi", yaitu, Anda menggunakannya untuk menyelesaikan ruang lingkup (atau lokasi yang dapat Anda katakan) dari simbol konstan / statis.

Sebagai contoh di baris pertama Anda, Rails menggunakannya untuk menemukan kelas Base di dalam ActiveRecord.Module, yang kedua digunakan untuk menemukan metode kelas (statis) dari kelas Rute, dll, dll.

Itu tidak digunakan untuk mengekspos apa pun, itu digunakan untuk "menemukan" barang-barang di sekitar lingkup Anda.

http://en.wikipedia.org/wiki/Scope_resolution_operator

Anehnya, semua 10 jawaban di sini mengatakan hal yang sama. '::' adalah operator resolusi namespace, dan ya itu benar. Tetapi ada satu gotcha yang harus Anda sadari tentang operator resolusi namespace ketika datang ke algoritma pencarian konstan . Sebagai Matz menggambarkan dalam bukunya, 'Bahasa Pemrograman Ruby', pencarian konstan memiliki beberapa langkah. Pertama, ia mencari konstanta dalam lingkup leksikal di mana konstanta direferensikan. Jika tidak menemukan konstanta dalam lingkup leksikal, maka ia akan mencari hierarki warisan . Karena algoritma pencarian konstan ini, di bawah ini kami mendapatkan hasil yang diharapkan:

module A
  module B
      PI = 3.14
      module C
        class E
          PI = 3.15
        end
        class F < E
          def get_pi
            puts PI
          end
        end
      end
  end
end
f = A::B::C::F.new
f.get_pi
> 3.14

Sementara F mewarisi dari E, modul B berada dalam ruang lingkup leksikal F. Akibatnya, instance F akan merujuk ke PI konstan yang didefinisikan dalam modul B. Sekarang jika modul B tidak mendefinisikan PI, maka instance F akan merujuk ke PI konstan didefinisikan dalam superclass E.

Tetapi bagaimana jika kita menggunakan modul '::' daripada bersarang? Apakah kita akan mendapatkan hasil yang sama? Tidak!

Dengan menggunakan operator resolusi namespace ketika mendefinisikan modul bersarang, modul dan kelas bersarang tidak lagi dalam lingkup leksikal dari modul luar mereka. Seperti yang Anda lihat di bawah, PI yang didefinisikan dalam A :: B tidak dalam lingkup leksikal A :: B :: C :: D dan dengan demikian kita mendapatkan konstanta yang tidak diinisialisasi ketika mencoba merujuk ke PI dalam metode instance get_pi:

module A
end

module A::B
  PI = 3.14
end

module A::B::C
  class D
    def get_pi
      puts PI
    end
  end
end
d = A::B::C::D.new
d.get_pi
NameError: uninitialized constant A::B::C::D::PI
Did you mean?  A::B::PI

Ini semua tentang mencegah definisi dari bentrok dengan kode lain yang terhubung ke proyek Anda. Itu berarti Anda dapat memisahkan hal-hal.

Misalnya Anda dapat memiliki satu metode yang disebut "run" di kode Anda dan Anda masih dapat memanggil metode Anda daripada metode "run" yang telah didefinisikan di beberapa perpustakaan lain yang telah Anda tautkan.

module Amimal
      module Herbivorous
            EATER="plants" 
      end
end

Amimal::Herbivorous::EATER => "plants"

:: Digunakan untuk membuat ruang lingkup. Untuk mengakses Constant EATER dari 2 modul, kita perlu mengatur cakupan modul untuk mencapai konstanta

Ruby on rails digunakan ::untuk resolusi namespace.

class User < ActiveRecord::Base

  VIDEOS_COUNT = 10
  Languages = { "English" => "en", "Spanish" => "es", "Mandarin Chinese" => "cn"}

end

Untuk menggunakannya:

User::VIDEOS_COUNT
User::Languages
User::Languages.values_at("Spanish") => "en"

Juga, penggunaan lainnya adalah: Saat menggunakan rute bersarang

OmniauthCallbacksController didefinisikan di bawah pengguna.

Dan dialihkan sebagai:

devise_for :users, controllers: {omniauth_callbacks: "users/omniauth_callbacks"}


class Users::OmniauthCallbacksController < Devise::OmniauthCallbacksController

end