用多个正则表达式模式拆分字符串会返回不需要的值

我猜最后你想构建的就是这个。

我稍微扩展了Regex来解析像["lorem ipsum"]

	//parses the path into an Array of keys
	var parsePath = (function(){
		var fetchParts = /'['s*('d+|"(?:''['s'S]|[^''"])+")'s*']|(?:'.|^)([A-Za-z_$][A-Za-z_$0-9]*)/g;
		var isValid = new RegExp("^(?:" + fetchParts.source.replace(/'((?:'?':)?/g, "(?:") + ")+$", "")
		
		return function(str){
			var s = str == null? "": String(str).trim();
			if(!isValid.test(s))
				throw new Error("invalid path: "+JSON.stringify(str));
			for(var m, keys = []; m = fetchParts.exec(s);)
				keys.push(m[1]? JSON.parse(m[1]): m[2]);
			return keys;
		}
	})();
	//takes a path or an Array of keys and returns a function that resolves the path from the passed object.
	//returns undefined if path can't be resolved;
	
	//v1
	var resolvePath = function(path){
		var keys = Array.isArray(path)? path: parsePath(path);
		return keys.reduceRight(
			(nextFn, key) => obj => obj != null && key in obj? nextFn(obj[key]): void 0,
			v => v
		);
	}
	//v2
	var resolvePath = function(path){
		var keys = Array.isArray(path)? path: parsePath(path);
		return function(obj){
			for(var i=0; i<keys.length; ++i){
				if(obj == null) return void 0;
				obj = obj[keys[i]]
			}
			return obj;
		}
	}
	//usage:
	var getSmthEsl = resolvePath('val4[3].sub1[ 1 ][2]["lorem''nipsum"].smth.esl');
	console.log("a", getSmthEsl({
		val4: [
			null,    //0
			null,    //1
			null,    //2
			{            //3
				sub1: [
					null,    //0
					[            //1
						null,    //0
						null,    //1
						{            //2
							"lorem'nipsum": {
								smth: {
									esl: {
										sucess: true
									}
								}
							}
						}
					]
				]
			}
		]
	}))
	
	console.log("b", getSmthEsl({ val4: [] }))

比你想象的简单多了:

window.val4 =  [
            0, 
            'some string', 
            2, 
            {
                sub1:   [
                            [1, 2, 3], 
                            [
                                'val',
                                1, 
                                {
                                    smth:   {
                                                esl: 'final value'
                                            }
                                }
                            ], 
                            [4, 5, 6]
                        ], 
                sub2: 'another str'
            }, 
            4
        ];
let ref = 'val4[3].sub1[ 1 ][2].smth.esl'
let result = window; // or 'global' in node
ref.replace(/('w+)|'['s*('d+)'s*']/g, (_, $1, $2) => result = result[$1 || $2]);
console.log(result)

对于这个作业，您需要能够动态设置对象属性。之前我已经为此目的编写了一个代码。Object.prototype.setNestedValue() .

setNestedValue([prop1[， prop2[， prop3…]]]]，value)完全像它的孪生getNestedValue()一样工作，但最后一个参数是要设置的值。如果该属性不存在，它将根据所提供参数的类型创建一个对象或数组。同样，字符串类型实参将产生一个对象，而数字类型实参将产生一个相同大小的Array。

让我们看看代码。

Object.prototype.setNestedValue = function(...a) {
  a.length > 2 ? typeof this[a[0]] === "object" && this[a[0]] !== null ? this[a[0]].setNestedValue(...a.slice(1))
                                                                       : (this[a[0]] = typeof a[1] === "string" ? {} : new Array(a[1]),
                                                                         this[a[0]].setNestedValue(...a.slice(1)))
               : this[a[0]] = a[1];
  return this;
};
var str = "val4[3].sub1[ 1 ][2].smth.esl",
    arr = str.split(/'['s*('d+)'s*']|'./)
             .filter(prop => prop)
             .map(prop => Number.isNaN(+prop) ? prop : +prop)
             .concat("final value");
 result = {}.setNestedValue(...arr);
 console.log(JSON.stringify(arr));
 console.log(JSON.stringify(result,null,4));

我首先展示结果参数数组如何调用setNestedValue(...arr)，然后是结果对象。

哦，我的错…我以为你想动态地构造对象，但是你喜欢从已经构造的对象中动态地获得嵌套值。Object.prototype.getNestedValue()是这项工作的理想选择。我们已经构造了对象，所以让我们再次使用上面的代码，动态地获取嵌套的值。

Object.prototype.getNestedValue = function(...a) {
  return a.length > 1 ? (this[a[0]] !== void 0 && this[a[0]].getNestedValue(...a.slice(1))) : this[a[0]];
};
Object.prototype.setNestedValue = function(...a) {
  a.length > 2 ? typeof this[a[0]] === "object" && this[a[0]] !== null ? this[a[0]].setNestedValue(...a.slice(1))
                                                                       : (this[a[0]] = typeof a[1] === "string" ? {} : new Array(a[1]),
                                                                         this[a[0]].setNestedValue(...a.slice(1)))
               : this[a[0]] = a[1];
  return this;
};
var str = "val4[3].sub1[ 1 ][2].smth.esl",
    arr = str.split(/'['s*('d+)'s*']|'./)
             .filter(prop => prop)
             .map(prop => Number.isNaN(+prop) ? prop : +prop)
             .concat("final value"),
  myObj = {}.setNestedValue(...arr),
  value;
arr.pop(); // lets remove the "final value" since now we will get it.
value = myObj.getNestedValue(...arr);
console.log(value);