我有一个IEnumerable<T>.我想为集合中的每个项目做一件事,除了最后一项,我想做其他事情.我怎么能整齐地编码呢？在伪代码中

foreach (var item in collection)
{
    if ( final )
    {
        g(item)
    }
    else
    {
        f(item)
    }
}

所以,如果我的IEnumerable是Enumerable.Range(1,4)我做f(1)f(2)f(3)g(4).NB.如果我的IEnumerable恰好是长度1,我想要g(1).

我的IEnumerable碰巧有点蹩脚,制作Count()和循环整个事情一样昂贵.

铁锈中的惯用语for/else：

在 Python 中，我可以使用for/else检查循环是否for在语句处终止break或“正常”完成：

prod = 1
for i in range(1, 10):
    prod *= i
    if prod > 123:
        break
else:
    print("oops! loop terminated without break.")

Rust 有类似的方法吗？这是我最接近的，但并不是特别相似。

let mut prod = 1u64;
let mut found = false;
for i in 1..10 {
    prod *= i;
    if prod > 123 {
        found = true;
        break;
    }
}
if !found {
    println!("oops! loop terminated without break.");
}

似乎有关于Rust Internals的讨论；然而，这更多的是关于未来的可能性，而不是惯用的。 …

我听说使用控制流异常是不好的做法.你觉得这怎么样？

public static findStringMatch(g0, g1) {

    int g0Left = -1;
    int g0Right = -1;
    int g1Left = -1;
    int g1Right = -1;

//if a match is found, set the above ints to the proper indices
//...
//if not, the ints remain -1

        try {
            String gL0 = g0.substring(0, g0Left);
            String gL1 = g1.substring(0, g1Left);

            String g0match = g0.substring(g0Left, g0Right);
            String g1match = g1.substring(g1Left, g1Right);

            String gR0 = g0.substring(g0Right);
            String gR1 = g1.substring(g1Right);

            return new StringMatch(gL0, gR0, g0match, g1match, gL1, gR1); …

insertion_procedure (int a[], int p [], int N)
{
    int i,j,k;
    for (i=0; i<=N; i++) p[i] = i;
    for (i=2; i<=N; i++)
    {
        k = p[i];
        j = 1;
        while (a[p[j-1]] > a[k]) {p[j] = p[j-1]; j--}
        p[j] = k;
    }
}

我必须找到这个代码的圈复杂度,然后建议一些白盒测试用例和黑盒测试用例.但我无法为代码制作CFG.

非常感谢对测试用例的一些帮助.

在以下C++代码中:

typedef enum { a, b, c } Test;

int foo(Test test) {
    switch (test) {
        case a: return 0;
        case b: return 1;
        case c: return 0;
    }
}

编译时发出警告-Wall,表示控件到达非void函数的结尾.为什么？

编辑

一般说来test示例中的变量可以包含任何值都是正确的.

foo(12354) 不编译:

> test.cpp:15:14: error: invalid conversion from ‘int’ to ‘Test’
> test.cpp:15:14: error:   initializing argument 1 of ‘int foo(Test)’

因为12354是不是一个有效的Test值(虽然它确实会是明文有效Ç,但它不是在C++中).

你肯定可以显式地将任意整数常量强制转换为枚举类型,但是不是认为是未定义的行为吗？

我被分配了一个项目来开发一组作为存储系统接口的类.要求是该类支持具有以下签名的get方法:

public CustomObject get(String key, Date ifModifiedSince)

基本上该方法应该返回CustomObject与keyif 关联的,并且只有在对象被修改之后才会返回ifModifiedSince.如果存储系统不包含,key则该方法应返回null.

我的问题是:

如何处理其中关键的存在,但该对象的情景已经不被修改？

这很重要,因为使用此类的一些应用程序将是Web服务和Web应用程序.这些应用程序需要知道是返回404(未找到),304(未修改)还是200(OK,这是数据).

我正在权衡的解决方案是:

1. 当存储系统不包含时,抛出自定义异常 key
2. ifModifiedSince失败时抛出自定义异常 .
3. 将状态属性添加到CustomObject.要求来电者查看房产.

我对这三个选项中的任何一个都不满意.我不喜欢选项1和2,因为我不喜欢使用流控制的异常.当我的目的是表明没有价值时,我也不喜欢返回值.

尽管如此,我倾向于选择3.

有没有我不考虑的选择？有没有人对这三种选择中的任何一种都有强烈的感受？

这个问题的答案,转述:

1. 提供一个contains 方法并要求调用者在调用之前调用它get(key, ifModifiedSince),如果key不存在则抛出异常,如果没有修改object则返回null.
2. 将响应和数据(如果有)包装在复合对象中.
3. 使用预定义常量表示某个state(UNMODIFIED, KEY_DOES_NOT_EXIST).
4. 调用者实现了用作回调的接口.
5. 设计很糟糕.

为什么我不能选择答案#1

我同意这是理想的解决方案,但我已经(不情愿地)被解雇了.这种方法的问题在于,在大多数使用这些类的情况下,后端存储系统将是第三方远程系统,如Amazon S3.这意味着一种contains方法需要往返于存储系统,这在大多数情况下会进行另一次往返.因为这会花费时间和金钱,所以不是一种选择.

如果没有这个限制,这将是最好的方法.

(我意识到我没有在这个问题中提到这个重要元素,但我试图保持简短.显然它是相关的.)

结论:

在阅读完所有答案之后,我得出的结论是,在这种情况下,包装器是最好的方法.基本上我会模仿HTTP,包括响应代码和内容正文(消息)的元数据(标题).

我的node.js脚本从数据库1中的表中读取行,进行一些处理并将行写入数据库2.

一切都完成后,脚本应该退出.

我怎么知道是否所有事情都已完成并退出节点呢？

如果我有这样的回调函数:

function exit_node() {
  process.exit();
}

(编辑:同时很明显,process.exit()也可以用db.close()替换 - 但这不是要放在那里的问题.问题是在哪个时候准确地做到这一点,即如何以及在何处执行此回调.)

但要在某个地方附上它并不容易.从db1最后一次读取后不正确,因为处理和写入仍然必须发生.

将它附加到对db2的写入并不容易,因为它必须在最后一次写入后附加,但每次写入都是独立的,并且不知道它是否是最后一次写入.

它理论上也可能发生,最后一次写入完成,但在此之前的另一次写入仍在执行.

编辑:对不起,我可以看到问题的解释不完整,可能令人困惑,但有些人仍然理解,下面有很好的答案.请继续阅读评论和答案,它应该给你全面的了解.

编辑:我可以想到一些"阻塞"控制器机制.脚本的不同部分为每个打开的"作业"向控制器添加阻止程序,并在作业完成后释放它们,并且当不再存在bocker时控制器退出脚本.也许async可以提供帮助:https://github.com/caolan/async

我也担心这会破坏代码和逻辑不合理.

对于我的论文,我需要绘制一些概率控制流程图.即控制流程图,边缘上描绘的概率.

我发现图形工具看起来非常有用,因为它可以使用现有图形的深层复制,我的图形非常相似.

所以我的问题是,如果有可能在边缘上/旁边绘制边缘属性(或一些字符串)？如果它不可能或非常复杂,那么在这种情况下是否有更好的工具？

编辑: 我需要有向边,甚至可以在2个节点之间创建循环并具有不同的值.这也有可能吗？所以我可以看到两个值？到现在为止,我可以看到带有双向边的有向图,但它只有一个值.

因此,例如在networkx中(参考Hooked),它看起来像:

G = nx.MultiDiGraph()
G.add_edge(0,1)
G.add_edge(1,0)
labels = {(0,1):'foo', (1,0):'bar'}

这样'foo'和'bar'都可见,你可以看到它们连接的方向.

但是当networkx呈现它时,我得到1个带有1个标签的双向边缘.

我希望能够从许多异步协同程序中获益.Asyncio as_completed有点接近我正在寻找的东西(即我希望任何协同程序能够随时返回到调用者然后继续),但这似乎只允许常规协同程序返回一次.

这是我到目前为止所拥有的:

import asyncio


async def test(id_):
    print(f'{id_} sleeping')
    await asyncio.sleep(id_)
    return id_


async def test_gen(id_):
    count = 0
    while True:
        print(f'{id_} sleeping')
        await asyncio.sleep(id_)
        yield id_
        count += 1
        if count > 5:
            return


async def main():
    runs = [test(i) for i in range(3)]

    for i in asyncio.as_completed(runs):
        i = await i
        print(f'{i} yielded')


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())
    loop.close()

替换runs = [test(i) for i in range(3)]为runs = [test_gen(i) for i …

Forth着名的允许用户通过为控制流定义新单词来改变语言(超出标准给出的单词:DO,LOOP,BEGIN,UNTIL,WHILE,REPEAT,LEAVE IF,THEN,ELSE,CASE,ENDCASE等)

是否有人们实际创建自己的新控制流程词的常见例子？有哪些典型和有用的例子？或者标准已经定义了人们实际需要的一切？

我希望找到一些有用的语言扩展示例,这些示例已经被接受或证明通常有助于使语言更具表现力.