另一个javascript数组挑战

解决另一个数组操作，我需要比平常更长的时间来解决这个问题。我需要有关组合数组值的帮助：

var array1 = ["alpha|LJ", "bravo|MH", "charlie|MH", "delta|MF",
              "echo|16", "{foxtrot}|GG", "{golf}|HS"];

var array2 = ["charlie-{golf}-{foxtrot}", "echo-{golf}"]; //some templates

以使最终阵列为：

final_array = ["alpha-LJ", "bravo-MH", "charlie-HS-GG-MH", "delta-MF",
               "echo-HS-16"];

为了弄清楚我是如何得到最终的_数组的，alpha、bravo和delta只将它们的“|”替换为“-”，因为在我的array2模板上找不到它们。charlie和echo获得了模板，因此{}的相应值根据array1被替换。老实说，Array1并不是我现在能想到的最好的关键：价值关系

以下是一些要求：

* Anything in array1 with {} braces are not meant to be templated.
* Keywords in array2 will always have a matching value in array1. 

我读过关于jquery.map（）的文章，认为使用它是可以实现的，也许可以与Regexp一起使用。希望你能利用这些。此外，如果有帮助，最终的_数组可以是任意顺序的

我真的需要提高我对这两个主题的知识…：|

---

提前感谢您。

编辑：更新以匹配您的输出并评论一些疯狂。考虑到在开始时对值执行了

split（）

操作，然后在结束时又执行了

split（），这并不是最有效的方法……但它确实有效

function funkyTransform( values, templates ){
  // Make a copy of the array we were given so we can mutate it
  // without rudely changing something passed to our function.
  var result = values.concat();

  // Map {value} entries for later lookup, and throw them out of the result
  var valueMap = {};
  for (var i=result.length-1;i>=0;--i){
    var pair = result[i].split('|');
    if (pair[0][0]=="{"){
      valueMap[pair[0]] = pair[1];
      result.splice(i,1); // Yank this from the result
    }
  }
  console.log(valueMap);
  // {
  //   "{foxtrot}": "GG",
  //   "{golf}":    "HS"
  // }

  // Use the value map to replace text in our "templates", and
  // create a map from the first part of the template to the rest.
  // THIS SHOULD REALLY SCAN THE TEMPLATE FOR "{...}" PIECES
  // AND LOOK THEM UP IN THE MAP; OOPS O(N^2)
  var templateMap = {};
  for (var i=templates.length-1;i>=0;--i){
    var template = templates[i];
    for (var name in valueMap){
      if (valueMap.hasOwnProperty(name)){
        template = template.replace(name,valueMap[name]);
      }
    }
    var templateName = template.split('-')[0];
    templateMap[ templateName ] = template.slice(templateName.length+1);
  }
  console.log(templateMap);
  // {
  //   "charlie": "HS-GG",
  //   "echo":    "HS"
  // }

  // Go through the results again, replacing template text from the templateMap
  for (var i=result.length-1;i>=0;--i){
    var pieces = result[i].split('|');
    var template = templateMap[pieces[0]];
    if (template) pieces.splice(1,0,template);
    result[i] = pieces.join('-');
  }
  return result;
}

var output = funkyTransform( array1, array2 );
console.log(output);
// ["alpha-LJ", "bravo-MH", "charlie-HS-GG-MH", "delta-MF", "echo-HS-16"]

编辑：更新以匹配您的输出并评论一些疯狂。考虑到在开始时对值执行了
split（）
操作，然后在结束时又执行了
split（），这并不是最有效的方法……但它确实有效

function funkyTransform( values, templates ){
  // Make a copy of the array we were given so we can mutate it
  // without rudely changing something passed to our function.
  var result = values.concat();

  // Map {value} entries for later lookup, and throw them out of the result
  var valueMap = {};
  for (var i=result.length-1;i>=0;--i){
    var pair = result[i].split('|');
    if (pair[0][0]=="{"){
      valueMap[pair[0]] = pair[1];
      result.splice(i,1); // Yank this from the result
    }
  }
  console.log(valueMap);
  // {
  //   "{foxtrot}": "GG",
  //   "{golf}":    "HS"
  // }

  // Use the value map to replace text in our "templates", and
  // create a map from the first part of the template to the rest.
  // THIS SHOULD REALLY SCAN THE TEMPLATE FOR "{...}" PIECES
  // AND LOOK THEM UP IN THE MAP; OOPS O(N^2)
  var templateMap = {};
  for (var i=templates.length-1;i>=0;--i){
    var template = templates[i];
    for (var name in valueMap){
      if (valueMap.hasOwnProperty(name)){
        template = template.replace(name,valueMap[name]);
      }
    }
    var templateName = template.split('-')[0];
    templateMap[ templateName ] = template.slice(templateName.length+1);
  }
  console.log(templateMap);
  // {
  //   "charlie": "HS-GG",
  //   "echo":    "HS"
  // }

  // Go through the results again, replacing template text from the templateMap
  for (var i=result.length-1;i>=0;--i){
    var pieces = result[i].split('|');
    var template = templateMap[pieces[0]];
    if (template) pieces.splice(1,0,template);
    result[i] = pieces.join('-');
  }
  return result;
}

var output = funkyTransform( array1, array2 );
console.log(output);
// ["alpha-LJ", "bravo-MH", "charlie-HS-GG-MH", "delta-MF", "echo-HS-16"]

尽管我做了一些假设，但这还是成功地获得了您想要的输出：


数组1中带有{}大括号的任何内容都不应该被模板化
array2中的关键字在array1中总是有一个匹配值（这很容易更改，但不确定规则是什么）

代码：

//这是主代码
var final_数组=$.map（数组1，函数（项）{
var components=item.split（“|”）；
//忽略{}大括号之间的元素
if（/^\{.*\}$/.test（组件[0]）返回；
组件[0]=模板（组件[0]）；
返回组件。联接（'-'）；
});
//帮助器查找特定字符串的array2并为其设置模板
//使用array1中的值
函数模板（str）{
var指数=指数匹配（array2，str，'-'）；
如果（索引==-1）返回str；
var components=array2[index].split（'-'）；
var结果=[str]；
对于（变量i=1；i
虽然我做了一些假设，但这成功地获得了您想要的输出：


数组1中带有{}大括号的任何内容都不应该被模板化
array2中的关键字在array1中总是有一个匹配值（这很容易更改，但不确定规则是什么）

代码：

//这是主代码
var final_数组=$.map（数组1，函数（项）{
var components=item.split（“|”）；
//忽略{}大括号之间的元素
if（/^\{.*\}$/.test（组件[0]）返回；
组件[0]=模板（组件[0]）；
返回组件。联接（'-'）；
});
//帮助器查找特定字符串的array2并为其设置模板
//使用array1中的值
函数模板（str）{
var指数=指数匹配（array2，str，'-'）；
如果（索引==-1）返回str；
var components=array2[index].split（'-'）；
var结果=[str]；
对于（变量i=1；i
如果您可以控制array1的结构，请尝试使用json，该结构只是。。。疯狂的使用json，您至少可以进行键值查找，而不必拆分字符串和使用过于复杂的正则表达式。对我来说，你是在为一个缓慢的脚本而设计。还有一句相关的话：“一些开发人员在遇到问题时会想，我知道，我会使用正则表达式。现在他们有两个问题。”感谢您提供了您的输入和所需的输出。不幸的是，我无法理解这种关系。为什么
alpha | LJ
会有连字符？为什么
bravo | MH
保留
MH
，但是
charlie | MH
用其他东西替换了它？也许我很傻，但我看不出逻辑在应用。呵呵，这句话很有趣！：）我来看看我能用第一个做些什么array@Phrogz，bravo保留了MH，因为在模板上找不到它。如果在模板上找不到，只需将|文本替换为hypen即可。由于下面的模板（array2），charlie被替换为其他内容。您实际要做的是什么？这些数据结构的格式是淫秽的…听起来你需要备份一些。如果你对array1的结构有任何控制权，请尝试使用json，该结构只是。。。疯狂的使用json，您至少可以进行键值查找，而不必拆分字符串和使用过于复杂的正则表达式。对我来说，你是在为一个缓慢的脚本而设计。还有一句相关的话：“一些开发人员在遇到问题时会想，我知道，我会使用正则表达式。现在他们有两个问题。”感谢您提供了您的输入和所需的输出。不幸的是，我无法理解这种关系。为什么
alpha | LJ
会有连字符？为什么
bravo | MH
保留
MH
，但是
charlie | MH
用其他东西替换了它？也许我很傻，但我看不出逻辑在应用。呵呵，这句话很有趣！：）我来看看我能用第一个做些什么array@Phrogzbravo保留了MH becau