遍历具有数组的嵌套对象的解决方法可以使用递归或者栈的方式来实现。下面是一个使用递归的代码示例：

function traverse(obj) {
  for (var key in obj) {
    if (Array.isArray(obj[key])) {
      for (var i = 0; i < obj[key].length; i++) {
        if (typeof obj[key][i] === 'object') {
          traverse(obj[key][i]);
        } else {
          console.log(obj[key][i]);
        }
      }
    } else if (typeof obj[key] === 'object') {
      traverse(obj[key]);
    } else {
      console.log(obj[key]);
    }
  }
}

var nestedObj = {
  a: 1,
  b: [2, 3, 4],
  c: {
    d: 5,
    e: [6, 7],
    f: {
      g: 8
    }
  }
};

traverse(nestedObj);

这段代码会依次输出数组和对象中的所有元素。对于数组，如果元素是对象，则会递归调用traverse函数，直到遇到非对象元素输出；对于嵌套对象，也会递归调用traverse函数。

另外，如果嵌套对象的层级比较深，递归的方式可能会导致调用栈溢出。这时可以考虑使用栈的方式来实现遍历，即使用一个栈数据结构来存储待遍历的对象。具体代码如下：

function traverse(obj) {
  var stack = [obj];
  
  while (stack.length) {
    var current = stack.pop();
    
    for (var key in current) {
      if (Array.isArray(current[key])) {
        for (var i = 0; i < current[key].length; i++) {
          if (typeof current[key][i] === 'object') {
            stack.push(current[key][i]);
          } else {
            console.log(current[key][i]);
          }
        }
      } else if (typeof current[key] === 'object') {
        stack.push(current[key]);
      } else {
        console.log(current[key]);
      }
    }
  }
}

var nestedObj = {
  a: 1,
  b: [2, 3, 4],
  c: {
    d: 5,
    e: [6, 7],
    f: {
      g: 8
    }
  }
};

traverse(nestedObj);

这段代码使用一个栈来存储待遍历的对象，每次从栈中取出一个对象进行处理，如果是数组，则将其中的对象压入栈中，如果是嵌套对象，则直接压入栈中。这样可以避免调用栈溢出的问题。