0xD34F

const AccordionItem = ({ title, opened, toggle, children }) => (
  <div>
    <button onClick={toggle}>{title}</button>
    {opened && children}
  </div>
);

const Accordion = ({ items }) => {
  const [ opened, setOpened ] = useState(null);

  return (
    <div>
      {items.map((n, i) => (
        <AccordionItem
          title={n.title}
          opened={i === opened}
          toggle={setOpened.bind(null, i === opened ? null : i)}
        >
          <p>{n.text}</p>
        </AccordionItem>
      ))}
    </div>
  );
};

Уникализируем массивы; объединяем в один; перебираем, отмечая, встречался ли текущий элемент ранее - если элемент встречен впервые, будет false, повторно (т.е., представлен в более чем одном из исходных массивов) будет true; хватаем элементы, которые false:

const diff = (...arrs) => Array
  .from(arrs
    .flatMap(arr => [...new Set(arr)])
    .reduce((acc, n) => acc.set(n, acc.has(n)), new Map))
  .reduce((acc, n) => (n[1] || acc.push(n[0]), acc), []);

Или, собираем Map, где ключами будут элементы вложенных массивов, а значениями множества вложенных массивов, где присутствует данный элемент. Получаем те ключи, где размер множества равен единице:

const diff = (...arrs) => Array
  .from(arrs.reduce((acc, arr) => (
    arr.forEach(n => acc.set(n, acc.get(n) ?? new Set).get(n).add(arr)),
    acc
  ), new Map))
  .reduce((acc, n) => (n[1].size === 1 && acc.push(n[0]), acc), []);

Или, никаких Map и Set - проверяем, что элемент вложенного массива отсутствует во всех других вложенных массивах и в результирующем массиве:

const diff = (...arrs) =>
  arrs.reduce((acc, arr) => (
    arr.forEach(n =>
      arrs.every(m => m === arr || !m.includes(n)) &&
      !acc.includes(n) &&
      acc.push(n)
    ),
    acc
  ), []);

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

Давайте рассмотрим на конкретном примере. Пусть есть массив объектов, на основе которых создаются чекбоксы:

data: () => ({
  items: [
    { checked: false, label: '...' },
    { checked: false, label: '...' },
    ...
  ],
}),

<label v-for="n in items">
  <input type="checkbox" v-model="n.checked">
  {{ n.label }}
</label>

И мы хотим сделать чекбокс, который позволял бы устанавливать или снимать все чекбоксы сразу. Его состояние будет описываться вычисляемым свойством. Геттер - очевидно, будет содержать проверку, что все чекбоксы установлены. А сеттер будет устанавливать переданное ему значение всем чекбоксам. Как-то так:

computed: {
  get() {
    return this.items.every(n => n.checked);
  },
  set(val) {
    this.items.forEach(n => n.checked = val);
  },
},

<label>
  <input type="checkbox" v-model="all">
  ALL
</label>

https://jsfiddle.net/j7hr68t4/

document.querySelector('.calc_container').addEventListener('input', e => {
  const block = e.target.closest('.calc_block');
  const price = +block.querySelector('.price span').innerText;
  const count = +e.target.value;
  block.querySelector('.summ span').innerText = price * count;

  const orderData = Array
    .from(e.currentTarget.querySelectorAll('.calc_block'), n => ({
      name: n.querySelector('label').innerText,
      count: +n.querySelector('.count').value,
      sum: +n.querySelector('.summ span').innerText,
    }))
    .filter(n => n.count);

  document.querySelector('.total_block span').innerText = orderData
    .reduce((acc, n) => acc + n.sum, 0);

  document.querySelector('textarea').value = orderData
    .map(n => `Название: ${n.name} | Количество: ${n.count}`)
    .join('\n');
});

const chunkedAndTransposed = ([ headers, ...arr ], chunkSize) =>
  arr.reduce((acc, n, i) => (
    (i % chunkSize) || acc.push(headers.map(m => [ m ])),
    n.forEach((m, j) => acc.at(-1)[j].push(m)),
    acc
  ), []);


const result = chunkedAndTransposed(arr, 2);

или, если на последний кусок данных не хватает, а размеры вложенных массивов должны быть одинаковыми, можно добавить null'ов или чего-нибудь ещё:

const chunkedAndTransposed = (arr, chunkSize, defautlValue = null) =>
  Array.from({ length: Math.ceil((arr.length - 1) / chunkSize) }, (_, iChunk) =>
    Array.from({ length: arr[0].length }, (_, iCol) =>
      Array.from({ length: chunkSize + 1 }, (_, iRow) =>
        iRow ? arr[iChunk * chunkSize + iRow]?.[iCol] ?? defautlValue : arr[0][iCol]
      )
    )
  );


const result = chunkedAndTransposed(arr, 5);

Документацию пробовали открывать? Там есть ответ на ваш вопрос.

Делаете вычисляемое свойство, которое будет содержат labels и datasets, передаёте его значение в компонент графика под именем chartData. В самом компоненте этот chartData передаёте в renderChart. Например.

Что передаётся в компонент AddProductForm:

AddProduct={this.props.addProduct}

Как вы пытаетесь переданное использовать:

this.props.addProduct(product);

Правда считаете, что между "a" и "A" разницы нет?

Какое сегодня число, о каком select'е идёт речь и как обновлять состояние его option'ов:

const today = new Date().getDate();
const select = document.querySelector('select');
const toggle = option => option.disabled = option.value < today;

Обновляем:

select.querySelectorAll('option').forEach(toggle);

// или

Array.prototype.forEach.call(select, toggle);

// или

for (const n of select.options) {
  toggle(n);
}

// или

for (let i = 0; i < select.children.length; i++) {
  toggle(select.children[i]);
}

const duplicateContent = el =>

  // можно добавить копии вложенных узлов
  el.append(...el.cloneNode(true).childNodes);

  // или добавить копию разметки
  // el.insertAdjacentHTML('beforeEnd', el.innerHTML);

  // или перезаписать разметку в удвоенном виде
  // el.innerHTML += el.innerHTML;
  // el.innerHTML = el.innerHTML.repeat(2);
  // el.innerHTML = Array(3).join(el.innerHTML);
  // el.innerHTML = String.prototype.concat.apply('', Array(2).fill(el.innerHTML));
  // el.innerHTML = el.innerHTML.replace(/.+/, '$&$&');
  // el.innerHTML = /(.+)/.exec(el.innerHTML).join``;

document.querySelectorAll('.btn').forEach(duplicateContent);

// или

for (const n of document.getElementsByClassName('btn')) {
  duplicateContent(n);
}

"Оптимизировать" - в смысле сократить? Вот так можно:

const getDuplicatesIndex = (arr, key = n => n) =>
  Object.fromEntries(Object
    .entries(arr.reduce((acc, n, i) => ((acc[key(n)] ??= []).push(i), acc), {}))
    .filter(n => n[1].length > 1)
  );

Если среди значений массива могут быть такие, которые, будучи различными, имеют одинаковый строковый эквивалент, то обычный объект следует заменить на Map:

const getDuplicatesIndex = (arr, key = n => n) =>
  new Map(Array
    .from(arr.reduce((acc, n, i) => {
      const k = key(n);
      acc.set(k, acc.get(k) ?? []).get(k).push(i);
      return acc;
    }, new Map))
    .filter(n => ~-n[1].length)
  );

Функция - это объект, ей можно добавить нужное свойство:

function wrapper(fn) {
  function wrapped(...args) {
    return fn.apply(this, args);
  }

  wrapped.reset = () => console.log('hello, world!!');

  return wrapped;
}

myMap.enterFullscreen()

Вы невнимательно читали документацию. Этот метод принадлежит не самой карте, а map.container.

var myMap = new ymaps.Map('map', {

Раз используете Vue, так делать не надо. Вместо id передавайте в конструктор карты сам элемент, для получения которого следует использовать ref:

<div ref="map"></div>

mounted() {
  ymaps.ready(() => {
    this.map = new ymaps.Map(this.$refs.map, {
    ...

https://jsfiddle.net/Lw98kjyc/

x?.[Symbol.iterator] instanceof Function

return {
  ...state,
  briefingType: state.briefingType.map(n => n.type === action.payload.type
    ? {
        ...n,
        users: n.users.map(m => m.userName === action.payload.userName
          ? {
              ...m,
              date: action.payload.date,
            }
          : m
        ),
      }
    : n
  ),
};

когда нажимаю на другой блок, то цвет кнопки не становится прежним

Становится. Проявите немного терпения, вам и четырёх месяцев ждать не придётся:

transition: background 9999999s;

Правда, происходит это вовсе не по причине нажатия на другой блок - что такое псевдокласс :active вы, очевидно, не разобрались.

Cделайте скрытые радиокнопки, которые будут нажиматься через label, и стилизуйте в качестве "нажатых" элементы, расположенные после :checked.

например

preg_replace('~\(\s*cm\s*\)~', '(cm)', $str)

state = {
  value: 0,
  options: [ 'Не отмечено', 'Отмечено' ],
}

onChange = ({ target: t }) => {
  this.setState(() => ({
    value: +t[t.dataset.stateAttr],
  }));
}

render() {
  const { value, options } = this.state;

  return (
    <div>
      <select
        value={value}
        onChange={this.onChange}
        data-state-attr="value"
      >
        {options.map((n, i) => <option value={i}>{n}</option>)}
      </select>
      <br />
      <label>
        <input
          type="checkbox"
          checked={value}
          onChange={this.onChange}
          data-state-attr="checked"
        />
        {options[value]}
      </label>
    </div>
  );
}

const longestStr = arr.reduce((max, n) => max.length > n.length ? max : n, '');
// или
const longestStr = arr.sort((a, b) => b.length - a.length)[0];
// или
const longestStr = arr.reduce((acc, n) => (acc[n.length] = n, acc), []).pop();

или, в более общем виде:

function max(data, key = n => n) {
  const getVal = key instanceof Function ? key : n => n[key];
  let result = null;

  for (const n of data) {
    const val = getVal(n);
    if (!result || result[1] < val) {
      result = [ n, val ];
    }
  }

  return result?.[0];
}


const longestStr = max(arr, 'length');

Сравнивайте, делайте выводы:

document.querySelector('#check').addEventListener('change', e => {
  document.querySelector('#password-input').type = e.target.checked
    ? 'text'
    : 'password';
});