标签: chain

问题出在标题上,但首先请看一下这段代码:

function number(a) {
    return {
        add: function(b) {
            result = a + b;
            return this;
        }, substract(b) {
            result = a - b;
            return this;
        }
}

以上代码是链规则的简单示例.我重新调整了一个对象,所以我可以连续执行:

number(2).add(5).add(3 * 12).substract(Math.random());

我的问题是,我必须重新调用一个对象以保持函数可链接.我想模仿链规则,但要返回具体的价值.例如,number(2).add(3)将返回5.

任何建议都非常感谢.

谢谢大家先进.[X]

我想找到从/到特定节点的所有路径。我希望路径中的每个节点只出现一次。

例如，在这样的图中：

(a)-[:REL]->(b)-[:REL]->(c)-[:REL]->(a)\n(a)-[:REL]->(e)-[:REL]->(f)-[:REL]->(a)\n(e)-[:REL]->(b)\n

以图形方式：

  e \xe2\x86\x92 b\n \xe2\x86\x99 \xe2\x86\x96 \xe2\x86\x97 \xe2\x86\x98\nf \xe2\x86\x92 a \xe2\x86\x90 c\n

密码：

CREATE (a { name:'A' })-[:REL]->(b {name:'B'})-[:REL]->(c { name:'C' })\n       -[:REL]->(a)-[:REL]->(e {name:'E'})-[:REL]->(f {name:'F'})-[:REL]->(a),\n       (e)-[:REL]->(b)\n

我希望从（a）开始的链研究能够回归

(a)->(b)->(c)->(a)\n\n(a)->(e)->(f)->(a)\n\n(a)->(e)->(b)->(c)->(a)\n

而从 (f) 开始仅返回

(f)->(a)->(e)->(f)\n

并不是

(f)->(a)->(b)->(c)->(a)->(e)->(f)\n

因为它两次通过节点 (a)。

我尝试过：

MATCH p=(a {name:'F'})-[:REL*1..]->(a) \nWHERE SINGLE(e1 IN TAIL(NODES(p)) WHERE SINGLE(e2 IN TAIL(NODES(p)) WHERE e1=e2))\nRETURN p\n

但我没有得到结果。\n我能达到的最好结果是不重复此查询的起始节点：

MATCH p=(a {name:'F'})-[:REL*1..]->(a) \nWHERE SINGLE(e IN TAIL(NODES(p)) WHERE …

我有一堆想要链接的上下文管理器。乍一看，contextlib.nested看起来像是一个合适的解决方案。但是，此方法在文档中被标记为已弃用，该文档还指出最新with声明允许直接执行此操作：

2.7 版后已弃用： with 语句现在直接支持此功能（没有容易混淆的错误怪癖）。

但是我无法让 Python 3.4.3 使用上下文管理器的动态迭代：

class Foo():
    def __enter__(self):
        print('entering:', self.name)
        return self
    def __exit__(self, *_):
        pass
    def __init__(self, name):
        self.name = name

foo = Foo('foo')
bar = Foo('bar')

是否链式：

from itertools import chain
m = chain([foo], [bar])
with m:
     pass

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: __exit__
m = [foo, bar]

直接提供列表：

with m:
     pass

Traceback (most recent call last):
  File "<stdin>", line 1, in …

例如，我有这个：

var r = fs.createReadStream('file.txt');
var z = zlib.createGzip();
var w = fs.createWriteStream('file.txt.gz');
r.pipe(z).pipe(w);

我想在 r.pipe(z).pipe(w) 完成后做点什么。我试过这样的事情：

var r = A.pipe(B);
r.on('end', function () { ... });

但它不适用于管道链。我怎样才能让它工作？

是否可以按顺序使用logstash过滤器？例如，我想将消息解析为 json，然后按字符拆分新创建的字段。

输入 => 过滤器 => 过滤器 => 输出 => 弹性搜索

在我的 Spring Boot 应用程序中，我有：

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    ...
    @Override
    protected void configure(HttpSecurity httpSecurity)
        throws Exception 
    {
        httpSecurity
            .authorizeRequests()
            // various GET/POST path enable rules, none of which would enable access to default ones (see log below)
            ...
            // finally, deny everything else
            .antMatchers("/**").denyAll()
            ...
    }
}

启动时，日志显示：

2016-01-29 13:20:49.379  INFO 8044 --- [ost-startStop-1] o.s.s.web.DefaultSecurityFilterChain     : Creating filter chain: OrRequestMatcher [requestMatchers=[Ant [pattern='/css/**'], Ant [pattern='/js/**'], Ant [pattern='/images/**'], Ant [pattern='/**/favicon.ico'], Ant [pattern='/error']]], []

我可以访问，例如，localhost:8080/blah/favicon.ico即使我希望它被阻止。

我尝试遵循安全配置中的 …

我有一个工作链，但是当我添加apply_async()它时，它只执行第一个任务。

@task(name='run_a', delay=True)
def run_a(**kwargs):
    do_whatever(kwarg['var'])
    return

@task(name='run_b', delay=True)
def run_b(**kwargs):
    # ...
    return

@task(name='run_c', delay=True)
def run_c(**kwargs):
    # ...
    return

使用链命令：

ret = chain(
    run_a.s(**kwargs),
    run_b.s(**kwargs),
    run_b.s(**kwargs)
).apply_async()

• 如果没有，apply_async一切都会按预期工作（同步）。
• 'kwargs' 是一个字典。

我需要按顺序加载三个不同的 json 文件并使用 fetch （原因是我正在使用 nextjs 导出，并且我需要动态读取这些文件，所以我在需要时获取它们，即使在出口）

第一个文件包含用于创建第二个文件的 url 的数据，依此类推，因此每次获取都需要获取实际更新的状态，

ATM 我正在​​使用的解决方案，因为第二个和第三个文件分别依赖于第一个和第二个文件，是获取第一个文件并使用 setState 设置一些状态，然后在 setState 回调中获取第二个文件并设置一些其他状态，很快：

fetch(baseUrl).then(
            response => response.json()
        ).then(
            res => { 
                this.setState({
                    ...
                }, () => {
                    fetch(anotherUrl+dataFromUpdatedState).then(
                        response => response.json()
                    ).then(
                        res => { 
                            this.setState({
                                ...
                            }, () => {                                 
                                fetch(anotherUrl+dataFromUpdatedState).then(
                                    response => response.json()
                                ).then(
                                    res => {
                                        this.setState({

                                        })
                                    }
                                )
                            })
                        }
                    ).catch(
                        error => {
                            //error handling
                        }
                    )
                })
            }
        ).catch(
            error => {
                this.setState({ //an error occured, fallback to default …

我想运行按节拍安排的复杂任务。让我们假设定义了默认的 add/mul 任务。

@app.on_after_configure.connect
def setup_periodic_tasks(sender, **kwargs):
    sender.add_periodic_task(
        crontab(),
        add.s(2,3) | mul.s(2)
    )

但这会在工作线程中返回一个错误：

NotImplementedError: chain is not a real task

如何使用 celerybeat 安排一项不平凡的任务？

我有一系列谓词子句，像这样

student?.firstName?.equals("John") ?: false &&
student?.lastName?.equals("Smith") ?: false &&
student?.age?.equals(20) ?: false &&
student?.homeAddress?.equals("45 Boot Terrace") ?: false &&
student?.cellPhone?.startsWith("123456") ?: false

我发现可以切换到布尔谓词and()而不是&&，但总的来说，它并没有使代码更简洁。