async function a() {
  return 'ok'
}

async function b() {
  try{
    const resolve = await a();
    console.log(resolve);
  }catch(reject){
    console.log(err);
  }
}

function monteCarlo() {
  return new Promise(function (resolve, reject) {
    reject({server: 'down'});
  });
}

async function main() {

  // converter para ES6
  try{
    const results = await monteCarlo();
  }catch(reject){
    console.log(reject)
  }
  
  
  return true;
}

function monteCarlo() {
  return new Promise(function (resolve, reject) {
    resolve([{
      titulo: 'UOL - O Melhor conteúdo'
    }]);
  });
}

async function main() {

  // converter para ES6
  await monteCarlo().then(function(response) {
    console.log(response)
  });
  
  return true;
}

const main = () => {
  
  let links = [
    'https://www.uol',
    'https://www.bol.com.br',
    'https://www.uol',
    'https://noticias.uol.com.br',
    'https://www.bol.com.br',
  ];
  
  // converter para ES6
  var uniqueLinks = links.reduce(function (carry, item) {
    if (carry.indexOf(item) === -1) {
      carry.push(item);
    }
    return carry;
  }, []);
  
  const uniques = new Set(links)
  
  
  return uniques;
};

// 1 - Encontre  um número maior que 6
var arr = [1, 4, 6, 8, 10];
var resp = null;
for (var i = 0; i < arr.length; ++i) {
	if (arr[i] > 6) {
		resp = arr[i];
		break;
	}
}

arr.find(item =>  item > 6);


// 2 - Encontre o índice de um número maior que 6
var arr = [1, 4, 6, 8, 10];
var resp = null;
for (var i = 0; i < arr.length; ++i) {
	if (arr[i] > 6) {
		resp = i;
		break;
	}
}

arr.findIndex(index =>  index > 6);


// 3 - Encontre os numeros maiores que 6
var arr = [1, 4, 6, 8, 10];
var resp = arr.reduce((carry, item) => {
  if (item > 6)
    carry.push(item);
  return carry;
}, []);


arr.filter(item => item > 6)

// 4 - O array contém o número 6?
var arr = [1, 4, 6, 8, 10];
var resp = arr.indexOf(6) > -1;


// 5 - Todos os números do array são números pares?
var arr = [2, 4, 6, 8, 9];
var resp = true;
for (var i = 0; i < arr.length; ++i) {
  if (arr[i] % 2 !== 0) {
    resp = false;
    break;
  }
}

arr.every(item => item % 2 == 0)

// 6 - Algum número no array é impar?
var arr = [2, 4, 0, -2];
var resp = arr.reduce(function (carry, item) {
  return carry || (item % 2 !== 0);
}, false);

arr.some(item => item % 2 != 0)

const main = () => {

  let a = [1, 2, 3];
  
  let b = [4, 5, 6];
  
  let c = [7, 8, 9];

  // converter para ES6
  var d = [...a, ...b, ...c];
  
  return d.join(',');
}

function a() {
  "Atualizar o array com o dobro de seus valores"
  
  let a = [1, 2, 3, 4];
  
  a.forEach((item, index) => {
    a[index] = item * 2;
  });
  
  // responda: for, forEach, map ou reduce
  return 'forEach';
}

function b() {
  "Em uma nova variável atribuir a soma dos valores do array"
  
  let a = [4, 10, 23, 99];
  let r = 0;
  
  a.map(item => {
    r += item;
  });
  
  // responda: for, forEach, map ou reduce
  return 'reduce';
}

function c() {
  "Em um novo array o quadrado dos itens de A"
  
  let a = [4, 8, 16];
  let r = a.map(item => Math.pow(item, 2));
  
  // responda: for, forEach, map ou reduce
  return 'map';
}

function d() {
  "Encontrar no array um item que seja maior ou igual a 2"
  
  let a = [1, 2, 3, 4];
  let resp = null;
  
  a.forEach((item, index) => {
    if (item >= 2) {
      resp = item;
    }
  });
  
  // responda: for, forEach, map ou reduce
  return 'for';
}

function e() {
  "Um novo array com valores únicos de A"
  
  let a = [1, 2, 2, 3, 4];
  let b = [];
  
  for (const item of a) {
    if (!b.includes(item))
      b.push(b);
  }
  
  // responda: for, forEach, map ou reduce
  return 'reduce';
}

function f() {
  "Novo array com itens de índice par"
  
  let a = ['a', 'b', 'c', 'd'];
  let b = [];
  
  a.map((item, index) => {
    if (index % 2 == 0) {
      b.push(item);
    }
  });
  
  // responda: for, forEach, map ou reduce
  return 'forEach';
}

function g() {
  "Executar chamadas http de forma assíncrona"
  
  let a = ['/p=1', '/p=2', '/p=3'];
  
  for (let path of a) {
    let xhr = new function() {};
    // ...
  }
  
  // responda: for, forEach, map ou reduce
  return 'for';
}

function h() {
  "Novo array com apenas titulo e descrição de uma resposta no Monte Carlo"
  
  let results = [{titulo: '..', descricao: '', tags: [], photo: '...'}];
  
  let resp = results.map(({titulo, descricao}) => ({titulo, descricao}));
  
  // responda: for, forEach, map ou reduce
  return 'map';
}

function i() {
  "Descompactar a matriz em uma lista"
  
  let a = [[1, 2], [4, 5], [4, 5]];
  let resp = a.reduce((carry, row) => ([...carry, ...row]), []);
  
  // responda: for, forEach, map ou reduce
  return 'reduce';
}

function j() {
  "Multiplicar matrizes"
  
  let a = [1, 2, 3];
  let b = [4, 5, 6];
  
  let resp = a.reduce((carry, v, i) => carry + v * b[i], 0);
  
  // responda: for, forEach, map ou reduce
  return 'reduce';
}

function k() {
  "Transformar as letras em maiúsculas"
  
  let a = ['Fred', 'John', 'Paul'];
  
  for (const [index, value] of a.entries()) {
    a[index] = value.toUpperCase();
  }
  
  // responda: for, forEach, map ou reduce
  return 'forEach';
}

function l() {
  "Exibir no console as chaves e os valores"
  
  let config = {portal: 'UOL', channel: 'Notícias', slug: 'uol'};
  
  for (const prop in config) {
    console.log(prop, config[prop]);
  }
  
  // responda: for, forEach, map ou reduce
  return 'for';
}

function m() {
  "Exibir no console os itens do array"
  
  let tags = ['São Paulo', 'Sudeste', 'Brasil'];

  for (const k in tags) {
    console.log(tags[k]);
  }
  
  // responda: for, forEach, map ou reduce
  return 'for';
}

class Component {
  constructor(dom) {
    console.log('Parent class constructor executed!');
    this.dom = dom;
  }
  
  onCreate() {
    return true;
  }
}

class Collection extends Component {
  constructor(dom, test) {
    super(dom);
  } 
}

class Component {
  constructor(dom) {
      this.dom = dom;
  }
  
  onCreate() {
    console.log('onCreate from parent class');
    return 'missing';
  }
  
  static on(event, callback) {
    callback();
  }
  
  async emit(event, data) {}
}

class Title extends Component {
   constructor(dom){
       super(dom)
   }
   
   onCreate() {
     return 'super!'
   }
}

class Component {
  constructor(dom) {
    this.dom = dom;
  }
  
  onCreate() {
    return this.dom;
  }
}

const todo = () => 'Walk';


// reescrever em ES6

{
  const todo = () => 'Run';
}

// reescreva usando ES6

const prop = 'myProp';

const obj = {
  [prop]: 123,
  
  myFunc() {
    return this[prop];
  } 
};

const title = 'UOL - O melhor conteúdo';

const share = {
  fb: {
    title
  },
  twitter: {
    tweet: title
  }
};

let results = [
  {materia: {conteudo: {titulo: 'São Paulo'}}, tags: [1, 2, 3]},
  {materia: {conteudo: {}}, tags: [3, 2]},
  {materia: {conteudo: {titulo: 'Rio de Janeiro'}}, tags: [3, 2]},
];


for (const { materia: { conteudo: {titulo = 'Brasil'}}} of results) {
  console.log(titulo);
}

const materia = {
  conteudo: {
    titulo: 'UOL',
  },
  tags: ['São Paulo', 'SP', 'Sudeste', 'Brasil', 'América Latina']
};

const {conteudo: { titulo}, tags: [cidade, uf, regiao]} = materia;