小编afs*_*tos的帖子

我遇到过以下代码:

function test(data) {
    if (data != null && data !== undefined) {
        // some code here
    }
}

我对JavaScript很新,但是,从我在这里读过的其他问题来看,我的印象是这段代码没有多大意义.

如果在除了以外的任何上下文中访问未定义的变量,您将收到错误typeof.

更新:上述答案(引用)可能会产生误导.应该说"一个未声明的变量",而不是"一个未定义的变量".

正如我在Ryan♦,maerics和nwellnhof的回答中所发现的那样,即使没有为函数提供参数,也始终声明其参数的变量.这个事实也证明了下面列表中的第一项是错误的.

根据我的理解,可能会遇到以下情况:

• 调用该函数时没有参数,从而生成data一个未定义的变量,并引发错误data != null.

• 该函数专门用null(或undefined)作为其参数调用,在这种情况下data != null已经保护内部代码,使得&& data !== undefined无用.

• 该函数使用非null参数调用,在这种情况下,它将平凡地传递两个data != null 和 data !== undefined.

问:我的理解是否正确？

我在Firefox的控制台中尝试了以下内容:

--
[15:31:31.057] false != null
[15:31:31.061] true
-- …

上下文(编辑)

有些澄清是需要的,所以我会试着总结影响这个问题的因素.

• 该项目的目标是为程序员提供某种功能,最有可能是以库的形式(我猜是一个带有类文件的JAR).

• 要使用所述功能,程序员必须遵守必须(应该)满足的约束.否则它将无法按预期运行(就像锁定java.util.concurrent,必须在适当的时间和地点获取/释放).

• 此代码不是使用它的应用程序的入口点(即没有main).

• API中公开的操作数量有限(且很小).

例子:

1. 想想一个小游戏,几乎所有东西都是由已经实现的类实现和管理的.程序员唯一要做的就是编写一个方法或其中几个描述角色将要做什么的方法(走路,改变方向,停止,检查对象).我想确保他们的方法(可能标有注释？)只是walk,或者changeDirection,或者计算diff = desiredValue - x,而不是说,写入某个文件,或者打开套接字连接.

2. 想想交易经理.该库将提供管理器,以及事务的一些常量属性(它们的隔离级别,超时,......).现在,程序员想要进行交易并使用这个经理.我想确保他们只read,write,commit,或rollback在一些资源,已知的经理.launchRocket如果经理不控制任何火箭发射,我不希望他们在交易过程中.

问题

我想在方法(或方法组)的主体上施加一些不变量/限制/约束,稍后由其他程序员在其他一些包/位置中实现.说,我给他们的东西:

public abstract class ToBeExtended {
    // some private stuff they should not modify
    // ...
    public abstract SomeReturnType safeMethod();
}

为了本项目的目的,方法体满足一些不变量是很重要的(可能是必要的).或者更确切地说,此方法实现使用的命令集是有限的.这些约束的例子:

• 此方法不得执行任何I/O.
• 此方法不得实例化任何未知(潜在危险)对象.
• ...

换一种方式:

• 此方法可以调用已知(特定)类的方法.
• 此方法可以执行一些基本指令(数学,分配局部变量,ifs,循环......).

我一直在浏览Annotations,似乎没有任何接近这一点.
我到目前为止的选择:

1. 定义一些注释,@SafeAnnotation并将其应用于方法,与实施者定义合同,他将遵循规定的规则,否则系统将发生故障.

2. Enum使用允许的操作定义a .而不是暴露允许的方法,只暴露一个方法,接受这些枚举对象的列表(或类似于 …

我有一个接口,Resource它应该包装一些东西并在包装对象上公开一些操作.
我的第一个方法是编写以下内容,并考虑策略模式.

interface Resource<T> {
    ResourceState read();
    void write(ResourceState);
}

abstract class AbstractResource<T> implements Resource<T> {
    // This is where the Strategy comes in.
    protected AbstractResource(ResourceStrategy<T> strat) {
        // ...
    }

    // Both the read and write implementations delegate to the strategy.
}

class ExclusiveResource<T> extends AbstractResource<T> { ... }
class ShareableResource<T> extends AbstractResource<T> { ... }

上面的两个实现在使用的锁定方案(常规锁或读写锁)方面有所不同.

还有ResourceManager一个负责管理这些事情的实体.我对客户端使用的想法是:

ResourceManager rm = ...
MyCustomObject o = ...
MyCustomReadWriteStrategy strat = ...
rm.newResourceFor(o, …

从Socket文档：

关机输入

public void shutdownInput()
                   throws IOException

Run Code Online (Sandbox Code Playgroud)

将此套接字的输入流放置在“流末尾”。任何发送到套接字输入流端的数据都会被确认，然后被静默丢弃。

如果在套接字上调用 shutdownInput() 之后从套接字输入流中读取，则该流将返回 EOF。

为了测试服务器中客户端之间的交互，我编写了一些客户端机器人。这些机器人会生成一些随机的客户端请求。由于这些只写入服务器，它们不需要输入流，它们不需要读取服务器发送的更新。这是机器人的主体代码：

private void runWriteBot(PrintWriter out) throws IOException {
    //socket.shutdownInput();
    String request;
    System.out.println("Write bot ready.");
    while (!quit) {
        request = randomRequest();
        out.println(request);
        sleep();
    }
}

如果我取消注释shutdownInput，则会在服务器的客户端处理程序中引发异常：

连接重置

我没想到会在套接字的另一侧抛出异常。该文档表明（至少对我而言）另一方发送的任何内容都将被默默丢弃，不会干扰另一端的活动，即不会让另一方抛出异常。

1. 我可以忽略服务器发送的内容，还是应该清除输入流中的内容？

2. 有没有什么自动的方法可以做到这一点，还是我需要定期阅读和忽略？

调试J2EE应用程序时,在Eclipse中,我确实看到了数百个Threads.但是,我对单个线程感兴趣,其中我的断点命中.每次来回寻找它都是一种痛苦.

如何过滤掉未悬浮的线程？

我想制作一个动画,RecyclerView其中要求孩子拥有比另一个孩子更大的z指数.但是,当我使用它的bringToFront方法时,ViewGroup它不起作用.

有没有办法把孩子带到前面RecyclerView？

我对Java的发生和同步有一些分歧.

想象一下以下场景:

主线程

MyObject o = new MyObject();    // (0)
synchronized (sharedMonitor) {
    // (1) add the object to a shared collection
}
// (2) spawn other threads

其他主题

MyObject o;
synchronized (sharedMonitor) {
    // (3) retrieve the previously added object
}
// (4) actions to modify the object

请注意,实例变量MyObject既不是volatile,也不是final.MyObject不使用同步的方法.

我的理解是:

• 1 发生在 3 之前,因为在同一个监视器上有同步,而其他线程仅在2处生成,这在1之后执行.

• 4上的操作无法保证以后对主线程可见,除非所有线程都进一步同步,并且主线程在这些操作之后以某种方式同步.

问:是否可以保证0处的操作可见,之前发生,3上的并发访问,或者我必须将变量声明为volatile？ …

假设我在合金4.2中有以下签名声明:

sig Target {}

abstract sig A {
    parent: lone A,
    r: some Target
}

sig B extends A {}
sig C extends A {}

在运行时,生成的实例将具有从每个B到一些Target,从C一些到一些的箭头Target.

我怎么能只隐藏箭头B？
我首先尝试了以下内容:

abstract sig A {
    parent: lone A
}

sig B extends A {
    r: some Target
}

sig C extends A {
    r: some Target
}

这会给我掌控r中B,但是写性能时,它引入了一个很大的模糊性.我想尽量保持这些简单.例如:

all a: A | a.r = parent.a.r

以上说a的Targets …

我写了一些代码并遇到了incompatible types编译错误.这就是我所拥有的:

public interface Expression<T> {
    int getArity();
    T evaluate();
}

public abstract class Value<T> implements Expression<T> {
    @Override
    public final int getArity() { return 0; }
}

public final class Constant<T> extends Value<T> {
    private final T value;

    /** Parameter constructor of objects of class Constant. */
    public Constant(T val) {
        value = val;
    }

    /** Copy constructor of objects of class Constant. */
    private Constant(Constant instance) {
        value = instance.evaluate();    // Error here.
    }

    @Override
    public …

我有一个JList<MyObj>,为此我创建了一个自定义ListCellRenderer<MyObj>.此列表包含在a中JScrollPane.

为了避免在运行时调整框架的大小,我希望滚动窗格始终具有适当的大小来显示VISIBLE_ITEMS我的元素,无论列表是空的还是填充的.以下是列表的设置代码.

model   = new DefaultListModel<>();
list    = new JList<>(model);

list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
list.setLayoutOrientation(JList.VERTICAL);
list.setVisibleRowCount(VISIBLE_ITEMS);
list.setCellRenderer(new MyItem());
    /* ... */
JScrollPane scroll = new JScrollPane(list);
panel.add(scroll, BorderLayout.CENTER);

MyItem 定义如下.

/**
 * A component that displays a single item.
 */
private static final class MyItem extends JPanel
        implements ListCellRenderer<MyObj> {
    // ...

    private final JLabel label;
    private final JTextArea text;

    MyItem() {
        super(new BorderLayout());
        label   = new JLabel(PLACEHOLDER);
        text    = new …

我正在尝试一些基本的C代码,用于定义int带指针的矩阵.

typedef int **Matrix;

Matrix createMatrix(int lines, int columns) {
    int i, j;
    Matrix m = (Matrix) malloc(sizeof(int) * lines * columns);
    for (i = 0; i < lines; ++i) {
        for (j = 0; j < columns; ++j) {
            m[i][j] = 0;
        }
    }
    return m;
}

int main(int argc, char**argv) {
    Matrix m = createMatrix(5, 10);
    // ...
    if (m[2][3] == 20) {
        // ...
    }
    return 0;
}

但是,这些m[i][j]访问会导致分段错误.这有什么不对？太多的星号？

我确信指向int的指针实际上与矩阵相同.

您好,我对构建模式有几个问题？

1. 为什么主类中的实例变量是私有的？
2. 为什么内部类声明为静态？
3. 为什么内部类中的实例变量是私有的并且重复？
4. 我们在方法中返回Builder对象究竟包含在这个对象中的什么内容？
5. 为什么主构造函数是私有的？

public class Plank {
    //1. Why are these instance variables private?
    private double widthInches;
    private double heightInches;
    private double thicknessInches;

    //2. Why is this class static?
    public static class Builder {
        //Why are these instance variables private and repeated?
        private double widthInches;
        private double heightInches;
        private double thicknessInches;

        public Builder widthInches(double inches) {

            widthInches = inches;
            //3. What is returned here what object is this referencing?
            return this;

        }
        public Builder heightInches(double inches) { …