根据包名，在指定空间中创建对象

function namespace(oNamespace, sPackage) {
    let arr=sPackage.split('.');
    let father=oNamespace;
    for(let i in arr){
        if(!father[arr[i]]||typeof father[arr[i]]!=='object')father[arr[i]]={};
        father=father[arr[i]];
    }
    return oNamespace;
}

function namespace(oNamespace, sPackage) {
    var package = sPackage.split('.');
    var obj = oNamespace;

    for (var i = 0; i < package.length; ++i) {
        if (typeof obj[package[i]] !== 'object') {
            obj[package[i]] = {};
        }

        obj = obj[package[i]];
    }

    return oNamespace;
}

function namespace(oNamespace, sPackage) {
    var arr = sPackage.split('.');//拆分数组
    var _point = oNamespace;//建立对象引用
    
    while(arr.length > 0){//遍历
        if(Object.prototype.toString.call(_point[arr[0]]) !== '[object Object]'){
            _point[arr[0]] = {};//不是对象就覆盖
        }
        _point = _point[arr[0]]; //重新定位引用
        arr.shift();
    }
    return oNamespace;
}

function namespace(oNamespace, sPackage) {  var temp = oNamespace;
 sPackage.split('.').forEach(function(key) {
   // console.log(temp[key])
   if (temp && temp[key] && typeof temp[key] === 'object') {
    temp[key] = temp[key];
   } else {
    temp[key] = {};
   }
   temp = temp[key];
 });
 return oNamespace; 
}

function namespace(oNamespace, sPackage) {
    let obj = oNamespace;
    let arr = sPackage.split('.');
    let len = arr.length;
    for(let i=0; i<len; i++) {
        if(arr[i] in obj) continue;
        obj[arr[i]] = {};
        obj = obj[arr[i]];
    }
    return oNamespace;
}

function namespace(oNamespace, sPackage) {
    var keys = sPackage.split('.');
    var tempSpace = oNamespace;
    keys.forEach(function(key) {
        if (!(tempSpace[key] instanceof Object)) {
            tempSpace[key] = {};
        }
        tempSpace = tempSpace[key];
    });
    return oNamespace;
}

function namespace(oNamespace, sPackage) {
    var p = sPackage.split('.')
    console.log('p is:', p)
    var cp = oNamespace
    for (var i = 0; i < p.length; i++) {
        if (oNamespace[p[i]] === undefined) {
            oNamespace[p[i]] = {}
        }
        oNamespace = oNamespace[p[i]]
    }
    console.log(cp)
}

	function namespace(oNamespace, sPackage) {



	var obj=oNamespace;



	sPackage.replace(/([^\.])(\.|)/g,function(t,m){



	//如果obj[m]是对象的话，返回自身，不是则返回空对象



	//将obj[m]赋给obj，下一次的obj就可以指向本次的obj[m]了



	obj=obj[m]=obj[m] instanceof Object?obj[m]:{}



	})



	return oNamespace;



	}

//递归
function namespace(oNamespace, sPackage) {
    var firstPointIndex = sPackage.indexOf('.');
    if(firstPointIndex === -1)
        return oNamespace[sPackage] = {};
    var firstPath = sPackage.slice(0,firstPointIndex);
    if(typeof oNamespace[firstPath] !== 'object')
        oNamespace[firstPath] = {};
    namespace(oNamespace[firstPath], sPackage.slice(firstPointIndex + 1));
    return oNamespace;
}

function namespace(oNamespace, sPackage) {
    var arr = sPackage.split('.');
    var res = oNamespace;	// 保留对原始对象的引用

    for(var i = 0, len = arr.length; i < len; i++) {
    	if(arr[i] in oNamespace) {	// 空间名在对象中
    		if(typeof oNamespace[arr[i]] !== "object") {	// 为原始值	
    			oNamespace[arr[i]] = {};    // 将此属性设为空对象			
    		}	
    	} else {	// 空间名不在对象中，建立此空间名属性，赋值为空
    		oNamespace[arr[i]] = {};
    	}
        
    	oNamespace = oNamespace[arr[i]];	// 将指针指向下一个空间名属性。
    }

    return res;

}

function namespace(oNamespace, sPackage) {
   if(sPackage.length <= 0) return;
    // var arr = sPackage.split('.');
    var pointer = oNamespace;


    	if(sPackage[0] in oNamespace) {
    		if(typeof oNamespace[sPackage[0]] !== "object") {
    			oNamespace[sPackage[0]] = {};    			
    		}	
    	} else {
    		oNamespace[sPackage[0]] = {};
    	}

    	oNamespace = oNamespace[sPackage[0]];

    	namespace(oNamespace, sPackage.slice(2));

    	
    return pointer;

}

if (!ns[scope[i]] ...) {...}

if (!(scope[i] in ns) ...) {...}

if (typeof ns[scope[i]] != 'object' ...) {...}

if (!(ns[scope[i]] instanceof Object) ...) {...}

function isPlainObject(value) {
    return Object.prototype.toString.call(value).slice(8, -1) == 'Object';
}

function namespace(oNamespace, sPackage) {
    var scope = sPackage.split('.');
    var ns = oNamespace;
    for (var i = 0; i < scope.length; ++i) {
        if (!ns.hasOwnProperty(scope[i]) || !isPlainObject(ns[scope[i]])) {
            ns[scope[i]] = {};
        }
        ns = ns[scope[i]];
    }
    return oNamespace;
}

function namespace(oNamespace, sPackage) {
    var packNameArr=sPackage.split(".");
    var curObj=oNamespace;
    for(var i=0;i<packNameArr.length;i++){
        if(!curObj.hasOwnProperty(packNameArr[i])){
            curObj[packNameArr[i]]={};
            curObj=curObj[packNameArr[i]];
        }
    }
    return oNamespace;
}

function namespace(oNamespace, sPackage) {
  let arr = sPackage.split('.')
  let pointer = oNamespace
  for (let i = 0; i < arr.length; i++) {
    // 如果为undefined或者不是对象则赋值为空对象
    if (!pointer[arr[i]] || typeof pointer[arr[i]] !== 'object') {
      pointer[arr[i]] = {}
    }
    pointer = pointer[arr[i]]
  }
  return oNamespace
}