Присоединяйся к Elem со следующим в функциональном стиле, в JavaScript

Question

Я хочу сделать это:

["a","b","c","d"] -> ["ab","bc","cd"]

точно так же, как в Присоединиться к следующему элементу в функциональном стиле , но в JavaScript.

Поскольку JavaScript не работаетУ меня нет функции sliding, мне интересно, что будет лучшим подходом. Я мог бы что-то сделать с reduce, но это было бы грязно, так как я не эксперт, поэтому я хотел бы получить совет.

Answer 1

Отобразить каждый элемент на себя, соединенный с элементом в i - 1, затем отрезать первый элемент в результате:

const input = ["a","b","c","d"];
const output = input
  .map((elm, i, arr) => arr[i - 1] + elm)
  .slice(1);
console.log(output);

Answer 2

Вы можете использовать Array.from(), чтобы создать массив с длиной на 1 меньше длины входного массива

const input = ["a", "b", "c", "d"],
      length = input.length - 1,
      output = Array.from({ length }, (_, i) => input[i] + input[i+1]);
      
console.log(output)

Answer 3

Попробуйте

["a","b","c","d"].reduce((a,c,i,arr)=> arr[i+1] ? [...a,c+arr[i+1]] : a, [])

let r=["a","b","c","d"].reduce((a,c,i,arr)=> arr[i+1] ? [...a,c+arr[i+1]] : a, [])
console.log(r);

Answer 4

Вы можете создать более общую функцию, которая генерирует все виды фрагментов:

const foldChunks = (len, step) => f => init => xs => {
  const aux = (acc, i) =>
    i + len > xs.length ? acc
      : i + step > xs.length ? f(acc) (xs.slice(i, i + len))
      : aux(f(acc) (xs.slice(i, i + len)), i + step);

  return aux(init, 0);
};

const xs = ["a","b","c","d","e","f","g","h"];

console.log(
  foldChunks(2, 1) (acc => ([s, t]) => (acc.push(s + t), acc)) ([]) (xs));
  
console.log(
  foldChunks(2, 2) (acc => ([s, t]) => (acc.push(s + t), acc)) ([]) (xs));
  
console.log(
  foldChunks(2, 3) (acc => ([s, t]) => (acc.push(s + t), acc)) ([]) (xs));
  
console.log(
  foldChunks(3, 1) (acc => ([s, t, u]) => (acc.push(s + t + u), acc)) ([]) (xs));

Answer 5

Это немного продвинутый, но, по крайней мере, «функциональный» вопрос:

// functional "library"

let range = n => Array(n).fill().map((_, i) => i);
let sliding = n => a => range(a.length - n + 1).map(i => a.slice(i, i + n));
let map = f => a => a.map(f);
let join = d => a => a.join(d);
let apply = (a, f) => f(a);
let pipe = (...fns) => a => fns.reduce(apply, a);

// our function 

let pairs = pipe(sliding(2), map(join('')))

console.log(pairs(['a', 'b', 'c', 'd']))

Конечно, вы можете сделать то же самое с ramda.js или подобной библиотекой.

Answer 6

старайтесь всегда использовать синтаксис ES6

let a=["a","b","c","d"]
let x=a.map((e,j)=> e+a[j+1])
x.splice(x.length-1, 1)
console.log(x)

Answer 7

Вы можете использовать Array.fill () и .map () для достижения требуемого результата

См. Фрагмент кода

const arr = ["a","b","c","d"];

let res = new Array(arr.length-1).fill('').map((v,i)=>arr[i]+arr[i+1]);

console.log(res);

Answer 8

Использование карты

var a=["a","b","c","d"]
var x=a.map(function(e,j){
return e+a[j+1]})
x.pop()
console.log(x)

Используйте цикл for

var a=["a","b","c","d"]
for(let i=0;i<a.length-1;i++)
a[i]=a[i]+a[i+1];
a.pop()
console.log(a)

Answer 9

Вы можете использовать деструктуризацию параметров, чтобы получить первые два элемента, соединить их и обработать остальную часть списка в рекурсивном вызове.

const concat = ([x, ...xs], ys = []) =>
  (x !== undefined && xs[0] !== undefined)
    ? concat(xs, [...ys, x + xs[0]])
    : ys;

console.log(concat(['a', 'b', 'c', 'd']));

Answer 10

Вы можете взять генератор и желаемую длину предметов.

function* joinNext(array, length = 2) {
    var i = 0;
    while (i + length < array.length + 1) yield array.slice(i, i++ + length).join('');
}


var array = ["a", "b", "c", "d"],
    result = [...joinNext(array)];

console.log(result);