在某个特定场景中，比如m={“a”:1,"b":{"c":2,"d":[3,4]}},须将他的层级展开，结果：

m={"a":1,"b.c":2,"b.d":[3,4]}

我的代码：

        var m = {
            "a": 1,
            "b": {
                "c": 2,
                "d": [3, 4],
                "e": {
                    "f":5
                }
            }
        }
        function fn(obj) {
            if (Object.prototype.toString.call(obj) === '[object Object]') {//obj:{}
            var newObj = {};
                for (var k in obj) {
                    if(Object.prototype.toString.call(obj[k]) === '[object Object]'){
                        for(var j in obj[k]){
                            if(Object.prototype.toString.call(obj[k][j]) === '[object Object]'){
                                newObj[k+'.'+j] = fn(obj[k][j])
                            }else{
                                newObj[k+'.'+j] = obj[k][j]
                            }
                        }
                    }else{
                        newObj[k] = obj[k]
                    }
                }
            } else {
                return obj
            }
            return newObj
        }
        console.log(fn(m))

我这么写对a到d，得到的是正确结果，但是再来一层a.e.f = 5 就解析不出来了。求解，还求写这种递归的需求时，我怎么知道在什么时间点去调用自己，循环到什么程度以后再去调用自己 ？