Javascript 如何使用同一数组中的其他项更改数组中的项

我需要将数组A更改为数组B，确保哈希项成为任意数量的非哈希项的前一个，直到下一个哈希项

const A = [ '# test',
  'test',
  '# layouts',
  'main',
  'nav' ]

const B = ['test/test',
    'layouts/main',
    'layouts/nav' ]

---

您可以使用

reduce

为此，累加器应该是一个包含两个值的对象，第一个值是结果数组，另一个值是要在

reduce

中用于生成路径的当前哈希字符串。一旦

reduce

完成它的工作，我们就可以将累加器的

result

属性存储到我们的结果变量

B

：

const B = A.reduce((acc, str) => {                           // for each string in the array A
   if(str.indexOf("#") === 0) {                              // if the string is hashed one
      acc.currentHash = str.slice(2);                        // set the current hash to this string
   } else {                                                  // otherwise
      acc.result.push(acc.currentHash + "/" + str);          // use the current hash to generate the resulting string of the current string
   }
   return acc;
}, { result: [], currentHash: ""}).result;                   // once reduce finishes, use '.result' to access the result array of the accumulator

示例：

const A=['#test'、'test'、'layouts'、'main'、'nav'；
常数B=A.reduce（（acc，str）=>{
if（str.indexOf（“#”）==0）{
acc.currentHash=str.slice（2）；
}否则{
acc.result.push（acc.currentHash+“/”+str）；
}
返回acc；
}，{result:[]，currentHash:：}）；
控制台日志（B）

您可以使用

reduce

为此，累加器应该是一个包含两个值的对象，第一个值是结果数组，另一个值是要在

reduce

中用于生成路径的当前哈希字符串。一旦

reduce

完成它的工作，我们就可以将累加器的

result

属性存储到我们的结果变量

B

：

const B = A.reduce((acc, str) => {                           // for each string in the array A
   if(str.indexOf("#") === 0) {                              // if the string is hashed one
      acc.currentHash = str.slice(2);                        // set the current hash to this string
   } else {                                                  // otherwise
      acc.result.push(acc.currentHash + "/" + str);          // use the current hash to generate the resulting string of the current string
   }
   return acc;
}, { result: [], currentHash: ""}).result;                   // once reduce finishes, use '.result' to access the result array of the accumulator

示例：

const A=['#test'、'test'、'layouts'、'main'、'nav'；
常数B=A.reduce（（acc，str）=>{
if（str.indexOf（“#”）==0）{
acc.currentHash=str.slice（2）；
}否则{
acc.result.push（acc.currentHash+“/”+str）；
}
返回acc；
}，{result:[]，currentHash:：}）；
控制台日志（B）我首选的方法是将数组映射到所需的格式，然后过滤掉无关的标记

const needle = '# ';
let directoryName = '';
const b = a.map((elem) => {
    if (elem.startsWith(needle)) {
        directoryName = elem.substring(needle.length);
        return;
    }
    return directoryName + '/' + elem;
}).filter(Boolean);

注意，我已经优化了代码的可读性。它将在阵列上循环两次，这几乎可以肯定，因为这里的操作非常快。但是如果你有一个巨大的数组，并且需要每一点性能，Ibrahim的答案会更合适。
我的首选方法是将数组映射到所需的格式，然后过滤掉无关的标记

const needle = '# ';
let directoryName = '';
const b = a.map((elem) => {
    if (elem.startsWith(needle)) {
        directoryName = elem.substring(needle.length);
        return;
    }
    return directoryName + '/' + elem;
}).filter(Boolean);

注意，我已经优化了代码的可读性。它将在阵列上循环两次，这几乎可以肯定，因为这里的操作非常快。但是如果你有一个庞大的数组，需要每一点性能，Ibrahim的答案会更合适。
这里有一个方法，你可以利用
数组.prototype.reduce
和
对象.key


函数修改（a，分隔符）{
常数f=a.reduce（（累计，el）=>{
var s=标高替换（/\s/g'）；
if（s.charAt（0）==分隔符）{
累计指针=s子串（1）；
累计数据[累计指针]=[]；
}否则{
累计数据[累计指针].push（el）；
}
返回累计；
}, {
指针：null，
数据：{}
});
返回Object.keys（f.data.map）（k=>{
var s=`${delimiter}${k}`
var值=f.数据[k]；
值。forEach（v=>{
s+=`/${v}`
});
返回s；
});
}
常数A=['#测试'，
"测试",，
"布局",，
"主要",，
“导航”
]
常数B=修改（A，“#”）；
控制台日志（B）这里有一种方法，您可以使用
数组.原型.reduce
和
对象.keys


函数修改（a，分隔符）{
常数f=a.reduce（（累计，el）=>{
var s=标高替换（/\s/g'）；
if（s.charAt（0）==分隔符）{
累计指针=s子串（1）；
累计数据[累计指针]=[]；
}否则{
累计数据[累计指针].push（el）；
}
返回累计；
}, {
指针：null，
数据：{}
});
返回Object.keys（f.data.map）（k=>{
var s=`${delimiter}${k}`
var值=f.数据[k]；
值。forEach（v=>{
s+=`/${v}`
});
返回s；
});
}
常数A=['#测试'，
"测试",，
"布局",，
"主要",，
“导航”
]
常数B=修改（A，“#”）；
控制台日志（B）步骤1，不要对你想更改的内容使用
常量。步骤1，不要对你想更改的内容使用
常量。