小编Vin*_*vic的帖子

我正在寻找合成示例或常用技术,使用过程语言对单词而不是字符进行正则表达式样式转换.

例如,要跟踪复制,可能需要创建具有相似含义但具有不同单词选择的文档.

我希望能够简明地定义可以应用于文本流的这些可能的转换.

例如."快速名词 "改为"快速名词 ",但" 走得快 ".不会得到转化(无名词之后.
或者:"爱丽丝会唱歌曲 ",以" 歌曲将被传唱爱丽丝"

我希望这可以在语法检查器中完成,例如检测被动语态.

这种语言处理的AC#实现非常简洁,但我认为任何努力的大部分都是提出正确的规则 - 保持规则清晰易懂似乎是一个开始的地方.

这个问题最初问(错误地)是什么"|" 在Python中,当实际问题是关于Django时.这个问题得到了我希望保留的Triptych的精彩答案.

我不得不使用包含数十万个文件的目录,进行文本匹配,替换等等.如果我走标准路线,比如说

grep foo *

我收到太多文件错误消息,所以我最终做了

for i in *; do grep foo $i; done

要么

find ../path/ | xargs -I{} grep foo "{}"

但这些并不是最优的(为每个文件创建一个新的grep进程).

这看起来更像是程序可以接收的参数大小的限制,因为for循环中的*可以正常工作.但是,无论如何,处理这个问题的正确方法是什么？

PS:不要告诉我做grep -r,我知道,我正在考虑没有递归选项的工具.

假设我有一个Python类,我想添加一个额外的属性.

两者之间有什么区别吗？

import path.MyClass
MyClass.foo = bar

并使用类似的东西:

import path.MyClass
setattr(MyClass, 'foo', bar)

？

如果没有,为什么人们似乎做第二个而不是第一个？(例如http://concisionandconcinnity.blogspot.com/2008/10/chaining-monkey-patches-in-python.html)

我有以下场景.客户端代码只能访问FooHandler,而不能直接访问Foo实例.

public delegate void FooLoaded(object sender, EventArgs e);

class Foo {
    public event FooLoaded loaded;
    /* ... some code ... */
    public void Load() { load_asynchronously(); }
    public void callMeWhenLoadingIsDone() { loaded(this,EventArgs.Empty); }
}

class FooHandler {
    public event FooLoaded OneFooLoaded;

    /* ... some code ... */

    public void LoadAllFoos() { 
        foreach (Foo f in FooList) { 
            f.loaded += new FooLoaded(foo_loaded);
            f.Load(); 
        } 
    }

    void foo_loaded(object sender, EventArgs e) {
        OneFooLoaded(this, e);
    }

}

然后客户端将使用FooHandler类的OneFooLoaded事件来获取加载foos的通知.这个'事件链接'是正确的吗？还有其他选择吗？我不喜欢这个(感觉不对,我无法准确地表达原因),但如果我希望处理程序成为访问点,我似乎没有很多选择.

基本上我只想使用任意类型的给定参数进行任意操作.

参数类型基类是Var,而Operation是将为给定参数执行的操作的基类.

我有Evaluator类,它包含使用opId映射的运算符集合.Evaluator将根据evaluate()成员函数中给出的opId参数进行操作,然后evaluate()函数将搜索将接受参数类型和opId的受支持运算符.

我想问的是,有没有有效的模式或算法可以在没有dynamic_cast <>和/或循环运算符集合的情况下执行此操作.

`

class Var {
public:
    bool isValidVar();
    static Var invalidVar();
}

template<typename T> class VarT : public Var {
public:
    virtual const T getValue() const;   
}

class Operator {
public:
    virtual Var evaluate(const Var& a, const Var& b) = 0;
}

template<typename T> class AddOperator : public Operator {
public:
    virtual Var evaluate(const Var& a, const Var& b)
    {                             //dynamic_cast is slow!
        const VarT<T>* varA = dynamic_cast<const VarT<T>*>(&a);
        const …

假设我正在构建一个库,以便在C中使用quuxes.

Quuxes需要两个状态变量成功sporked:

static int quux_state;
static char* quux_address;

/* function to spork quuxes found in a file, 
   reads a line from the file each time it's called. */
void spork_quux(FILE*);

如果我将这些数据存储为全局变量,那么只有一个客户端能够一次启动quuxes,否则状态变量将被第二个调用者破坏,并可能发生灾难.

问题是在C中设计可重入库的最佳方法是什么？

我接受了以下案件,但没有令人满意的结论.

在下面的例子中,问题是如何将客户关联到每个州？

/* library handles all state data allocation */
static int* quux_state; 
static char** quux_address;

在下面的例子中,客户端能够搞乱状态,非常不受欢迎

/* let each client store state */
typedef struct { int state; char* address; } QuuxState; 
QuuxState spork_quux(FILE*);

那么,如何正确地做到这一点？

我有以下正则表达式：\n我想出了大部分部分，如下所示：

\nValidationExpression="^[\u0020\u0027\u002C\u002D\u0030-\u0039\u0041-\u005A\u005F\u0061-\u007A\u00C0-\u00FF\ xc2\xb0./]{1,256}$"\n\nu0020 : 空格\nu0027 : 撇号\nu002C : 逗号\nu002D : 连字符/减号\nu0030-\\u0039\\ : 0-9\nu0041-\\u005A : A - Z\nu005F : 下划线\nu0061-\\u007A\\ : a - z\n\nu00C0-\\u00FF\xc2\xb0./ : ??\n

需要帮助理解验证表达式的最后部分：

u00C0-\\u00FF\xc2\xb0./

任何人都知道这是什么意思？

正如你所看到的,这很糟糕.还有其他选择 我尝试在group by子句中使用列别名无济于事.

select count(callid) ,
case
        when callDuration > 0 and callDuration < 30 then 1
        when callDuration >= 30 and callDuration < 60 then 2
        when callDuration >= 60 and callDuration < 120 then 3
        when callDuration >= 120 and callDuration < 180 then 4
        when callDuration >= 180 and callDuration < 240 then 5
        when callDuration >= 240 and callDuration < 300 then 6
        when callDuration >= 300 and callDuration < 360 then 7
        when callDuration >= …

我目前的做法是这样的

DateTime startHour = new DateTime(1900,1,1,12,25,43);
DateTime endHour = new DateTime(1900,1,1,13,45,32);

// I need to, say, know if a complete DateTime instance 
// is later than startHour plus 15 minutes

DateTime now = DateTime.Now();

startHour = startHour.addMinutes(15);

if (now.CompareTo(new DateTime(now.Year, now.Month, now.Day, startHour.Hour, 
                    startHour.Minute, startHour.Second)) > 0) 
{
    //I can do something now
}

这非常麻烦甚至容易出错.就我所见,TimeSpans不是解决方案,因为它们代表跨度并且不受24小时限制的约束(TimeSpan为56小时34分钟有效.)

这种计算的首选方法是什么？

我错过了什么？

编辑:我正在进行的计算是比较完整的DateTime实例与表示实际时间的小时,分​​钟,秒三元组以及操作这些三元组的方法(添加小时,分钟秒)的方法.

编辑2:谢谢大家,我认为我现在掌握了DateTime API的要点.:)我唯一想念的是一种指定TimeSpan的方法,该TimeSpan应仅代表TimeOfDay,但这是次要的.