小编Ste*_*eve的帖子

我正在尝试使用perl正则表达式来编写一个简单的语法(请注意,这不是用于生产用途,只是用于提供编辑器提示/完成的快速分析).例如,

my $GRAMMAR = qr{(?(DEFINE)
  (?<expr> \( (?&expr) \) | (?&number) | (?&var) | (?&expr) (?&op) (?&expr) )
  (?<number> \d++ )
  (?<var> [a-z]++ )
  (?<op> [-+*/] )
)}x;

我希望能够像这样运行

$expr =~ /$GRAMMAR(?&expr)/;

然后访问所有变量名称.然而,根据perlre,

请注意,在递归返回后,无法访问在递归内部匹配的捕获组,因此需要额外的捕获组层.因此,即使$ + {NAME},也不会定义$ + {NAME_PAT}.

显然这是不可能的.我可以尝试使用(?{ code })块来将变量名称保存到散列中,但这并不尊重回溯(即,即使变量已经过回溯,分配的副作用仍然存在).

是否有任何方法可以获取给定命名捕获组捕获的所有内容,包括递归匹配？或者我是否需要手动挖掘各个部分(从而复制所有模式)？

我可以通过几种不同的方式初始化复杂对象(注入依赖项和注入成员所需的设置),看起来都很合理,但各有利弊.我举一个具体的例子:

final class MyClass {
  private final Dependency dependency;
  @Inject public MyClass(Dependency dependency) {
    this.dependency = dependency;
    dependency.addHandler(new Handler() {
      @Override void handle(int foo) { MyClass.this.doSomething(foo); }
    });
    doSomething(0);
  }
  private void doSomething(int foo) { dependency.doSomethingElse(foo+1); }
}

如您所见,构造函数执行了3项操作,包括调用实例方法.我被告知从构造函数中调用实例方法是不安全的,因为它绕过了编译器对未初始化成员的检查.即我可以doSomething(0)在设置之前调用this.dependency,这将编译但不起作用.重构这个的最佳方法是什么？

1. make doSomethingstatic并明确传入依赖项？在我的实际情况中,我有三个实例方法和三个成员字段都相互依赖,所以这似乎是很多额外的样板,使所有这三个静态.

2. 移动addHandler并doSomething进入@Inject public void init()方法.虽然使用Guice是透明的,但它需要任何手动构造才能确保调用init(),否则如果有人忘记,对象将无法完全发挥作用.此外,这暴露了更多的API,这两者似乎都是坏主意.

3. 包装嵌套类以保持依赖关系以确保其行为正常而不暴露其他API:

   class DependencyManager {
     private final Dependency dependency;
     public DependecyManager(Dependency dependency) { ... }
     public doSomething(int foo) { ... }
   }
   @Inject …

我有一个Class<? extends Annotation>并且尝试过调用newInstance()但是Java因为我无法实例化接口的明显原因而对我大吼大叫.但我知道像EasyMock这样的框架完全能够实例化接口.Annotation从我的身上得到一个完全愚蠢的实例需要Class什么？

我在 ES 模块中定义了一个函数，我想确保内联。当它仅在一个块中使用时，这工作正常，但是如果我从两个单独的块调用该函数，webpack 会生成阻止内联的模块查找模式：

// common.js
export function inlineMe(x) {
  return x;
}

// main.js
import {inlineMe} from './common';
import('./ext').then(ext => {
  if (inlineMe(true)) {
    ext.f();
  } else {
    console.log('not inlined');
  }
});

// ext.js
import {inlineMe} from './common';
export function f() {
  console.log(inlineMe(true) ? 'inlined' : 'not inlined');
}

使用具有以下合理标准选项的 TerserPlugin 通过 webpack 运行它

// webpack.config.js
module.exports = {
  mode: 'production',
  entry: './main.js',
  optimization: {
    minimizer: [
      new TerserPlugin({
        terserOptions: {
          compress: {passes: 50, inline: true, unsafe: true},
        }, …

鉴于以下特征和实现：

trait Wrapper<Type> {
    type Inner : Wrapped<Type>;
    fn bind<B, F>(self, f: F) -> <B as Wrapped<Type>>::Outer
        where B: Wrapped<Type>, F: Fn(Self::Inner) -> <B as Wrapped<Type>>::Outer;
}

trait Wrapped<Type> {
    type Outer : Wrapper<Type>;
}

struct Opt;

impl<T> Wrapped<Opt> for T {
    type Outer = Option<T>;
}

impl<T> Wrapper<Opt> for Option<T> {
    type Inner = T;
    fn bind<B, F>(self, f: F) -> <B as Wrapped<Opt>>::Outer
        where B: Wrapped<Opt>, F: Fn(Self::Inner) -> <B as Wrapped<Opt>>::Outer {
        match self {
            Some(a) => …