/* É necessário escrever uma função para calcular a soma de todos os valores numéricos num array. Valores numéricos válidos também são strings, que começam com dígitos. Nesse caso, deve-se usar essa sequência inicial de dígitos como valor numérico. O array pode conter quaisquer tipos de dados e não ser plano. **Não deve usar métodos embutidos como .flat, .flatMap** */ function sum(arr) { // ... } console.log(sum([1, 'x', '2x', ['3', ['x2', '5']]]));
Para cada um dos três trechos de código JavaScript, determine o que será exibido no console e explique as diferenças no comportamento de primitivos, objetos e reatribuições de referências.
/** * É necessário escrever uma função assíncrona, * que "durma" a quantidade de milissegundos especificada, * e depois termine com sucesso * / function sleep(duration) { } // Exemplo const startTime = Date.now(); console.log("começando a dormir..."); sleep(2000).then(() => { console.log("Acordei após 2 segundos!"); console.log("Tempo passado: ", Date.now() - startTime); }); sleep(1000).then(() => { console.log("Acordei após 1 segundo!"); console.log("Tempo passado: ", Date.now() - startTime); });
Dada uma função síncrona e um tempo em milissegundos. É necessário retornar uma nova versão dessa função, cuja execução seja limitada pelo tempo especificado. Se a função for executada dentro do tempo, a promessa é resolvida com os dados obtidos. Caso contrário, a promessa é rejeitada com a string 'time limit exceeded'.
/** * Implementar a função wrapper runOnce, que aceita * uma função e devolve uma nova função. A nova * função só pode ser chamada uma vez, todas as chamadas * subsequentes retornam undefined. * * A função envolvida pode aceitar argumentos * e retornar um resultado. */ function runOnce(fn) { // o seu código } const logHello = (name) => { console.log(`olá, ${name}!`) }; const logHelloOnce = runOnce(logHello); console.clear(); logHelloOnce('Oleg'); // 'olá, Oleg!' logHelloOnce('Olga'); // undefined
/** * Implementar a função sumPromises, que aceita * promessas como argumentos e retorna a soma * dos seus resultados. * * A função pode aceitar qualquer quantidade de argumentos. * Pode usar qualquer API de promessas. */ // Código aqui // Exemplo de uso const promise1 = Promise.resolve(1); const promise2 = Promise.resolve(2); sumPromises(promise1, promise2).then(console.log); // 3
Existem problemas ao adicionar novos métodos aos protótipos de objetos incorporados?
[nome] perguntou: Quanto tempo levou a implementação da versão MVP do leitor?
/** * São dadas três secções de código. É necessário escrever o resultado de cada console.log. */ var n = 1; function F(n) { n = 3; } F(n); console.log(n); var obj = { a: 1 }; function F1(o) { o.a = 5; } F1(obj); console.log(obj); var obj = { a: 1 }; function F2(o) { o = { hello: 1 }; } F2(obj); console.log(obj);
/** * A função `asyncAuth(callback)` aceita um callback, no qual podem ser * passados um erro (como primeiro argumento) e dados * do backend (como segundo argumento). * asyncAuth((error, data) => {}); * * Precisa implementar a função `auth()`, * que chama `asyncAuth()`, mas retorna uma Promise. * * @returns {Promise} */ function auth() { return new Promise((resolve, reject) => { asyncAuth((error, data) => { if (error) { reject(error) } else { resolve(data) } }); }) } /** * A função `tryAuth()` usa `auth()` e, em caso de erro, * realiza N tentativas adicionais. * Se todas falharem, devolve o último erro. * * @returns {Promise} */ function tryAuth(n) { }
Como transformar arguments em um array à antiga (ES5), sem Array.from e spread-operator?
Que novidades do padrão ES6 são usadas no código escrito? O que é o objeto arguments e como ele difere dos parâmetros rest?
Pode falar sobre as abordagens arquitetónicas que utilizou no projeto? Está familiarizado com o Feature-Sliced Design (FSD)?
[nome] perguntou: Já trabalhou na otimização de métricas de velocidade de serviços?
[nome] perguntou: Já escreveu algum trabalho adicional na pipeline por si próprio?
Implementar a função withTimeout, que aceita uma função e um tempo (milissegundos) e retorna uma nova função. Se a função original não for executada dentro do tempo definido, a promessa deve ser rejeitada.
[nome] perguntou: Como era geralmente organizado o trabalho numa tarefa específica: quem a trazia e a preparava, como era o processo de aprovação, que questões surgiam durante a implementação, e como as resolviam?
/** * A função `asyncAuth(callback)` aceita um callback, no qual * pode ser passada uma erro (como primeiro argumento) e dados * do backend (como segundo argumento). * asyncAuth((error, data) => {}); * * Precisa implementar a função `auth()`, * que chama `asyncAuth()`, mas retorna uma Promise. * * @returns {Promise} */ function auth() { // asyncAuth((error, data) => {}); } /** * A função `tryAuth()` usa `auth()` e, em caso de erro, * realiza N tentativas adicionais. * Se todas falharem, retorna o último erro. * * @returns {Promise} */ function tryAuth(n) { }
Implemente a função asyncAuth com uma interface de callback que retorna uma Promessa. Depois, implemente a função tryAuth(n), que usa asyncAuth e, em caso de erro, faz n tentativas adicionais. Se todas as tentativas falharem, retorna o último erro.
O que acontece se o timeout não for limpo após a execução bem-sucedida da função? Como corrigir isso e qual método de promessa seria adequado para limpar o timeout em qualquer caso (sucesso e erro)?
