Javascript 当输入参数为null时，如何编写函数返回的jasmine期望？

我有以下javascript函数：

function(fieldObject, value) {

    if (!value) {
      return;
    }

    // call some other functions
}

---

是否可以编写一个期望，即函数在if语句中返回，而不编写多个期望，即if语句之后的所有其他函数都不会被调用？

这是一个非常有趣的问题： 我不是100%确定是否有一种方法可以实现您所寻求的目标，但是我使用了这个技巧来验证提前返回的状态（就像您的情况一样）

这是我如何使用它的-

• 使您的

  void

  方法

  返回false

  退出处理。你可以 不要在代码中使用这个返回值，但您可以确定测试它 效率高
• 如果您的方法预期返回一个值，但它有一个早期的返回/中断，您仍然可以使用

  returnfalse

  来中断它

用于说明上述场景的代码示例：

var testObj = {
    voidLikeFunction : function(arg1){
        if(!arg1){
            return false;
        } else {
            console.log('Executes void like function..');
            this.callAFunction();
            this.callAnotherFunction();
            this.callYetAnotherFunction();
        }
    },

    callAFunction : function(){
        console.log('callAFunction()');
    },

    callAnotherFunction : function(){
        console.log('callAnotherFunction()');
    },

    callYetAnotherFunction : function(){
        console.log('callYetAnotherFunction()');
    },

    expectedToReturnInt : function(arg1){
        if(!arg1){
            return false
        } else {
            var sum =0;
            for(int i=0; i<10; i++){
                sum += i;
            }
            return sum;
        }
    }
};

describe('testVoidLikeFunc', function(){
    it('testEarlyReturn', function(){
        var val = testObj.voidLikeFunction();
        expect(val).toBe(false);
    });
    it('testLateReturn', function(){
        spyOn(testObj, 'callAFunction').and.callThrough();
        spyOn(testObj, 'callAnotherFunction').and.callThrough();
        spyOn(testObj, 'callYetAnotherFunction').and.callThrough();
        var dummyParam = true;
        testObj.voidLikeFunction(dummyParam);
        expect(testObj.callAFunction).toHaveBeenCalled();
        expect(testObj.callAnotherFunction).toHaveBeenCalled();
        expect(testObj.callYetAnotherFunction).toHaveBeenCalled();
    });
});

describe('testExpectedToReturnInt', function(){
    it('testEarlyReturn', function(){
        var val = testObj.expectedToReturnInt();
        expect(val).toBe(false);
    });
    it('testLateReturn', function(){
        var dummyParam = true;        
        var val = testObj.expectedToReturnInt(dummyParam);
        expect(val).toEqual(45);
    });
});

var testObj={
voidLikeFunction:函数（arg1）{
如果（！arg1）{
返回false；
}否则{
log（'执行类似void的函数..'）；
this.callAFunction（）；
this.callAnotherFunction（）；
this.callYetAnotherFunction（）；
}
},
callAFunction:function（）{
log（'callAFunction（）'）；
},
callAnotherFunction:function（）{
log（'callAnotherFunction（）'）；
},
callYetAnotherFunction:function（）{
log（'callYetAnotherFunction（）'）；
},
expectedToReturnInt:函数（arg1）{
如果（！arg1）{
返回错误
}否则{
var总和=0；
对于（inti=0；这听起来很像一个。通过这样做，您试图解决的问题是什么？