标签: lexical-scope

有人可以给我一个关于词汇范围的简要介绍吗？

我刚读完R简介中的范围界定,对这项<<-任务非常好奇.

手册显示了一个(非常有趣)的例子<<-,我觉得我理解.我仍然缺少的是这可能有用的背景.

因此,我希望从您那里读到的是关于何时使用<<-可能有趣/有用的示例(或示例链接).使用它的危险可能是什么(它看起来容易松散),以及您可能想要分享的任何提示.

我正在阅读Peter Seibel撰写的"Practical Common Lisp"一书.

在第6章"变量"部分"词汇变量和闭包"和"动态,又称特殊,变量". http://www.gigamonkeys.com/book/variables.html

我的问题是两个部分中的示例都显示了(让...)如何影响全局变量,并没有真正说明动态和词汇变量之间的区别.

我理解闭包是如何工作的,但我真的不知道在这个例子中让我们如此特别:

(defvar *x* 10)

(defun foo ()
  (format t "Before assignment~18tX: ~d~%" *x*)
  (setf *x* (+ 1 *x*))
  (format t "After assignment~18tX: ~d~%" *x*))


(defun bar ()
  (foo)
  (let ((*x* 20)) (foo))
  (foo))


CL-USER> (foo)
Before assignment X: 10
After assignment  X: 11
NIL


CL-USER> (bar)
Before assignment X: 11
After assignment  X: 12
Before assignment X: 20
After assignment  X: 21
Before assignment X: 12
After assignment  X: 13
NIL

我觉得这里没什么特别的.外FOO …

这是原始SO问题的延续:使用"::"而不是"module ..."来表示Ruby命名空间

在最初的SO问题中,这里是我仍然无法理解的情景:

FOO = 123

module Foo
  FOO = 555
end

module Foo
  class Bar
    def baz
      puts FOO
    end
  end
end

class Foo::Bar
  def glorf
    puts FOO
  end
end

puts Foo::Bar.new.baz    # -> 555
puts Foo::Bar.new.glorf  # -> 123

有人可以提供一些解释为什么第一个呼叫返回555以及为什么第二个呼叫返回123？

通常我会在setInterval中引用"this"时指定一个替代的"self"引用.是否有可能在原型方法的上下文中完成类似的事情？以下代码错误.

function Foo() {}
Foo.prototype = {
    bar: function () {
        this.baz();
    },
    baz: function () {
        this.draw();
        requestAnimFrame(this.baz);
    }
};

我已经了解到静态作用域是唯一理智的做事方式,而动态作用域是魔鬼的工具,而且只是由于解释器/编译器的不良实现.

然后我从Common Lisp vs. Scheme文章中看到了这个片段:

Both Lexically and Dynamically    Lexical scope only, per the standard.
scoped special vars.  Common      Dynamically scoped vars are provided
Lisp just wins on this point.     by some implementations as an extension
                                  but code using them is not portable.

     (I have heard the arguments about whether Dynamic scoping
      is or is not a Bad Idea in the first place.  I don't care. 
      I'm just noting that you can do things …

Emacs 24现在具有词法范围的变量.当然,它还具有动态范围的变量.既然它有两者,我很困惑变量什么时候会有哪种范围.有一个lexical-binding变量控制何时启用词法绑定,我想我defvar现在读到一些关于动态范围变量的声明,但总的来说我很丢失.在Emacs 24的新范围规则中,是否有一个很好的解释？换句话说,当我查看为Emacs 24编写的Emacs Lisp代码中的变量时,如何判断变量使用的范围？

F#具有称为"类型扩展"的功能,使开发人员能够扩展现有类型.有两种类型的扩展:内在扩展和可选扩展.第一个类似于C#中的部分类型,第二个类似于方法扩展(但更强大).

要使用内部扩展,我们应该将两个声明放入同一个文件中.在这种情况下,编译器会将两个定义合并为一个最终类型(即这是一种类型的两个"部分").

问题是这两种类型对不同的成员和值有不同的访问规则:

// SampleType.fs
// "Main" declaration
type SampleType(a: int) =
    let f1 = 42
    let func() = 42

    [<DefaultValue>]
    val mutable f2: int
    member private x.f3 = 42
    static member private f4 = 42

    member private this.someMethod() =
        // "Main" declaration has access to all values (a, f1 and func())
        // as well as to all members (f2, f3, f4)
        printf "a: %d, f1: %d, f2: %d, f3: %d, f4: %d, func(): …

通过学习R,我只是碰到下面的代码解释这里.

open.account <- function(total) {
  list(
    deposit = function(amount) {
      if(amount <= 0)
        stop("Deposits must be positive!\n")
      total <<- total + amount
      cat(amount, "deposited.  Your balance is", total, "\n\n")
    },
    withdraw = function(amount) {
      if(amount > total)
        stop("You don't have that much money!\n")
      total <<- total - amount
      cat(amount, "withdrawn.  Your balance is", total, "\n\n")
    },
    balance = function() {
      cat("Your balance is", total, "\n\n")
    }
  )
}

ross <- open.account(100)
robert <- open.account(200)

ross$withdraw(30)
ross$balance() …

所以我是编程的新手,我正在尝试用Eloquent Javascript这本书来学习JS.

到目前为止一直很好,直到我用以下代码到达一个例子

function makeAddFunction(amount) {
  function add(number) {
    return number + amount;
  }
  return add;
}

var addTwo = makeAddFunction(2);
var addFive = makeAddFunction(5);
show(addTwo(1) + addFive(1));

注意:show就像alert,只显示教程集成的JS控制台屏幕上的变量.

作者说这是一个展示词汇范围如何允许合成函数的例子. 这里的章节

我不明白的是如何addTwo和addFive,这理应是变量,可以将参数传递给函数makeAddFunction和add,更具体地说,请问该函数add知道变量要发送的参数是参数number.

谢谢你的帮助!