Javascript 递归查找嵌套数组中的最后一个字符串？

以下是阵列：

[ 'markdown',
  [ 'para', 'this is a paragraph' ],
  [ 'para', {class: 'custom-class'}, 'another paragraph' ],
  [ 'hr' ],
  [ 'bulletlist',
    [ 'listitem', 'This is a list' ],
    [ 'listitem', 'This is another list' ] ] ]

我想做的是在每个字符串中找到最后一个字符串。在这种情况下，

“这是一段”

，

“另一段”

，

“这是一个列表”

，

“这是另一个列表”

。（我对只有一个字符串的数组不感兴趣，在本例中，

hr

。但我想这是另一个问题。）

我能做到的最好的是：

for (i = 1; i < tree.length; i++) {
  var node = tree[i]
  var lastItem = node[node.length - 1] 

  console.log(lastItem)
}

\\ this is a paragraph
\\ {class: 'custom-class'}
\\ hr
\\ [ 'listitem', 'This is a list' ]
\\ [ 'listitem', 'This is another list' ]

for（i=1；i

我认为您可以看到问题，尽管1）循环有时会找到嵌套数组/对象2）它不是递归的

---

我应该如何修改循环，使其始终找到这些数组的最后一个字符串？

我很难理解您的对象结构，因此我将首先给出一个措辞明确的答案。如果您的对象结构变得更清晰，我可以编写一个实际的编码示例

在这里不使用递归是不可能的，因为您不知道数组的嵌套深度。您需要做的是创建一个函数，该函数接收一个对象作为参数。然后，该函数遍历对象的所有元素，如果它看到其中任何元素是数组，则调用自身。当它到达最后一个元素时，它将被打印

基本上沿着以下路线：

function findLastString(obj)
    loop obj.length
        if obj[i] == array
        then findLastString(obj[i])
    end loop
    if obj[obj.length-1] != array
    then print(obj[obj.length-1])
end function

---

我很难理解你的对象结构，所以我将首先给出一个措辞明确的答案。如果您的对象结构变得更清晰，我可以编写一个实际的编码示例

在这里不使用递归是不可能的，因为您不知道数组的嵌套深度。您需要做的是创建一个函数，该函数接收一个对象作为参数。然后，该函数遍历对象的所有元素，如果它看到其中任何元素是数组，则调用自身。当它到达最后一个元素时，它将被打印

基本上沿着以下路线：

function findLastString(obj)
    loop obj.length
        if obj[i] == array
        then findLastString(obj[i])
    end loop
    if obj[obj.length-1] != array
    then print(obj[obj.length-1])
end function

---

我很难理解你的对象结构，所以我将首先给出一个措辞明确的答案。如果您的对象结构变得更清晰，我可以编写一个实际的编码示例

在这里不使用递归是不可能的，因为您不知道数组的嵌套深度。您需要做的是创建一个函数，该函数接收一个对象作为参数。然后，该函数遍历对象的所有元素，如果它看到其中任何元素是数组，则调用自身。当它到达最后一个元素时，它将被打印

基本上沿着以下路线：

function findLastString(obj)
    loop obj.length
        if obj[i] == array
        then findLastString(obj[i])
    end loop
    if obj[obj.length-1] != array
    then print(obj[obj.length-1])
end function

---

我很难理解你的对象结构，所以我将首先给出一个措辞明确的答案。如果您的对象结构变得更清晰，我可以编写一个实际的编码示例

在这里不使用递归是不可能的，因为您不知道数组的嵌套深度。您需要做的是创建一个函数，该函数接收一个对象作为参数。然后，该函数遍历对象的所有元素，如果它看到其中任何元素是数组，则调用自身。当它到达最后一个元素时，它将被打印

基本上沿着以下路线：

function findLastString(obj)
    loop obj.length
        if obj[i] == array
        then findLastString(obj[i])
    end loop
    if obj[obj.length-1] != array
    then print(obj[obj.length-1])
end function

---

使用带累加器的减速器和递归：

var findLast = function(xs) {
  return xs.reduce(function(acc, x) {
    if (Array.isArray(x)) {
      var last = x[x.length-1]
      if (Array.isArray(last)) {
        return acc.concat(findLast(x))
      }
      return acc.concat(last)
    }
    return acc
  },[])
}

console.log(findLast(yourArray))
/*^
[ 'this is a paragraph',
  'another paragraph',
  'hr',
  'This is a list',
  'This is another list' ]
*/

请注意，递归不是必需的，因为递归问题总是可以使用循环和堆栈（如果需要）来解决。递归更为优雅，但在JavaScript中，它会用许多嵌套数组（直到浏览器提供TCO）破坏堆栈，但循环不会：

var findLast = function(xs) {
  var out = []
  for (var i = 0; i < xs.length; i++) {
    var x = xs[i]
    if (Array.isArray(x)) {
      var last = x[x.length-1]
      if (Array.isArray(last)) {
        xs = x
        i = 0
      } else {
        out.push(last)
      }
    }
  }
  return out
}

---

演示：

使用带累加器的减速器和递归：

var findLast = function(xs) {
  return xs.reduce(function(acc, x) {
    if (Array.isArray(x)) {
      var last = x[x.length-1]
      if (Array.isArray(last)) {
        return acc.concat(findLast(x))
      }
      return acc.concat(last)
    }
    return acc
  },[])
}

console.log(findLast(yourArray))
/*^
[ 'this is a paragraph',
  'another paragraph',
  'hr',
  'This is a list',
  'This is another list' ]
*/

请注意，递归不是必需的，因为递归问题总是可以使用循环和堆栈（如果需要）来解决。递归更为优雅，但在JavaScript中，它会用许多嵌套数组（直到浏览器提供TCO）破坏堆栈，但循环不会：

var findLast = function(xs) {
  var out = []
  for (var i = 0; i < xs.length; i++) {
    var x = xs[i]
    if (Array.isArray(x)) {
      var last = x[x.length-1]
      if (Array.isArray(last)) {
        xs = x
        i = 0
      } else {
        out.push(last)
      }
    }
  }
  return out
}

---

演示：

使用带累加器的减速器和递归：

var findLast = function(xs) {
  return xs.reduce(function(acc, x) {
    if (Array.isArray(x)) {
      var last = x[x.length-1]
      if (Array.isArray(last)) {
        return acc.concat(findLast(x))
      }
      return acc.concat(last)
    }
    return acc
  },[])
}

console.log(findLast(yourArray))
/*^
[ 'this is a paragraph',
  'another paragraph',
  'hr',
  'This is a list',
  'This is another list' ]
*/

请注意，递归不是必需的，因为递归问题总是可以使用循环和堆栈（如果需要）来解决。递归更为优雅，但在JavaScript中，它会用许多嵌套数组（直到浏览器提供TCO）破坏堆栈，但循环不会：

var findLast = function(xs) {
  var out = []
  for (var i = 0; i < xs.length; i++) {
    var x = xs[i]
    if (Array.isArray(x)) {
      var last = x[x.length-1]
      if (Array.isArray(last)) {
        xs = x
        i = 0
      } else {
        out.push(last)
      }
    }
  }
  return out
}

---

演示：

使用带累加器的减速器和递归：

var findLast = function(xs) {
  return xs.reduce(function(acc, x) {
    if (Array.isArray(x)) {
      var last = x[x.length-1]
      if (Array.isArray(last)) {
        return acc.concat(findLast(x))
      }
      return acc.concat(last)
    }
    return acc
  },[])
}

console.log(findLast(yourArray))
/*^
[ 'this is a paragraph',
  'another paragraph',
  'hr',
  'This is a list',
  'This is another list' ]
*/

请注意，递归不是必需的，因为递归问题总是可以使用循环和堆栈（如果需要）来解决。递归更为优雅，但在JavaScript中，它会用许多嵌套数组（直到浏览器提供TCO）破坏堆栈，但循环不会：

var findLast = function(xs) {
  var out = []
  for (var i = 0; i < xs.length; i++) {
    var x = xs[i]
    if (Array.isArray(x)) {
      var last = x[x.length-1]
      if (Array.isArray(last)) {
        xs = x
        i = 0
      } else {
        out.push(last)
      }
    }
  }
  return out
}

---

演示：

hr

是

['hr']

中的最后一个字符串。为什么不包括这些？@thefourtheye你是对的。我编辑了这个问题。@nicael你说得对。谢谢。

hr

是

['hr']

中的最后一个字符串。为什么不包括这些？@thefourtheye你是对的。我编辑了这个问题。@nicael你说得对。谢谢。

hr

是

['hr']

中的最后一个字符串。为什么不包括这些？@thefourtheye你是对的。我编辑了这个问题。@nicael你说得对。谢谢。

hr

是

['hr']

中的最后一个字符串。为什么不包括这些？@thefourtheye你是对的。我编辑了这个问题。@nicael你说得对。谢谢。“不使用递归是不可能的”--这不是不可能的，如果必要的话，你可以随时使用循环和堆栈。“不可能”这个词有点苛刻，但是如果没有递归处理这种类型的结构是没有意义的。“不使用递归是不可能的”--这不是不可能的，如果有必要，您可以随时使用循环和堆栈。好吧，“不可能”这个词有点苛刻，但如果不使用递归来处理这种类型的结构，它真的没有意义。“不使用递归是不可能的”-