Kapan pelingkupan dinamis bermanfaat?

Dengan pelingkupan dinamis, callee dapat mengakses variabel peneleponnya. Kode Pseudo C:

void foo()
{
    print(x);
}

void bar()
{
    int x = 42;
    foo();
}

Karena saya belum pernah memprogram dalam bahasa yang mendukung pelingkupan dinamis, saya ingin tahu seperti apa beberapa kasus penggunaan dunia nyata untuk pelingkupan dinamis nantinya.

Aplikasi yang sangat berguna untuk pelingkupan dinamis adalah untuk melewatkan parameter kontekstual tanpa harus menambahkan parameter baru secara eksplisit ke setiap fungsi dalam tumpukan panggilan

Misalnya, Clojure mendukung pelingkupan dinamis melalui penjilidan , yang dapat digunakan untuk menetapkan kembali sementara nilai *out*untuk pencetakan. Jika Anda mengikat kembali *out*maka setiap panggilan untuk mencetak dalam lingkup dinamis dari penjilidan akan mencetak ke aliran output baru Anda. Sangat berguna jika, misalnya, Anda ingin mengalihkan semua hasil cetak ke beberapa jenis log debugging.

Contoh: dalam kode di bawah ini, fungsi do-stuff akan mencetak ke output debug daripada standar keluar, tetapi perhatikan bahwa saya tidak perlu menambahkan parameter output untuk melakukan-hal untuk mengaktifkan ini ....

(defn do-stuff [] 
  (do-other-stuff)
  (print "stuff done!"))

(binding [*out* my-debug-output-writer]
  (do-stuff))

Perhatikan bahwa binding Clojure juga bersifat lokal, jadi Anda tidak memiliki masalah dengan penggunaan bersamaan dari kemampuan ini. Ini membuat binding jauh lebih aman daripada (ab) menggunakan variabel global untuk tujuan yang sama.

(Penafian: Saya tidak pernah memprogram dalam bahasa pelingkupan dinamis)

Pelingkupan jauh lebih mudah diimplementasikan dan berpotensi lebih cepat. Dengan pelingkupan dinamis, hanya satu tabel simbol yang diperlukan (variabel saat ini tersedia). Itu hanya membaca dari tabel simbol ini untuk semuanya.

Bayangkan dalam Python fungsi yang sama.

def bar():
    x = 42;
    foo(42)

def foo(x):
    print x

Ketika saya memanggil bilah, saya memasukkan x ke tabel simbol. Ketika saya menelepon foo, saya mengambil tabel simbol yang saat ini digunakan untuk bar dan mendorongnya ke tumpukan. Saya kemudian memanggil foo, yang telah x diteruskan ke sana (kemungkinan telah dimasukkan ke dalam tabel simbol baru pada pemanggilan fungsi). Setelah keluar dari fungsi, saya harus menghancurkan ruang lingkup baru dan mengembalikan yang lama.

Dengan pelingkupan dinamis, ini tidak diperlukan. Saya hanya perlu mengetahui instruksi yang saya perlukan untuk kembali ketika fungsi berakhir karena tidak ada yang harus dilakukan ke tabel simbol.

Penanganan pengecualian di sebagian besar bahasa menggunakan pelingkupan dinamis; ketika pengecualian terjadi kontrol akan ditransfer kembali ke penangan terdekat pada tumpukan aktivasi (dinamis).

Tidak 100% yakin jika ini adalah pasangan yang tepat, tapi saya pikir setidaknya sudah cukup dekat dalam arti umum untuk menunjukkan di mana itu mungkin berguna untuk melanggar atau mengubah aturan pelingkupan.

Bahasa Ruby datang dengan ERB templating class, yang misalnya dalam Rails digunakan untuk menghasilkan file html. Jika Anda menggunakannya terlihat seperti ini:

require 'erb'

x = 42
template = ERB.new <<-EOF
  The value of x is: <%= x %>
EOF
puts template.result(binding)

The bindingtangan akses ke variabel lokal ke ERB pemanggilan metode, sehingga dapat mengaksesnya dan menggunakannya untuk mengisi template. (Kode antara EOF adalah string, bagian antara <% =%> dievaluasi sebagai kode Ruby oleh ERB dan akan menyatakan ruang lingkupnya sendiri seperti fungsi)

Contoh Rails lebih baik menunjukkan hal ini. Di pengontrol artikel, Anda akan menemukan sesuatu seperti ini:

def index
  @articles = Article.all

  respond_to do |format|
    format.html
    format.xml  { render :xml => @posts }
  end
end

File index.html.erb kemudian dapat menggunakan variabel lokal @articlesseperti ini (dalam hal ini pembuatan objek ERB dan pengikatan ditangani oleh kerangka Rails, jadi Anda tidak melihatnya di sini):

<ul>
<% @articles.each do |article| %>
  <li><%= article.name</li>
<% end %>
</ul>

Jadi dengan menggunakan variabel yang mengikat, Ruby memungkinkan untuk menjalankan satu dan kode templat yang sama dalam konteks yang berbeda.

Kelas ERB hanya satu contoh penggunaan. Ruby memungkinkan secara umum untuk mendapatkan status eksekusi aktual dengan pengikatan variabel dan metode dengan menggunakan pengikatan Kernel #, yang sangat berguna dalam konteks apa pun di mana Anda ingin mengevaluasi suatu metode dalam konteks yang berbeda atau ingin menyimpan konteks untuk penggunaan nanti.

Kasus penggunaan untuk pelingkupan dinamis adalah IHMO sama dengan variabel global. Pelingkupan dinamis menghindari beberapa masalah dengan variabel global yang memungkinkan pembaruan variabel yang lebih terkontrol.

Beberapa menggunakan case yang dapat saya pikirkan:

• Logging : Masuk akal untuk mengelompokkan log berdasarkan konteks runtime yang dari konteks leksikal. Anda secara dinamis dapat mengikat logger di penangan permintaan sehingga semua fungsi yang dipanggil dari sana berbagi "requestID" yang sama dalam entri log.
• Pengalihan output
• Resource Allocators : Untuk melacak sumber daya yang dialokasikan untuk tindakan / permintaan tertentu.
• Penanganan pengecualian .
• Perilaku kontekstual secara umum, misalnya Emacs mengubah pemetaan kunci dalam konteks tertentu .

Tentu saja pelingkupan dinamis tidak "mutlak diperlukan" tetapi meringankan beban karena harus meneruskan data gelandangan di sepanjang rantai panggilan atau harus menerapkan proksi global pintar dan manajer konteks.

Tetapi sekali lagi, pelingkupan dinamis berguna ketika berhadapan dengan jenis elemen yang sering kali diperlakukan sebagai global (logging, output, alokasi / manajemen sumber daya, dll).

Ada cukup banyak tidak ada. Saya harap Anda, misalnya, tidak pernah menggunakan variabel yang sama dua kali.

void foo() {
    print_int(x);
}
void bar() {
    print_string(x);
}

Sekarang bagaimana Anda memanggil foo dan bar dari fungsi yang sama?

Ini secara efektif mirip dengan hanya menggunakan variabel global, dan itu buruk untuk semua alasan yang sama.