Aves

const axios = require('axios');
const xml2js = require('xml2js');

const parser = new xml2js.Parser();

const NULL = 0;
const SECOND = 2;

// Ну концепция данной идеи заключается в том, что если появляется новый канал, то мы его просто добавляем во входной массив,
const rssChannels = [
  'https://mos.ru/rss',
  'https://lenta.ru/rss/news',
];

// Итоговый, агрегационный массив с новостями со всех полученных источников из входного массива rssChannels
const newsFeed = [];

// Подключение к RSS ленте, получаем XML и приобразуем из него в JS объекты, затем добавляем в агрегационный массив newsFeed
const getChannelFeed = url =>
  axios.get(url).then(res => {
    return parser.parseStringPromise(res.data)
      .then(res => newsFeed.push(...res.rss.channel[NULL].item))
      .catch(err => console.log('ERROR: Unable to parse received XML'));
  })
    .catch(err => console.log('ERROR: Unable to establish URL connection'));


// Заполняем выходной массив контентов
const someFoo = rssChannels =>
  Promise.all(rssChannels.map(item => getChannelFeed(item)));


someFoo(rssChannels).then(item => console.log(newsFeed));

Вообще, кривовато всё как-то.

https://jsfiddle.net/dwuzo462/
scaledinnovation.com/analytics/splines/aboutSpline...

const source = {one: 'человек', few: 'человека', many: 'человек'};
const pr = new Intl.PluralRules('ru');

for (let i = 70; i<= 400; i++)
  console.log(`${i} ${source[pr.select(i)]}`);

function combine([list, ...rest]) {
	if (rest.length === 0)
    return list;
    
  const res = [];
  for (const a of list)
    for (const b of combine(rest))
      res.push(`${a}${b}`);
  
  return res;
}

Строка закодирована просто в base64

window.atob('\x64\x47\x39\x56\x63\x48\x42\x6c\x63\x6b\x4e\x68\x63\x32\x55\x3d') // "toUpperCase"

const fs = require('fs');
const path = require('path');

async function readDirFiles(dir) {
  const filePaths = await fs.promises.readdir(dir, {withFileTypes: true});
  return await Promise.all(
    filePaths
      .filter(e => e.isFile())
      .map(async (e) => {
        const p = path.join(dir, e.name)
        return {
          path: p,
          content: await fs.promises.readFile(p, {encoding: 'utf8'})
        };
      })
  );
}

readDirFiles('.')
  .then(files => {
    console.log(files);
  })
  .catch(err =>
    console.error(err)
  );

function insert(n, arr) {
  let i = 0;
  while (n > arr[i]) i++;
  arr.splice(i, 0, n);
  return arr;
}

function collapse(src) {
  var res = String.prototype.replace.call(src, /(\d)\1/g, (s, p) => p * 2);
  return res == src ? res : collapse(res)
}

Чтение файла операция асинхронная, нужно слушать событие load.

for(let i = 0; i < input.files.length; i++) {
  const r = reader[i] = new FileReader();
  r.addEventListener('load', () => {
    document.querySelectorAll('.blah3')[i].setAttribute('src', r.result);
  });
  r.readAsDataURL(input.files[i]);
}

https://codepen.io/anon/pen/WjxEqO?editors=0011

Потому что первое значение x при котором условие не будет выполнено 11, и во время проверки оно увеличится до 12.

https://github.com/hden/socketio-wildcard

Object.getOwnPropertyNames(foo).forEach(function(prop) {
  Object.defineProperty(
    bar,
    prop,
    Object.getOwnPropertyDescriptor(foo, prop)
  );
});

Еще вариант https://developer.mozilla.org/ru/docs/Web/JavaScri...

Можно сделать что-нибудь в таком роде:

const stream = require('stream');
const fs = require('fs');

class PercentWatcher extends stream.Duplex {
  constructor(fd) {
    super();
    this.size = fs.fstatSync(fd).size;
    this.handled = 0;
  }
  _read() {}
  _write(chunk, encoding, callback) {
    this.push(chunk);
    this.handled += chunk.length;
    console.log(`\n\n${Math.round(this.handled / this.size * 100)}%\n\n`);
    callback();
  }
}

const fd = fs.openSync('file.txt', 'r');

fs.createReadStream(null, {fd}).pipe(new PercentWatcher(fd)).pipe(process.stdout);

Затем что <h1>Hello World!</h1> преобразуется в React.createElement("h1", null, "Hello World!")

В метод then аргументом нужно функцию передавать() => console.log('res') ну или console.log.bind(console, 'res')

Проще всего так:

class Calc extends React.Component {
  state = {
    valueA: 0,
    valueB: 0
  };
  handleChange = ({target: {name, value}}) => {
    if (name) this.setState({[name]: value});
  };
  render() {
    return (
      <div onChange={this.handleChange}>
        <input type='text' name='valueA' value={this.state.valueA}/>
        <input type='text' name='valueB' value={this.state.valueB} />
      </div>
    );
  }
}

JS Bin

256 = 00000001 00000000

Те, у которых дескриптор с enumarable: false. Не участвуют в for...in и Object.keys().

Для redux нормальная схема. Чтобы избежать лишних отрисовок, нужно использовать shouldComponentUpdate, а запрос отправлять из componentWillReceiveProps. Можно приметно так:

componentWillReceiveProps(nextProps) {
  if (nextProps.complete && !this.props.complete) this.sendRequest();
}

shouldComponentUpdate(nextProps) {
  const changed = Object.keys(nextProps).filter(e => nextProps[e] !== this.props[e]);
  if (changed.length == 1 && changed[0] == 'complete') return false;
}