проблемы с array.concat ()

Question

Я пытаюсь использовать рекурсивный вызов для конкатенации возвращаемого массива.

Направления этой проблемы: поток данных получен и должен быть обращен.

Каждый сегмент8 бит длиной, означая, что порядок этих сегментов должен быть обратным, например:

11111111 00000000 00001111 10101010 (byte1) (byte2) (byte3) (byte4) должен стать:

1010101000001111 00000000 11111111 (byte4) (byte3) (byte2) (byte1) Общее число битов всегда будет кратно 8.

, пробуя разные комбинации вещей действительно ...

function dataReverse(data) {
  //split incoming array into array values consisting of 8 numbers each.
  //var octGroups = data.length / 8;
  var result = [];
  //recursive call
  function shuffler(array){
    let input = array;
    //base case
    if(input.length === 0){
      return result;
    } else {
      //concat result with 8 values at a time
      let cache = input.splice(-8,8);
      result.concat(cache);
      return shuffler(input);
    }
    return result;
  }
  
  
  
  
  
  var reversed = shuffler(data);
//base case is if data.length === 0 return result else
//reverse iterate through array, concating to new return array
//return result
  return reversed;
}

console.log(dataReverse([1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,0,1,0,1,0]));

ожидается, что он обратится через входной массив, объединяя массив результатов с 8 значениями одновременно, начиная с конца, но не изменяя порядок чисел.

Моя попытка выше возвращает массив нулевой длины.Что я сделал не так?

Answer 1

Используйте join вместо concat

function dataReverse(data) {
  //split incoming array into array values consisting of 8 numbers each.
  //var octGroups = data.length / 8;
  var result = [];
  //recursive call
  function shuffler(array) {
    let input = array;
    //base case
    if (input.length === 0) {
      return result;
    } else {
      //concat result with 8 values at a time
      let cache = input.splice(-8, 8);
      result.push(cache.join(''));
      return shuffler(input);
    }
    return result;
  }


  var reversed = shuffler(data);
  //base case is if data.length === 0 return result else
  //reverse iterate through array, concating to new return array
  //return result
  return reversed;
}

console.log(dataReverse([1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]));

Answer 2

concat возвращает новый массив, который вам нужно присвоить обратно результату

result = result.concat(cache);

И если вы хотите, чтобы каждый байт представлял собой строку из 8 символов, вы можете использовать объединение

result = result.concat(cache.join(''));

function dataReverse(data) {
  //split incoming array into array values consisting of 8 numbers each.
  //var octGroups = data.length / 8;
  var result = [];
  //recursive call
  function shuffler(array) {
    let input = array;
    //base case
    if (input.length === 0) {
      return result;
    } else {
      //concat result with 8 values at a time
      let cache = input.splice(-8, 8);
      result = result.concat(cache);
      return shuffler(input);
    }
    return result;
  }


  var reversed = shuffler(data);
  //base case is if data.length === 0 return result else
  //reverse iterate through array, concating to new return array
  //return result
  return reversed;
}

console.log(dataReverse([1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]));

Вы можете просто зациклить массив, создать группу по 8 байт каждый, а затем развернуть и затем уменьшить до одного массива

let dataReverse = (data) => {
  let count = 0
  let temp = []
  let group = data.reduce((op, inp) => {
    temp.push(inp)
    if (count === 8) {
      op.push(temp)
      temp = []
    }
    return op
  }, [])
  if (temp.length) group.push(temp)
  return group.reverse().reduce((op,inp)=>op.concat(inp))
}


console.log(dataReverse([1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]));

Answer 3

Вы можете разбить массив на 8 pieces each, а затем просто использовать Array.reverse и Array.flat .Преимущество этого заключается в том, что вы получаете хороший функциональный, многократно используемый, кодируемый и очень читаемый код.

Учтите это:

let data = [1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,0,1,0,1,0]

// utility function to chunk array by number
const chunkBy = (arr, by=2) => arr.reduce((r,c,i) => (i%by==0 ? r.push([c]) : r[r.length-1] = [...r[r.length-1], c], r), [])

let result = chunkBy(data, 8).reverse().flat()

console.log('in:  ', data.join(''))
console.log('out: ', result.join(''))

Вот функция chunkBy в более удобочитаемой форме:

let data = [1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,0,1,0,1,0]

const chunkBy = (arr, by=2) => // default to chunks of 2
  arr.reduce((acc, cur, index) => {
    if(index % by == 0)        // use modulo to check for the remainder
      acc.push([cur])          // if exact then we start a new chunk
    else                       // if not we keep adding to the previous chunk
      acc[acc.length-1] = [...acc[acc.length-1], cur]
    return acc
}, [])

console.log(chunkBy(data, 8))

Если вы используете lodash _.chunk уже существует:

let data = [1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,0,1,0,1,0]

let result = _(data)
  .chunk(8)
  .reverse()
  .flatten()
  .value()

console.log(result.join(''))

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

Answer 4

concat возвращает массив - присвойте результат:

function dataReverse(data) {
  //split incoming array into array values consisting of 8 numbers each.
  //var octGroups = data.length / 8;
  var result = [];
  //recursive call
  function shuffler(array) {
    let input = array;
    //base case
    if (input.length === 0) {
      return result;
    } else {
      //concat result with 8 values at a time
      let cache = input.splice(-8, 8);
      result = result.concat(cache);
      return shuffler(input);
    }
    return result;
  }


  var reversed = shuffler(data);
  //base case is if data.length === 0 return result else
  //reverse iterate through array, concating to new return array
  //return result
  return reversed;
}

let reversed = dataReverse([1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]);

//Code for pretty-printing in groups of 8
reversed = reversed.reduce((acc, curr, i) => {
  const c = Math.floor(i / 8);
  acc[c] = [].concat((acc[c] || []), curr);
  return acc;
}, []);

console.log(reversed.map(e => e.join("")));

.as-console-wrapper {
  max-height: 100% !important;
  top: auto;
}

(блок массива из этого ответа ).