标签: logic

我想用Mustache实现以下逻辑:

{{#if users.length > 0}}
    <ul>
        {{#users}}
            <li>{{.}}</li>
        {{/users}}
    </ul>
{{/if}}

// eg. data = { users: ['Tom', 'Jerry'] }

我应该修改users结构以满足需要吗？例如:

{{#hasUsers}}
    <ul>
        {{#users}}
            <li>{{.}}</li>
        {{/users}}
    </ul>
{{/hasUsers}}

// eg. data = { hasUsers: true, users: ['Tom', 'Jerry'] }

我很难理解算法中问题的根本原因.然后,通过逐步简化函数,我发现在Python中对默认参数的评估并不像我预期的那样.

代码如下:

class Node(object):
    def __init__(self, children = []):
        self.children = children

问题是children如果没有明确给出属性,Node类的每个实例都共享相同的属性,例如:

>>> n0 = Node()
>>> n1 = Node()
>>> id(n1.children)
Out[0]: 25000176
>>> id(n0.children)
Out[0]: 25000176

我不明白这个设计决定的逻辑？为什么Python设计者决定在定义时评估默认参数？这对我来说似乎非常违反直觉.

如果满足两个期望中的一个,我需要设置测试成功:

expect(mySpy.mostRecentCall.args[0]).toEqual(jasmine.any(Number));
expect(mySpy.mostRecentCall.args[0]).toEqual(false);

我希望它看起来像这样:

expect(mySpy.mostRecentCall.args[0]).toEqual(jasmine.any(Number)).or.toEqual(false);

我在文档中遗漏了什么,或者我是否必须编写自己的匹配器？

进行三向异或的最简单方法是什么？

换句话说,我有三个值,我想结果为true IFF只声明一个三个值是真实的.

到目前为止,这是我提出的:

((a ^ b)&&(a ^ c)&&!(b && c))|| ((b ^ a)&&(b ^ c)&&!(a && c))|| ((c ^ a)&&(c ^ b)&&!(a && b))

是否有更简单的事情做同样的事情？

以下是上述完成任务的证明:

a = true; b = true; c = true
((a ^ b) && (a ^ c) && !(b && c)) || ((b ^ a) && (b ^ c) && !(a && c)) || ((c ^ a) && (c ^ b) && !(a && b))
=> false

a = true; b = …

我是jQuery的新手,我写了一个简单的函数来检查每个按键的密码强度.

这个想法是每次用户输入一个角色时,评估内容以测试他们输入的密码的强度......我相信每个人之前都看过这些.

无论如何,我使用的逻辑是没有密码以值1开头.当使用小写字符时,分数增加到2.当使用数字时,分数再次增加1,对于大写时相同使用字符,密码长度为5个或更多字符时使用.

返回的是密码的强度,每次按下一个键时,从1到5的值.

所以,关于我的问题.我这样做的方式似乎并不像jQuery那样...几乎就像我可能刚刚完成了直接的javascript.我也想知道我的逻辑.我做过什么或忽略了什么吗？聪明人比我自己的任何建议？

任何建议或意见将不胜感激.

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

我的同事向我展示了这段代码,我们都想知道为什么我们似乎无法删除重复的代码.

private List<Foo> parseResponse(Response<ByteString> response) {
    if (response.status().code() != Status.OK.code() || !response.payload().isPresent()) {
      if (response.status().code() != Status.NOT_FOUND.code() || !response.payload().isPresent()) {
        LOG.error("Cannot fetch recently played, got status code {}", response.status());
      }
      return Lists.newArrayList();
    }
    // ...
    // ...
    // ...
    doSomeLogic();
    // ...
    // ...
    // ...
    return someOtherList;
}

这是一个替代表示,使它不那么罗嗦:

private void f() {
    if (S != 200 || !P) {
        if (S != 404 || !P) {
            Log();
        }
        return;
    }
    // ...
    // ...
    // ...
    doSomeLogic();
    // …

我想创建一些嵌套条件：当它是合并或合并请求并且以特定名称启动“功能”时，我需要此管道才能工作。那么，作业的“唯一”选项中是否有 AND 条件？

假设您正在尝试阅读此属性

var town = Staff.HomeAddress.Postcode.Town;

沿链的某处可能存在null.阅读城镇的最佳方式是什么？

我一直在试验几种扩展方法......

public static T2 IfNotNull<T1, T2>(this T1 t, Func<T1, T2> fn) where T1 : class
{
    return t != null ? fn(t) : default(T2);
}

var town = staff.HomeAddress.IfNotNull(x => x.Postcode.IfNotNull(y=> y.Town));

要么

public static T2 TryGet<T1, T2>(this T1 t, Func<T1, T2> fn) where T1 : class
{
if (t != null)
{
    try
    {
        return fn(t);
    }
    catch{ }
}
return default(T2);
}

var town = staff.TryGet(x=> x.HomeAddress.Postcode.Town);

显然,这些只是抽象出逻辑并使代码(一点点)更具可读性.

但是有更好/更有效的方式吗？

编辑:

在我的特定情况下,对象是从WCF服务返回的,我无法控制这些对象的体系结构.

编辑2: …

我正在参加Scala编程课程.有一次教练说:

函数blah和bladdy是一阶逻辑的通用和存在量词.

有人可以将" 一阶逻辑的普遍存在量词 "翻译成英语吗？

我想将float值的符号作为int-1或1 的值.

避免条件总是降低计算成本的好主意.例如,我能想到的一种方法是使用快速bit-shift获取标志:

float a = ...;
int sign = a >> 31; //0 for pos, 1 for neg
sign = ~sign; //1 for pos, 0 for neg
sign = sign << 1; //2 for pos, 0 for neg
sign -= 1; //-1 for pos, 1 for neg -- perfect.

或者更简洁:

int sign = (~(a >> 31) << 1) - 1;

1. 这看起来像是一个好方法吗？
2. 鉴于字节顺序问题(MSB持有标志),这是否适用于所有平台？