标签: scoping

我希望这是直截了当的,我做错了.我在网上看到一些关于"变异自杀"看起来不错的东西,但它是旧版本而且我在5.10.1.

无论如何 - 我声明的变量 - $ RootDirectory - 只是突然失去了价值,我无法弄清楚原因.

这是一个重现问题的脚本.当我在调试模式(perl -d)中运行脚本时,我可以在第21行和第26行打印出$ RootDirectory.但它已经过了第30行.

use strict;
my $RootDirectory; 
my @RootDirectories; 

@RootDirectories = (
   'c:\\P4\\EDW\\PRODEDW\\EDWDM\\main\\db\\'
   ,'c:\\P4\\EDW\\PRODEDW\\EDWADS\\main\\db\\'
   ,'c:\\P4\\EDW\\PRODEDW\\FJE\\main\\db\\'
   );

foreach $RootDirectory (@RootDirectories) { 
   # $RootDirectory = 'c:\\P4\\EDW\\PRODEDW\\EDWDM\\main\\db\\';
   # print ' In foreach ' . $RootDirectory. "\n";
   RunSchema ();
} 

exit(0);

sub RunSchema() { 
   # print ' In RunSchema ' . $RootDirectory. "\n";
   CreateTables ();
} 

sub CreateTables() { 
   # print ' In CreateTables ' . $RootDirectory. "\n";
   SQLExecFolder ('tbl');
} 

sub SQLExecFolder() { 
   print …

让我在R中添加另一个范围问题,这次是降雪包.如果我在我的全局环境中定义一个函数,并且我稍后在另一个函数中的sfApply()中尝试使用该函数,则不再找到我的第一个函数:

#Runnable code. Don't forget to stop the cluster with sfStop()
require(snowfall)
sfInit(parallel=TRUE,cpus=3)

func1 <- function(x){
    y <- x+1
    y
}

func2 <- function(x){
    y <- sfApply(x,2,function(i) func1(i) )
    y
}

y <- matrix(1:10,ncol=2)
func2(y)
sfStop()

这给出了:

> func2(y)
Error in checkForRemoteErrors(val) : 
  2 nodes produced errors; first error: could not find function "func1"

如果我将我的函数嵌套在另一个函数中,它可以工作.当我在全局环境中使用sfApply()时,它也可以工作.事实是,我不想在函数2中嵌入我的函数func1,因为这会导致func1被定义多次(func2用于循环结构).

我已经尝试过简化代码以摆脱双循环,但由于问题的性质,这是不可能的.有任何想法吗？

如果在"use strict"中不允许arguments.callee,我们就做不到

var f = function g() {
    //g
}

因为在IE中不起作用(或者说"奇怪")http://kangax.github.com/nfe/#jscript-bugs,那么我们还有哪些其他选项可以引用函数中的匿名函数本身？

最近我一直在做这样的事情:

import Tkinter
class C(object):
    def __init__(self):
        self.root = Tkinter.Tk()
        def f():
            print 'hello'
        self.button = Tkinter.Button(master=self.root, command=f, text='say hello')

而不是像这样的事情:

import Tkinter
class C(object):
    def __init__(self):
        self.root = Tkinter.Tk()
        self.button = Tkinter.Button(master=self.root, command=self.f, text='say hello')
    def f(self):
        print 'hello'

问题不是特定于Tkinter,但它是一个很好的例子.该函数f仅用作按钮的回调,因此我选择在其中定义它__init__.这样,只有内部的代码才__init__知道它f的存在 - 外部范围不会开始变得杂乱无章,并且用​​户不需要关心设计为内部的方法.

我的问题是:这被认为是好风格吗？我很担心,因为我有一个带有很多按钮的GUI类 - __init__开始看起来很长,有很多本地函数定义.我应该使用更合适的替代方案吗？

可能重复:
我可以使用块来管理C++中的变量范围吗？

我遇到了一些类似的C++代码:

int main(void) {

  int foo;
  float qux;
  /* do some stuff */

  {
    int bar;
    bar = foo * foo;
    qux = some_func(bar);
  }

  /* continue doing some more stuff */
}

最初我认为也许原作者使用大括号来组合一些相关的变量,但是由于设计中的系统没有丰富的内存,我认为作者可能有意图使用bar的范围解析和任何变量离开而不是把它们放在整个封闭(foo)的范围内.

有什么理由这样做吗？在我看来,这应该是不必要的,任何现代编译器都不需要这样做？

所以我知道在Scheme中定义的是动态作用域,并且允许静态作用域,但是下面的内容让我困惑:

如果我有

(let ((x 0))
  (define f (lambda () x))
  (display (f))
  (let ((x 1))
    (display (f))
    )
  )

它将显示00.到目前为止一切顺利.但是,如果我为x添加额外的定义,如下所示:

(let ((x 0))
  (define f (lambda () x))
  (display (f))
  (define x 4)
  (let ((x 1))
    (display (f))
    )
  )

它将显示undefined4.为什么是这样？为什么在评估f 之后定义x 会影响(f)的返回值？为什么返回值"未定义"？

还值得一提的是,用letrec而不是define绑定f也会起作用:

(let ((x 0))
  (letrec ((f (lambda () x)))
  (display (f))
  (define x 4)
  (let ((x 1))
    (display (f))
    )
  )
)

返回00.

注意:我使用了DrRacket,上面写着"Pretty Big"

我有一个属于公司的模型 CompanyBranch：

class CompanyBranch < ActiveRecord::Base
  belongs_to :company
  ...
end

公司有一个属性“category_id”。现在我想通过公司的category_id 来确定CompanyBranch 的范围。像这样的东西：

scope :category, -> (category_id) { where company.category_id: category_id }

但这是行不通的。这样做的正确方法是什么？

我有一个foo包含类的包FStream.package对象foo定义了一些提供扩展器方法的隐式值类FStream.我想将这些值类从包对象中移出并放入它们自己的单独文件中,但我也希望它们在我使用时始终可用FStream(或者最好是当我使用foo包中的任何东西时.是否可以实现这一点？我尝试将隐式值类放入其他对象中,但我无法从对象扩展.尝试将它们放在类或特征中,但隐式值类只能在其他对象中定义.

富/ FStream.scala

package foo

class FStream {
  def makeFoo(): Unit = ???
}

富/ package.scala

package foo

package object foo {

  // I want to move these definitions into separate files:

  implicit class SuperFoo(val stream: FStream) extends AnyVal {
    def makeSuperFoo(): Unit = ???
  }

  implicit class HyperFoo(val stream: FStream) extends AnyVal {
    def makeHyperFoo(): Unit = ???
  }
} 

酒吧/ usage.scala

package bar

import foo._ // …

我想用lapply()R来计算几个模型,但似乎该update()函数无法处理通过生成的模型lapply().

一个最小的例子:

d1 <- data.frame(y = log(1:9), x = 1:9, trt = rep(1:3, each = 3))

f <- list(y ~ 1, y ~ x, y ~ trt)

modsa <- lapply(f, function(formula) glm(formula, data = d1))
modsb <- lapply(f, glm, data = d1)

update(modsa[[1]], data = d1[1:7, ])
#> Error: object of type 'closure' is not subsettable
update(modsb[[1]], data = d1[1:7, ])
#> Error in FUN(formula = X[[i]], data = d1[1:7, ]): could not find …

我试图将一个参数传递给一个函数，它是一个字符串，但必须同时评估它的名称（符号？）和它的值（参见下面的示例）。到目前为止，我能够用来base::get获取实际值，但分配flowCore::'transform,flowSet-method'失败。我知道关于 SO 的许多问题都是关于将字符串评估为变量名，正如您将在下面看到的，我尝试了很多。我认为必须有一个rlang基于答案的答案，但我找不到任何解决方案，任何指针将不胜感激。

一个可重现的例子：

# load required packages -------------------------------------------------------
library(flowAI)   # Bioconductor
library(flowCore) # Bioconductor
library(rlang)
# load example data ------------------------------------------------------------
data(Bcells) # from flowAI
# reprex -----------------------------------------------------------------------
timeCh <- "Time" # this could be variable

x <- flowCore::transform(Bcells,`Time`=(`Time`-min(`Time`)))           # this works
y <- flowCore::transform(Bcells,`Time`=(get(timeCh)-min(get(timeCh)))) # still good
z <- flowCore::transform(Bcells,timeCh=(get(timeCh)-min(get(timeCh)))) # not good

虽然在上面的代码中，转换 forz将运行得很好，但实际上一个新列被添加到名为“timeCh”的 flowSet 中。这不是想要的效果，因为我想使用转换来专门更改现有的 column Time。因此，我一直在尝试一些策略来评估存储在 timeCh 中的字符串作为对象名称 (?) into transform，但无济于事：

timeSym <- sym("Time")
timequo <- …