Khi phạm vi năng động sẽ hữu ích?

Với phạm vi động, một callee có thể truy cập các biến của trình gọi của nó. Mã giả C:

void foo()
{
    print(x);
}

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

Vì tôi chưa bao giờ lập trình bằng một ngôn ngữ hỗ trợ phạm vi động, tôi tự hỏi một số trường hợp sử dụng trong thế giới thực cho phạm vi động sẽ là gì.

Một ứng dụng rất hữu ích của phạm vi động là để truyền các tham số theo ngữ cảnh mà không cần phải thêm các tham số mới một cách rõ ràng vào mọi chức năng trong ngăn xếp cuộc gọi

Ví dụ, Clojure hỗ trợ phạm vi động thông qua liên kết , có thể được sử dụng để tạm thời gán lại giá trị của *out*việc in. Nếu bạn liên kết lại *out*thì mọi cuộc gọi để in trong phạm vi động của liên kết sẽ in ra luồng đầu ra mới của bạn. Rất hữu ích nếu, ví dụ, bạn muốn chuyển hướng tất cả đầu ra được in sang một loại nhật ký gỡ lỗi nào đó.

Ví dụ: trong đoạn mã bên dưới, hàm do-Stuff sẽ in ra đầu ra gỡ lỗi thay vì ra ngoài tiêu chuẩn, nhưng lưu ý rằng tôi không cần thêm tham số đầu ra vào công cụ để kích hoạt điều này ....

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

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

Lưu ý rằng các ràng buộc của Clojure cũng là luồng cục bộ, do đó bạn không gặp vấn đề gì với việc sử dụng đồng thời khả năng này. Điều này làm cho các ràng buộc an toàn hơn đáng kể so với (ab) sử dụng các biến toàn cục cho cùng một mục đích.

(Tuyên bố miễn trừ trách nhiệm: Tôi chưa bao giờ lập trình bằng ngôn ngữ phạm vi động)

Phạm vi dễ thực hiện hơn nhiều và có khả năng nhanh hơn. Với phạm vi động, chỉ cần một bảng biểu tượng (các biến hiện có). Nó chỉ đọc từ bảng biểu tượng này cho tất cả mọi thứ.

Hãy tưởng tượng trong Python cùng chức năng.

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

def foo(x):
    print x

Khi tôi gọi thanh, tôi đặt x vào bảng ký hiệu. Khi tôi gọi foo, tôi lấy bảng biểu tượng hiện được sử dụng cho thanh và đẩy nó lên ngăn xếp. Sau đó tôi gọi foo, có x được truyền cho nó (có khả năng đã được đưa vào bảng ký hiệu mới khi gọi hàm). Sau khi thoát khỏi chức năng, tôi phải hủy phạm vi mới và khôi phục lại phạm vi cũ.

Với phạm vi năng động, điều này là không cần thiết. Tôi chỉ cần biết hướng dẫn tôi cần quay lại khi hàm kết thúc vì không có gì phải làm với bảng ký hiệu.

Xử lý ngoại lệ trong hầu hết các ngôn ngữ sử dụng phạm vi động; khi một ngoại lệ xảy ra, điều khiển sẽ được chuyển trở lại trình xử lý gần nhất trên ngăn xếp kích hoạt (động).

Không chắc chắn 100% nếu đây là một trận đấu chính xác, nhưng tôi nghĩ ít nhất nó cũng đủ gần theo nghĩa chung để chỉ ra nơi nào có thể được sử dụng để phá vỡ hoặc thay đổi quy tắc phạm vi.

Ngôn ngữ Ruby xuất hiện lớp ERB templating, ví dụ trong Rails được sử dụng để tạo các tệp html. Nếu bạn sử dụng nó trông như thế này:

require 'erb'

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

Các bindingtay truy cập vào các biến cục bộ vào lệnh gọi phương thức ERB, vì vậy nó có thể truy cập chúng và sử dụng chúng để điền vào mẫu. (Mã giữa các EOF là một chuỗi, phần nằm giữa <% =%> được đánh giá là mã Ruby bởi ERB và sẽ khai báo phạm vi của chính nó giống như một hàm)

Một ví dụ Rails thậm chí còn chứng minh điều này tốt hơn. Trong một trình điều khiển bài viết, bạn sẽ tìm thấy một cái gì đó như thế này:

def index
  @articles = Article.all

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

Sau đó, tệp index.html.erb có thể sử dụng biến cục bộ @articlesnhư thế này (trong trường hợp này việc tạo đối tượng ERB và ràng buộc được xử lý bởi khung Rails, vì vậy bạn không thấy nó ở đây):

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

Vì vậy, bằng cách sử dụng một biến liên kết, Ruby cho phép chạy một và cùng một mã mẫu trong các bối cảnh khác nhau.

Lớp ERB chỉ là một ví dụ về việc sử dụng. Ruby nói chung cho phép có được trạng thái thực thi thực tế với các ràng buộc biến và phương thức bằng cách sử dụng ràng buộc Kernel #, rất hữu ích trong bất kỳ bối cảnh nào bạn muốn đánh giá một phương thức trong ngữ cảnh khác nhau hoặc muốn giữ bối cảnh để sử dụng sau này.

Các trường hợp sử dụng cho phạm vi động là IHMO giống như đối với các biến toàn cục. Phạm vi động tránh một số vấn đề với các biến toàn cục cho phép cập nhật biến được kiểm soát nhiều hơn.

Một số trường hợp sử dụng mà tôi có thể nghĩ ra:

• Ghi nhật ký : Có ý nghĩa hơn đối với nhật ký nhóm theo ngữ cảnh thời gian chạy từ bối cảnh từ vựng. Bạn có thể liên kết một cách ngẫu nhiên bộ ghi nhật ký tại một trình xử lý yêu cầu để tất cả các hàm được gọi từ đó chia sẻ cùng một "requestID" trong các mục nhật ký.
• Chuyển hướng đầu ra
• Phân bổ tài nguyên : Để theo dõi các tài nguyên được phân bổ cho một hành động / yêu cầu cụ thể.
• Xử lý ngoại lệ .
• Hành vi bối cảnh nói chung, ví dụ Emacs thay đổi ánh xạ khóa trong các bối cảnh nhất định .

Tất nhiên, phạm vi động không phải là "hoàn toàn bắt buộc" nhưng giảm bớt gánh nặng phải truyền dữ liệu của người đi theo chuỗi cuộc gọi hoặc phải thực hiện các proxy và quản lý bối cảnh toàn cầu thông minh.

Nhưng một lần nữa, phạm vi động lại có ích khi xử lý các loại yếu tố được coi là toàn cầu (ghi nhật ký, đầu ra, phân bổ / quản lý tài nguyên, v.v.).

Có khá nhiều không có. Tôi chắc chắn hy vọng rằng bạn, ví dụ, không bao giờ sử dụng cùng một biến hai lần.

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

Bây giờ làm thế nào để bạn gọi cả foo và bar từ cùng một chức năng?

Điều này thực sự giống với việc sử dụng một biến toàn cục và nó không tốt cho tất cả các lý do tương tự.