├── 2020-01-13-spreadoperator.js ├── 2020-01-14-concatvariables.js ├── 2020-01-16-destructuringobject.js ├── 2020-01-20-varscope.js ├── 2020-01-21-restoperator.js ├── 2020-01-22-setobject.js ├── 2020-01-25-objectfreeze.js ├── 2020-01-28-eventemitter.js ├── 2020-02-02-defaultvalueparam.js ├── 2020-02-13-map.js ├── 2020-02-14-filter.js ├── 2020-02-16-reduce.js ├── 2020-02-17-console.js ├── 2020-02-18-JSONstringify.js ├── 2020-02-21-in.js ├── 2020-02-23-every.js ├── 2020-02-24-RegExp.js ├── 2020-02-25-fill.js ├── 2020-02-26-arraymaxmin.js ├── 2020-02-27-dynamicobject.js ├── 2020-02-28-slicingwithlength.js ├── 2020-02-29-uniquesortedarray.js ├── 2020-03-01-capitalizeallwords.js ├── 2020-03-03-splice.js ├── 2020-03-04-floorwithor.js ├── 2020-03-06-includes.js ├── 2020-03-08-forofwomen.js ├── 2020-03-09-flat.js ├── 2020-03-10-callandapply.js ├── 2020-03-11-operator===.js ├── 2020-03-14-arrayscontains.js ├── 2020-03-15-arrowfunction.js ├── 2020-03-17-some.js ├── 2020-03-18-readFileSync-writeFileSync.js ├── 2020-03-19-trycatch.js ├── 2020-03-22-fillintervalarray.js ├── 2020-04-06-whitespaceremove.js ├── 2020-04-09-removelastchar.js ├── 2020-04-26-selectrandomitemarray.js ├── 2020-06-17-functiondeclarationandexpression.js ├── 2020-12-27-compareobjects.js └── 2021-01-29-consoledir.js /2020-01-13-spreadoperator.js: -------------------------------------------------------------------------------- 1 | /* 2 | Com Spread Operator é possível agregar objetos/arrays existentes em 3 | outros de forma simples e elegante. 4 | */ 5 | 6 | let someData = { 7 | stadium: 'Santiago Bernabéu', 8 | coach: 'Zinedine Zidane' 9 | } 10 | 11 | let realMadrid = { 12 | name: 'Real Madrid', 13 | founded: 1902, 14 | ...someData //... Spread Operator 15 | } 16 | 17 | console.log(realMadrid) 18 | 19 | let someAnimals = ['Monkey', 'Lion', 'Elephant'] 20 | 21 | let allAnimals = ['Hyena', 'Zebra', 'Cheetah', ...someAnimals] //... Spread Operator 22 | 23 | console.log(allAnimals) -------------------------------------------------------------------------------- /2020-01-14-concatvariables.js: -------------------------------------------------------------------------------- 1 | /* Algumas formas de concatenar variáveis. */ 2 | 3 | let tv = { 4 | manufacturer: 'Samsung', 5 | model: '43RU7100', 6 | display: 'LED', 7 | resolution: '4K 3840 x 2160' 8 | } 9 | 10 | let description 11 | 12 | //1 - Concatenando variáveis utilizando sinal de + 13 | description = '1 - A Smart TV ' + tv.display + ' ' + tv.manufacturer + ' ' + 14 | tv.model + ' conta com a resolução ' + tv.resolution 15 | console.log(description) 16 | 17 | //2 - Concatenando variáveis utilizando a função concat() 18 | description = '2 - A Smart TV '.concat(tv.display, ' ', tv.manufacturer, ' ', 19 | tv.model, ' conta com a resolução ', tv.resolution) 20 | console.log(description) 21 | 22 | //3 - Concatenando variáveis utilizando acentos graves 23 | description = `3 - A Smart TV ${tv.display} ${tv.manufacturer} ${tv.model} \ 24 | conta com a resolução ${tv.resolution}` 25 | console.log(description) 26 | -------------------------------------------------------------------------------- /2020-01-16-destructuringobject.js: -------------------------------------------------------------------------------- 1 | /* 2 | Destructuring ou desestruturação é uma feature bacana do ES6. Com ela, 3 | recuperamos dados de objetos/vetores de forma tranquila e elegante, mantendo o 4 | código enxuto e legível. 5 | */ 6 | 7 | const estate = { 8 | address: 'Rua Simon Bolivar, 100', 9 | type: 'Casa', 10 | price: 1500, 11 | description: '3 Quartos, Sala ampla, 2 Banheiros, Quintal', 12 | estate_agency: { 13 | name: 'Adjuve Imóveis e Condomínios', 14 | phone: '+55 24 2249-9000', 15 | } 16 | } 17 | 18 | //Criando a variável description com o conteúdo de estate.description 19 | let { description } = estate 20 | console.log(description) 21 | 22 | //Criando a variável name com o conteúdo de estate.estate_agency.name 23 | let { estate_agency: { name } } = estate 24 | console.log(name) 25 | 26 | // Usando desestruturação com função 27 | function showPrice({ price }) { 28 | console.log(price); 29 | } 30 | showPrice(estate); 31 | 32 | // Usando desestruturação com vetor 33 | const states = ['Rio de Janeiro', 'São Paulo', 'Minas Gerais'] 34 | let [RJ, SP, MG] = states 35 | console.log(RJ) 36 | -------------------------------------------------------------------------------- /2020-01-20-varscope.js: -------------------------------------------------------------------------------- 1 | /* 2 | Declarou 𝘷𝘢𝘳 e teve problemas com escopo? Use 𝘭𝘦𝘵 para que funcione de 3 | forma esperada. A declaração 𝘤𝘰𝘯𝘴𝘵 funciona de forma semelhante ao 𝘭𝘦𝘵, 4 | mas não permite reatribuição de valor, a menos que a modificação seja feita 5 | no atributo de um objeto. 6 | */ 7 | 8 | if (true) { var x = 10 } 9 | console.log(x) // 10 10 | 11 | if (true) { let y = 10 } 12 | // y só existe dentro do escopo da estrutura condicional acima (if) 13 | console.log(y) // Undefined 14 | 15 | for (var i=3; i>0; i--) { /* Do Something... */ } 16 | console.log(i) // 0 17 | 18 | for (let j=3; j>0; j--) { /* Do Something... */ } 19 | // j só existe dentro do escopo da estrutura de repetição acima (for) 20 | console.log(j) // Undefined 21 | 22 | const person = { 23 | name: 'Julio', 24 | email: 'jbernardorj@gmail.com', 25 | linkedin: 'https://www.linkedin.com/in/julio-bernardo/', 26 | github: 'https://github.com/jbdevelop', 27 | } 28 | //Variáveis constantes (const) não permitem alteração, reatribuição de valor 29 | //person = 'João Paulo' // TypeError: Assignment to constant variable 30 | 31 | //Entretanto, atributos de objetos podem ser alterados 32 | person.name = 'Julio Bernardo' //Funciona! Atributos de objetos sofrem mutação 33 | console.log(person) 34 | -------------------------------------------------------------------------------- /2020-01-21-restoperator.js: -------------------------------------------------------------------------------- 1 | /* 𝘙𝘦𝘴𝘵 𝘖𝘱𝘦𝘳𝘢𝘵𝘰𝘳 são utilizados no fim da assinatura de uma função para 2 | receber um conjunto de argumentos passados (resto). Podem ser utilizados 3 | também em vetores. */ 4 | 5 | function sortRestOperator(one, two, ...numbers) { // ...numbers Rest Param 6 | // one = 4, two = 8, ...numbers = 9, 7, 1, 5, 3 (resto) 7 | return numbers.sort() 8 | } 9 | 10 | let sorted = sortRestOperator(4, 8, 9, 7, 1, 5, 3) 11 | console.log(sorted) 12 | 13 | const numbers = [4, 8, 0, 6, 2] 14 | 15 | let [one, two, ...rest] = numbers //...rest Rest Operator 16 | console.log(rest) 17 | -------------------------------------------------------------------------------- /2020-01-22-setobject.js: -------------------------------------------------------------------------------- 1 | /* 2 | O objeto 𝘚𝘦𝘵 permite armazenamento de valores únicos de qualquer tipo de dado 3 | em seu conjunto. Podemos iniciá-lo vazio ou com algum valor diretamente através 4 | do construtor. 5 | */ 6 | 7 | let any = new Set() //Iniciando Set vazio 8 | 9 | let integer = new Set([1,2,3]) // Iniciando Set com valores (construtor) 10 | 11 | any.add('Coronavirus') 12 | any.add(911) 13 | any.add('Trump Impeachment') 14 | any.add(911) // 911 não adicionado, valores únicos 15 | console.log(any) // Set { 'Coronavirus', 911, 'Trump Impeachment' } 16 | 17 | console.log(any.has('Coronavirus')) // True 18 | 19 | any.delete('Coronavirus') 20 | console.log(any.has('Coronavirus')) // False 21 | 22 | console.log(any.size) // 2 23 | 24 | console.log(any) // Set { 911, 'Trump Impeachment' } 25 | -------------------------------------------------------------------------------- /2020-01-25-objectfreeze.js: -------------------------------------------------------------------------------- 1 | /* 2 | O método 𝘖𝘣𝘫𝘦𝘤𝘵.𝘧𝘳𝘦𝘦𝘻𝘦() 'congela' o objeto dado, não permitindo mais a 3 | adição/remoção de atributos/valores do objeto em questão. Se algum atributo 4 | representar outro objeto, .𝘧𝘳𝘦𝘦𝘻𝘦() não irá proteger essa camada. Para isto, 5 | temos que congelar também o atributo/objeto. 6 | */ 7 | 8 | const car = { 9 | name: 'Bugatti', 10 | headquarters: 'Molsheim, France', 11 | group: { 12 | name: 'Volkswagen', 13 | headquarters: 'Wolfsburg, Germany', 14 | founded: 1937 15 | }, 16 | model: 'La Voiture Noire', 17 | price: '$18,700,000', 18 | engine: '8.0L Quad Turbocharged W16', 19 | transmission: '7-Speed Dual-Clutch', 20 | hp: 1500 21 | } 22 | 23 | Object.freeze(car) // Mutação superficial de atributos não permitida 24 | 25 | car.name = 'Ferrari' // Não alterou o atributo name e ficou em silêncio 26 | console.log(car.name) // Bugatti 27 | 28 | // Object.freeze() é raso, não 'congela' ramificações de objetos 29 | car.group.founded = 2019 // Alterou atributo founded (Mutação profunda) 30 | console.log(car.group.founded) // 2019 31 | 32 | Object.freeze(car.group) // Agora sim, objeto group congelado 33 | 34 | car.group.founded = 1937 // Não alterou o atributo founded, está congelado 35 | console.log(car.group.founded) // 2019 36 | 37 | delete car.name // Nada acontece. Objeto congelado = atributo protegido. 38 | 39 | console.log(Object.isFrozen(car)) // True 40 | -------------------------------------------------------------------------------- /2020-01-28-eventemitter.js: -------------------------------------------------------------------------------- 1 | const { EventEmitter } = require('events') 2 | 3 | /* 4 | Que tal criar eventos personalizados com o módulo 𝘦𝘷𝘦𝘯𝘵𝘴 em Node.js? 5 | Neste exemplo, vamos imaginar um log básico de segurança onde há uma 6 | reação - 𝘤𝘰𝘯𝘴𝘰𝘭𝘦.𝘭𝘰𝘨 do evento ouvinte - 𝘦𝘷𝘦𝘯𝘵.𝘰𝘯('𝘴𝘦𝘤𝘶𝘳𝘪𝘵𝘺_𝘭𝘰𝘨', ...) quando 7 | invocado pelo evento emissor - 𝘦𝘷𝘦𝘯𝘵.𝘦𝘮𝘪𝘵('𝘴𝘦𝘤𝘶𝘳𝘪𝘵𝘺_𝘭𝘰𝘨', ...). 8 | */ 9 | 10 | const event = new EventEmitter() 11 | 12 | event.on('security_log', (user, action, date) => { // Ouvinte (Listener) 13 | console.log(`Log de Segurança: ${user} - ${action} - ${date}`) 14 | }) 15 | 16 | event.emit('security_log', 'admin', 'Alterou usuário', new Date()) // Emissor (Emitter) 17 | -------------------------------------------------------------------------------- /2020-02-02-defaultvalueparam.js: -------------------------------------------------------------------------------- 1 | /* 2 | A partir do ES6 é permitido definir valor padrão em parâmetros da 3 | assinatura de uma função. 4 | */ 5 | 6 | function rootSquare(n = 25) { 7 | const calc = Math.sqrt(n) 8 | console.log(calc) 9 | } 10 | 11 | rootSquare() 12 | -------------------------------------------------------------------------------- /2020-02-13-map.js: -------------------------------------------------------------------------------- 1 | /* 2 | A função 𝘮𝘢𝘱() mapeia todos os elementos de um vetor. A cada iteração, 3 | 𝘮𝘢𝘱 chama uma 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬 a fim de realizar algo e por fim devolve o resultado 4 | em um novo vetor. Neste exemplo, o resultado é a potência de 2 de cada elemento. 5 | */ 6 | 7 | const numbers = [2, 3, 5] 8 | 9 | const pow = numbers.map( n => Math.pow(n, 2) ) 10 | 11 | console.log(pow) 12 | -------------------------------------------------------------------------------- /2020-02-14-filter.js: -------------------------------------------------------------------------------- 1 | /* 2 | A função 𝘧𝘪𝘭𝘵𝘦𝘳() percorre um vetor chamando uma 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬 a cada iteração, 3 | que realiza um teste lógico para cada elemento. O resultado é um 4 | novo vetor filtrado. Neste exemplo, "reza a lenda" que o vetor resultado 5 | corresponde aos salários de Dev Jr em variadas empresas a partir de 2020. 6 | */ 7 | 8 | const salary = [3500.00, 8000.00, 1300.00, 5250.00, 9375.00, 8000.00] 9 | .filter( s => s > 4000.00 ) 10 | 11 | console.log(salary) 12 | -------------------------------------------------------------------------------- /2020-02-16-reduce.js: -------------------------------------------------------------------------------- 1 | /* 2 | A função 𝘳𝘦𝘥𝘶𝘤𝘦() percorre um vetor da esquerda para direita invocando uma 3 | 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬 para realizar uma ação a cada iteração de elemento. Possui 2 parâmetros 4 | de assinatura (𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬, 𝘪𝘯𝘪𝘵𝘪𝘢𝘭𝘝𝘢𝘭𝘶𝘦) e a 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬 por sua vez assina 4 parâmetros 5 | (𝘢𝘤𝘤𝘶𝘮𝘶𝘭𝘢𝘵𝘰𝘳, 𝘤𝘶𝘳𝘳𝘦𝘯𝘵𝘝𝘢𝘭𝘶𝘦, 𝘤𝘶𝘳𝘳𝘦𝘯𝘵𝘐𝘯𝘥𝘦𝘹, 𝘢𝘳𝘳𝘢𝘺). Se for definido 𝘪𝘯𝘪𝘵𝘪𝘢𝘭𝘝𝘢𝘭𝘶𝘦 em 𝘳𝘦𝘥𝘶𝘤𝘦(), o 6 | parâmetro 𝘢𝘤𝘤𝘶𝘮𝘶𝘭𝘢𝘵𝘰𝘳 da 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬 receberá esse valor e iniciará com ele. O valor de 7 | retorno da 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬 é atribuído ao 𝘢𝘤𝘤𝘶𝘮𝘶𝘭𝘢𝘵𝘰𝘳 a cada iteração. O objetivo é a 8 | redução do vetor num valor único de retorno (exemplo 1), mas veremos um pouco 9 | além (exemplo 2). 10 | */ 11 | 12 | // Exemplo 1 - Subtração de todos os elementos do vetor, da esquerda para direita: 13 | const numbers = [200, 50, 20, 30] 14 | const result = numbers.reduce((accum, currentValue) => { 15 | 16 | return accum - currentValue 17 | }) 18 | console.log(result) // 200 - 50 - 20 - 30 = 100 19 | 20 | // Exemplo 2 - Contagem de tags iguais no vetor, retornado um objeto com os cálculos realizados: 21 | const tags = [ 22 | '#love', '#love', '#fashion', '#followme','#love', '#followme', '#love', 23 | '#fashion', '#love', '#followme', '#love' 24 | ] 25 | const countedTags = tags.reduce( (allTags, tag) => { 26 | if (tag in allTags) 27 | allTags[tag]++ 28 | else 29 | allTags[tag] = 1 30 | 31 | return allTags 32 | }, {}); //Valor inicial é um objeto vazio {} 33 | 34 | console.log(countedTags) // { '#love': 6, '#fashion': 2, '#followme': 3 } 35 | -------------------------------------------------------------------------------- /2020-02-17-console.js: -------------------------------------------------------------------------------- 1 | console.table(['Avatar', 'Titanic', 'LOR - The Return Of The King']) // Dados de saída tabelados 2 | 3 | //Iniciando o cálculo do custo de uma tarefa 4 | console.time('time') 5 | let count = 0 6 | while(count < 9999) count++ 7 | // Finalizando o cálculo do custo de uma tarefa 8 | console.timeEnd('time') // time: 0.208ms 9 | 10 | console.warn('Warning: The function is deprecated.') // Saída no console em formato de alerta 11 | 12 | console.error('Error: Undefined index') // Saída no console em formato de erro 13 | 14 | //console.count mostra o número de vezes que foi chamado 15 | console.count('count') // count: 1 16 | console.count('count') // count: 2 17 | console.count() // default: 1 18 | console.count('count') // count: 3 19 | console.count() // default: 2 20 | console.countReset('count') // Resetando a contagem para 'count' 21 | console.count('count') // count: 1 22 | 23 | console.clear() // Limpa o console -------------------------------------------------------------------------------- /2020-02-18-JSONstringify.js: -------------------------------------------------------------------------------- 1 | /* 2 | 𝘑𝘚𝘖𝘕.𝘴𝘵𝘳𝘪𝘯𝘨𝘪𝘧𝘺() é um metodo que converte objetos Javascript para o formato 3 | 𝘑𝘚𝘖𝘕 𝘴𝘵𝘳𝘪𝘯𝘨. Pode receber uma 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬 ou 𝘢𝘳𝘳𝘢𝘺 normalmente usados para 4 | substituição/manipulação de conteúdo do objeto. No exemplo da 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬, 5 | a ideia é identificar os tipos de valores do objeto 𝘪𝘯𝘴𝘦𝘤𝘵 e armazená-los em 𝘵𝘺𝘱𝘦𝘴. 6 | */ 7 | 8 | const animal = { 9 | commonName: 'Aranha-marrom', 10 | scientificName: 'Loxosceles', 11 | class: 'Aracnídeo', 12 | length: '3cm', 13 | eyes: 6, 14 | venomous: true, 15 | } 16 | 17 | console.log(JSON.stringify(animal)) 18 | 19 | 20 | let types = {} 21 | 22 | const checkBoolean = JSON.stringify(animal, (key, value) => { 23 | types[key] = typeof value //armazenando no objeto types os tipos de valores de animal 24 | 25 | return value 26 | }) 27 | 28 | console.log(types) 29 | 30 | 31 | console.log(JSON.stringify(animal, ['commonName', 'class'])) 32 | -------------------------------------------------------------------------------- /2020-02-21-in.js: -------------------------------------------------------------------------------- 1 | const sponsor = { name: 'Nestlé.', founded: 1866, slogan: 'Good Food, Good Life.' } 2 | 3 | const sponsors = ['Nike', 'ELetrobrás', 'Coca-Cola'] 4 | 5 | console.log('slogan' in sponsor) // true 6 | 7 | delete sponsor.slogan 8 | 9 | console.log('slogan' in sponsor) // false 10 | 11 | sponsors[0] = undefined 12 | 13 | console.log(0 in sponsors) // true 14 | -------------------------------------------------------------------------------- /2020-02-23-every.js: -------------------------------------------------------------------------------- 1 | /* 2 | O método 𝘦𝘷𝘦𝘳𝘺 testa cada elemento do vetor a partir de uma 𝘤𝘢𝘭𝘭𝘣𝘢𝘤𝘬 e retorna um 3 | 𝘣𝘰𝘰𝘭𝘦𝘢𝘯. Se um desses testes for falso, 𝘦𝘷𝘦𝘳𝘺 vai parar, não verificará os valores 4 | restantes do vetor e vai retornar 𝘧𝘢𝘭𝘴𝘦. 5 | Este exemplo simples verifica se todos os números são divisíveis por 2. 6 | */ 7 | 8 | const numbers = [2, 10, 22, 76, 8, 16] 9 | 10 | const divisibleBy = numbers.every( value => value % 2 === 0 ) 11 | 12 | console.log(divisibleBy) // true -------------------------------------------------------------------------------- /2020-02-24-RegExp.js: -------------------------------------------------------------------------------- 1 | /* 2 | Uma 𝘙𝘦𝘨𝘶𝘭𝘢𝘳 𝘌𝘹𝘱𝘳𝘦𝘴𝘴𝘪𝘰𝘯 (𝘙𝘦𝘨𝘦𝘹) ou Expressão Regular é formada por uma sequência de 3 | caracteres para se obter um padrão de busca. Podemos utilizar esse padrão para 4 | pesquisá-lo numa determinada 𝘴𝘵𝘳𝘪𝘯𝘨 e se necessário, fazer uma manipulação de 5 | texto. Expressões regulares em conjunto com os métodos previstos se tornam 6 | extremamente poderosos para manipulação de 𝘴𝘵𝘳𝘪𝘯𝘨𝘴. Os exemplos são simples e 7 | incentivadores para um estudo mais aprofundado da documentação, de modo que se 8 | aproveite o melhor dessa ferramenta. 9 | */ 10 | 11 | //1a FORMA - através de Expressões Literais 12 | const literal = /node/ig.test( 13 | 'Backend é com Node.js, Frontend é com React, Mobile é com React Native.' 14 | ) 15 | /* 16 | /padrão/ - O padrão inserido entre duas barras comuns caracteriza-o como Expressão Literal 17 | /node/ - a palavra node é o padrão a ser buscado. 18 | i - ignora case-sensitive 19 | g - Percorre por completo a string, não parando na primeira ocorrência encontrada 20 | .test - Testa correspondência em uma string 21 | */ 22 | console.log(literal) //true 23 | 24 | 25 | //2a FORMA - através do construtor do objeto RegExp 26 | let constructor = new RegExp("\\s","g") 27 | /* 28 | Onde: 29 | \s - Encontra espaços em branco, tabulação, avanço de página... 30 | g - Percorre por completo a string, não parando na primeira ocorrência encontrada 31 | */ 32 | 33 | let backend = 'Node.js, PHP, Ruby' 34 | 35 | backend = backend.replace(constructor, '') // Substitui constructor por '' na string backend 36 | 37 | console.log(backend) // Node.js,PHP,Ruby 38 | -------------------------------------------------------------------------------- /2020-02-25-fill.js: -------------------------------------------------------------------------------- 1 | /* 2 | Você já precisou preencher parte ou completamente um vetor com 3 | um valor estático? Com o método fill, veremos que isto é mais fácil que parece. 4 | Agradecimento ao Mauro Simoes por colaborar nos estudos deste método. 5 | */ 6 | 7 | const bestComposers = ['Bach', 'Chopin', 'Beethoven', 'Haydn', 'Vivaldi'] 8 | 9 | // Substitui todos os elementos do vetor por 'Mozart' 10 | console.log(bestComposers.fill('Mozart')) // [ 'Mozart', 'Mozart', 'Mozart', 'Mozart', 'Mozart' ] 11 | 12 | // A partir do índice 1, substitui todos os elementos do vetor por 'Paganini' 13 | console.log(bestComposers.fill('Paganini', 1)) // [ 'Mozart', 'Paganini', 'Paganini', 'Paganini', 'Paganini' ] 14 | 15 | // Substitui apenas o elemento do índice 2 do vetor por 'Liszt' 16 | console.log(bestComposers.fill('Liszt', 2, 3)) // [ 'Mozart', 'Paganini', 'Liszt', 'Paganini', 'Paganini' ] 17 | 18 | // Substitui os elementos do índice 3 e 4 do vetor por 'Pachelbel' 19 | console.log(bestComposers.fill('Pachelbel', 3, 5)) // [ 'Mozart', 'Paganini', 'Liszt', 'Pachelbel', 'Pachelbel' ] 20 | 21 | // Substitui apenas o elemento do índice 4 do vetor por 'Salieri' 22 | console.log(bestComposers.fill('Salieri', -1, 5)) // [ 'Mozart', 'Paganini', 'Liszt', 'Pachelbel', 'Salieri' ] 23 | /* 24 | Se o valor for negativo, será tratado como array.length + valor negativo 25 | ou seja: + 5 - 1 = 4. Então, o fill na verdade representa: fill('Salieri', 4, 5) 26 | */ 27 | -------------------------------------------------------------------------------- /2020-02-26-arraymaxmin.js: -------------------------------------------------------------------------------- 1 | /* 2 | Como retornar o maior e menor número de um vetor? As funções 3 | Math.max() e Math.min() retornam o maior e menor números dentre a lista de 4 | argumentos passada, mas naturalmente, vão falhar (NaN) se passarmos diretamente 5 | um vetor como argumento para essas funções. Podemos contornar isto de uma forma 6 | prática, vamos ver? 7 | */ 8 | 9 | const numbers = [2, 4, 12, 1] 10 | 11 | //Spread 12 | console.log(Math.max(...numbers)) // 12 13 | console.log(Math.min(...numbers)) // 1 14 | 15 | //apply() method 16 | console.log(Math.max.apply(null, numbers)) // 12 17 | console.log(Math.min.apply(null, numbers)) // 1 18 | 19 | /* 20 | abaixo, o valor inicial (n1) assume numbers[0] (2) 21 | e o valor atual (n2) assume numbers[1] (4) e assim por diante 22 | */ 23 | 24 | //reduce() method 25 | const max = numbers.reduce( (n1, n2) => Math.max(n1, n2) ) 26 | console.log(max) // 12 -------------------------------------------------------------------------------- /2020-02-27-dynamicobject.js: -------------------------------------------------------------------------------- 1 | /* 2 | # Fast Tip # 3 | # Propriedade dinâmica em Objeto Javascript # 4 | */ 5 | 6 | const dynamic = 'kills' 7 | 8 | const character = { 9 | name: 'John Wick', 10 | [dynamic]: 0, 11 | } 12 | 13 | console.log(character) // { name: 'John Wick', kills: 0 } 14 | 15 | character.kills = 299 16 | 17 | console.log(character) // { name: 'John Wick', kills: 299 } 18 | -------------------------------------------------------------------------------- /2020-02-28-slicingwithlength.js: -------------------------------------------------------------------------------- 1 | /* 2 | # Fast Tip # 3 | # Slicing com array.length # 4 | */ 5 | 6 | let so = ['Linux', 'MacOS', 'Windows', 'MS-DOS', 'Solaris'] 7 | 8 | so.length = 3 9 | 10 | console.log(so) // ['Linux', 'MacOS', 'Windows'] 11 | -------------------------------------------------------------------------------- /2020-02-29-uniquesortedarray.js: -------------------------------------------------------------------------------- 1 | /* 2 | # Fast Tip # 3 | # Vetor com valores numéricos únicos ordenado # 4 | */ 5 | 6 | const numbers = [1, 3, 3, 2, 1, 5, 4, 4, 5] 7 | 8 | // O Set aceita apenas valores únicos em sua coleção 9 | const uniques = [...new Set(numbers)] // [1, 3, 2, 5, 4] 10 | 11 | // Ordenação crescente 12 | uniques.sort((n1, n2) => n1 - n2) // [1, 2, 3, 4, 5] -------------------------------------------------------------------------------- /2020-03-01-capitalizeallwords.js: -------------------------------------------------------------------------------- 1 | /* 2 | # Fast Tip # 3 | # Capitalize em todas as palavras da String # 4 | */ 5 | 6 | const str = 'buscando novas oportunidades' 7 | 8 | const result = str.split(' ') 9 | .map(word => `${word[0].toUpperCase()}${word.slice(1)}`) 10 | .join(' ') 11 | 12 | console.log(result) 13 | 14 | /* 15 | Linhas: 16 | 3 - Transforma a string em array de strings 17 | 4 - Percorre os elementos da array, retornando o 18 | primeiro caractere maiúsculo + o restante da palavra. Ex.: B + uscando 19 | 5 - Junta os elementos da array e retorna numa string 20 | */ -------------------------------------------------------------------------------- /2020-03-03-splice.js: -------------------------------------------------------------------------------- 1 | /* 2 | O método splice() permite inserir e/ou remover elementos no vetor a partir do 3 | índice dado. Age sobre o vetor original e retorna os elementos excluídos. 4 | Parâmetros: 5 | 𝘀𝘁𝗮𝗿𝘁 - Em qual ou a partir de qual índice deverá agir. 6 | 𝗱𝗲𝗹𝗲𝘁𝗲𝗖𝗼𝘂𝗻𝘁 - número inteiro que indica quantos elementos devem ser excluídos. 7 | Se omitido ou se o número indicado for maior que a quantidade de elementos 8 | existentes no vetor, então todos os elementos a partir de 𝘀𝘁𝗮𝗿𝘁 serão removidos. 9 | 𝗶𝘁𝗲𝗺𝟭, 𝗶𝘁𝗲𝗺𝟮, ... - Elementos a serem adicionados na lista. Se omitido, 10 | splice() apenas removerá elementos. 11 | */ 12 | 13 | const numbers = [1, 7] 14 | 15 | const n = numbers.slice() 16 | 17 | //A partir do índice 1, insere 2,3,3,5,6 no vetor. Remove 0 elementos. 18 | const removed1 = n.splice(1, 0, 2, 3, 3, 5, 6) 19 | 20 | console.log(removed1) // [] 21 | 22 | console.log(numbers) // [ 1, 2, 3, 3, 5, 6, 7 ]  23 | 24 | //Remove 1 elemento do índice 3 e insere 4 25 | const removed2 = n.splice(3, 1, 4) 26 | 27 | console.log(removed2) // [ 3 ] 28 | 29 | console.log(numbers) // [ 1, 2, 3, 4, 5, 6, 7 ] -------------------------------------------------------------------------------- /2020-03-04-floorwithor.js: -------------------------------------------------------------------------------- 1 | console.log(8 | 13) // 13 2 | /* Operador bit-a-bit | (OR) 3 | 8 na base 2 - 1|0|0|0 4 | 13 na base 2 - 1|1|0|1 5 | ------- 6 | Resultado de 8 | 13 - 1|1|0|1 7 | Porém, o resultado é em decimal, ou seja, 13. 8 | */ 9 | 10 | /* 11 | Se pensarmos bem, podemos usar | para fazer o arrendodamento para baixo, 12 | caso utilizemos sempre 0 como comparativo. 13 | */ 14 | console.log(8.5 | 0) // 8 15 | /* 16 | 8 na base 2 - 1|0|0|0 .1 (a conversão e feita para inteiro 32 bits) 17 | 0 na base 2 - | | |0 18 | ------- 19 | Resultado de 8.5 | 0 - 1|0|0|0 20 | Porém, o resultado é em decimal, ou seja, 8. 21 | */ 22 | 23 | console.log(-12.32 | 0) // -12 24 | /* 25 | -12 na base 2 - - 1|1|0|0 .010100... (a conversão e feita para inteiro 32 bits) 26 | 0 na base 2 - | | |0 27 | ------- 28 | Resultado de -12.32 | 0 - 1|1|0|0 29 | Porém, o resultado é em decimal, ou seja, -12. 30 | */ -------------------------------------------------------------------------------- /2020-03-06-includes.js: -------------------------------------------------------------------------------- 1 | /* 2 | O método includes() procura elementos dentro de um vetor e retorna true ou false, adequadamente. 3 | Parâmetros: 4 | 𝘀𝗲𝗮𝗿𝗰𝗵𝗘𝗹𝗲𝗺𝗲𝗻𝘁 - O elemento a ser encontrado 5 | 𝗳𝗿𝗼𝗺𝗜𝗻𝗱𝗲𝘅 - Opcional. A posição do array que iniciará a busca. 6 | */ 7 | 8 | function checkCarAvailable(car, startIndex = 0) { 9 | const carGroup = ['Versa', 'Polo', 'Sandero'] 10 | 11 | return carGroup.includes(car, startIndex) 12 | ? `O carro ${car} está DISPONÍVEL para aluguel.` 13 | : `O carro ${car} está INDISPONÍVEL no momento.` 14 | } 15 | 16 | console.log(checkCarAvailable('BMW')) // false - O carro BMW está INDISPONÍVEL no momento. 17 | 18 | console.log(checkCarAvailable('Polo', 3)) // false - O carro Polo está INDISPONÍVEL no momento. 19 | 20 | console.log(checkCarAvailable('Versa')) // true - O carro Versa está DISPONÍVEL para aluguel. 21 | -------------------------------------------------------------------------------- /2020-03-08-forofwomen.js: -------------------------------------------------------------------------------- 1 | /* 2 | # Fast Tip # 3 | # for...of # 4 | 5 | Para todas as mulheres, 6 | um Feliz dia Internacional da Mulher! 7 | */ 8 | 9 | const women = [ 10 | ['Amor', true], ['Carinho', true], ['Respeito', true], ['Justiça', true], 11 | ['Felicidade', true], ['Dedicação', true], ['Bondade', true], 12 | ['Virtude', true], ['Garra', true], ['Força', true], 13 | ['Preconceito', false], ['Violência', false], ['Desigualdade', false], 14 | ['Assédio', false], ['Machismo', false] 15 | ] 16 | 17 | let aux = true 18 | console.log('MULHERES representam:') 19 | for (const [key, value] of Object.entries(women)) { 20 | if (value[1]) { 21 | console.log(`#${value[0]}`) 22 | } else { 23 | if (aux) { 24 | console.log('\nDiga NÃO ao:') 25 | aux = false 26 | } 27 | console.log(`#${value[0]}`) 28 | } 29 | } 30 | console.log('contra as MULHERES.') 31 | 32 | /* 33 | MULHERES representam: 34 | #Amor 35 | #Carinho 36 | #Respeito 37 | #Justiça 38 | #Felicidade 39 | #Dedicação 40 | #Bondade 41 | #Virtude 42 | #Garra 43 | #Força 44 | 45 | Diga NÃO ao: 46 | #Preconceito 47 | #Violência 48 | #Desigualdade 49 | #Assédio 50 | #Machismo 51 | contra as MULHERES. 52 | */ -------------------------------------------------------------------------------- /2020-03-09-flat.js: -------------------------------------------------------------------------------- 1 | /* 2 | A função flat() achata e retorna um novo vetor com os subvetores 3 | concatenados nele. Utilizamos o parâmetro depth (default 1) para atingir 4 | a profundidade desejada. 5 | */ 6 | 7 | const array1 = [1, [2, 3], [4, 5]] 8 | array1.flat() // [1, 2, 3, 4, 5] - flat() é o mesmo que flat(1) 9 | 10 | const array2 = [1, [[]], 2, , 3, null, ''] 11 | // flat() remove espaços ou vetores vazios, mas não remove null ou '' 12 | array2.flat(2) // [1, 2, 3, null, ''] 13 | 14 | const array3 = [1, [2, [3, 4, [5]]]] 15 | //Infinity achata até que o vetor tenha 1 dimensão 16 | array3.flat(Infinity) // [1, 2, 3, 4, 5] -------------------------------------------------------------------------------- /2020-03-10-callandapply.js: -------------------------------------------------------------------------------- 1 | /*As funções apply() e call() são similares. A diferença está na assinatura 2 | dos métodos, onde call aceita uma lista de argumentos e apply uma array 3 | de argumentos: 4 | call(thisArg, arg1, arg2, ...) 5 | apply(thisArg, [args]) 6 | 7 | Ambas determinam o contexto que uma função será executada. Ao passarmos um 8 | objeto em thisArg, este será o this específico a ser usado numa 9 | determinada função. 10 | */ 11 | 12 | function printChessChampion(firstName, middleName, lastName) { 13 | console.log(`${this.knowAs} (${firstName} ${middleName} ${lastName})`, this.worldChampionIn) 14 | } 15 | 16 | const chessPlayer = [ 17 | { knowAs: 'Bobby Fischer', worldChampionIn: [1972, 1973, 1974] }, 18 | { knowAs: 'Capablanca', worldChampionIn: [1921, 1922, 1923, 1924, 1925, 1926] }, 19 | { knowAs: 'Smyslov', worldChampionIn: [1957, 1958] } 20 | ] 21 | 22 | //Com call, passando uma lista de argumentos 23 | printChessChampion.call(chessPlayer[0], 'Robert', 'James', 'Fischer') 24 | // Bobby Fischer (Robert James Fischer) [ 1972, 1973, 1974 ] 25 | 26 | //Com apply, passando uma array de argumentos 27 | printChessChampion.apply(chessPlayer[1], ['José', 'Raúl', 'Capablanca']) 28 | // Capablanca (José Raúl Capablanca) [ 1921, 1922, 1923, 1924, 1925, 1926 ] 29 | 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /2020-03-11-operator===.js: -------------------------------------------------------------------------------- 1 | /* 2 | O operador de identidade (===) compara os operandos sem fazer conversão de tipo 3 | do dado. Já o operador de igualdade (==) converte o operando se ele não for 4 | do mesmo tipo do outro e só depois faz a comparação estrita. 5 | */ 6 | 7 | console.log('3' == 3) // true 8 | 9 | console.log('7' == 7) // true 10 | 11 | console.log(10 === 10) // true 12 | 13 | console.log('5' === 5) // false 14 | 15 | console.log(typeof 5) 16 | 17 | console.log(typeof '5') -------------------------------------------------------------------------------- /2020-03-14-arrayscontains.js: -------------------------------------------------------------------------------- 1 | const wild = ['Tigre', 'Urso', 'Jacaré', 'Puma'] 2 | 3 | const cats = ['Tigre', 'Gato', 'Puma'] 4 | 5 | const containsBoth = wild.filter(value => cats.includes(value)) 6 | // Contém em wild e cats 7 | console.log(containsBoth) // ['Tigre', 'Puma'] 8 | 9 | const justContainsWild = wild.filter(value => !cats.includes(value)) 10 | // Contém apenas em wild 11 | console.log(justContainsWild) // ['Urso', 'Jacaré'] 12 | 13 | const justContainsCats = cats.filter(value => !wild.includes(value)) 14 | // Contém apenas em cats 15 | console.log(justContainsCats) // ['Gato'] 16 | 17 | const animals = [wild, cats] 18 | 19 | let notContainsBoth = [] 20 | 21 | animals.forEach(() => { 22 | notContainsBoth.push(animals[0].filter(value => !animals[1].includes(value))) 23 | animals.reverse() 24 | }) 25 | // Contém em wild e não contém em cats e vice-versa 26 | console.log(notContainsBoth.flat(1)) // ['Urso', 'Jacaré', 'Gato'] -------------------------------------------------------------------------------- /2020-03-15-arrowfunction.js: -------------------------------------------------------------------------------- 1 | const expressions = { 2 | // Sem Arrow Function 3 | sumFunction: function (arg1, arg2) { 4 | const sum = arg1 + arg2 5 | return sum 6 | }, 7 | // Com Arrow Function 8 | sumArrow: (arg1, arg2) => { 9 | const sum = arg1 + arg2 10 | return sum 11 | }, 12 | 13 | /* 14 | Ainda com Arrow Function... 15 | Instrução única permite ausência das {} e se houver retorno, 16 | podemos inibir a palavra return. 17 | */ 18 | sumArrowBest: (arg1, arg2) => arg1 + arg2, 19 | 20 | // Sem Arrow Function 21 | sqrtFunction: function(arg1) { 22 | return Math.sqrt(arg1) 23 | }, 24 | 25 | /* 26 | Com Arrow Function 27 | Instrução única permite ausência das {} e se houver retorno, 28 | podemos inibir a palavra return. 29 | Parâmetro único permite ausência de (). 30 | */ 31 | sqrtArrow: arg1 => Math.sqrt(arg1), 32 | 33 | } 34 | 35 | /* 36 | Uma Função convencional define seu próprio valor this. 37 | Arrow Function não possui this em seu escopo, logo, ao fazer a 38 | busca por ele, não é encontrado no escopo atual, mas acaba sendo 39 | encontrado no escopo encapsulado. 40 | */ 41 | 42 | this.name = "Usuário Escopo Global"; 43 | 44 | var person = { 45 | name: "Alberto Santos Dumont", 46 | 47 | printFunction: function () { 48 | // Função convencional - aqui this.name faz parte do escopo do objeto person. 49 | console.log(this.name); 50 | }, 51 | // Função convencional (Sugar sintax) - aqui this.name faz parte do escopo do objeto person. 52 | printShortFunction() { 53 | console.log(this.name); 54 | }, 55 | // Arrow Function - aqui this.name faz parte do escopo global. 56 | printArrow: () => { 57 | console.log(this.name); 58 | }, 59 | }; 60 | 61 | person.printFunction(); // "Alberto Santos Dumont" 62 | person.printArrow(); // "Usuário Escopo Global" 63 | person.printShortFunction(); // "Alberto Santos Dumont" -------------------------------------------------------------------------------- /2020-03-17-some.js: -------------------------------------------------------------------------------- 1 | /* 2 | A função some() percorre um vetor testando cada elemento a partir da 3 | implementação de uma callback. Se a condição for atendida, some() 4 | para imediatamente retornando o valor boolean correspondente. A função recebe 5 | os seguintes argumentos: 6 | - callback( 7 | currentValue - Valor atual do vetor sendo processado, 8 | index - Índice atual do vetor sendo processado, 9 | array - Vetor que chamou some() 10 | ) 11 | - thisArg(opcional) - Valor this de uso interno na callback durante a execução. 12 | 13 | Neste exemplo, pergunto se existe uma pessoa no objeto person 14 | chamada André com 18 anos ou mais. Utilizei o parâmetro opcional this 15 | para passar um vetor de critério. 16 | */ 17 | 18 | const person = [ 19 | { name: 'João', age: 17}, 20 | { name: 'Pedro', age: 11 }, 21 | { name: 'André', age: 20 }, 22 | ] 23 | 24 | const checkPerson = ['André', 18] 25 | 26 | const result = person.some((p) => { 27 | return p.name === checkPerson[0] && p.age >= checkPerson[1] 28 | }, checkPerson) 29 | 30 | console.log(result) // true -------------------------------------------------------------------------------- /2020-03-18-readFileSync-writeFileSync.js: -------------------------------------------------------------------------------- 1 | /* 2 | covid-19.json 3 | { 4 | "symptoms": "Febre, tosse seca, cansaço, falta de ar", 5 | "attacks": "Sistema Respiratório", 6 | "transmission": "Contato de pessoa para pessoa, Gotículas respiratórias, Objetos de utilização comunitária", 7 | "prevention": "Lavar as mãos frequentemente; Evitar tocar olhos, nariz, boca; Limpar e desinfetar objetos tocados frequentemente; Cobrir boca/nariz ao tossir/espirrar com lenço descartável", 8 | "incubation": "" 9 | } 10 | */ 11 | const fs = require('fs') 12 | 13 | const path = './covid-19.json' 14 | 15 | function load() { 16 | const buffer = fs.readFileSync(path, 'utf-8') 17 | const json = JSON.parse(buffer) 18 | return json 19 | } 20 | 21 | function save(content) { 22 | const string = JSON.stringify(content) 23 | fs.writeFileSync(path, string) 24 | } 25 | 26 | const covid19 = load() 27 | 28 | console.log(covid19) 29 | /* 30 | { 31 | symptoms: 'Febre, tosse seca, cansaço, falta de ar', 32 | attacks: 'Sistema Respiratório', 33 | transmission: 'Contato de pessoa para pessoa, Gotículas respiratórias, Objetos de utilização comunitária', 34 | prevention: 'Lavar as mãos frequentemente; Evitar tocar olhos, nariz, boca; Limpar e desinfetar objetos tocados frequentemente; Cobrir boca/nariz ao tossir/espirrar com lenço descartável', 35 | incubation: '' 36 | } 37 | */ 38 | covid19.incubation = '2 a 14 dias' 39 | 40 | save(covid19) 41 | 42 | console.log(covid19) 43 | 44 | /* 45 | { 46 | symptoms: 'Febre, tosse seca, cansaço, falta de ar', 47 | attacks: 'Sistema Respiratório', 48 | transmission: 'Contato de pessoa para pessoa, Gotículas respiratórias, Objetos de utilização comunitária', 49 | prevention: 'Lavar as mãos frequentemente; Evitar tocar olhos, nariz, boca; Limpar e desinfetar objetos tocados frequentemente; Cobrir boca/nariz ao tossir/espirrar com lenço descartável', 50 | incubation: '2 a 14 dias' 51 | } 52 | */ -------------------------------------------------------------------------------- /2020-03-19-trycatch.js: -------------------------------------------------------------------------------- 1 | /* 2 | Vamos falar sobre o bloco try...catch? 3 | 4 | try - testa um bloco de código e se falhar... 5 | catch - captura essa exceção lançada em try, entretanto... 6 | finally - implementado, sempre executará, com ou sem lançamento/captura de exceção. Vamos aos exemplos! 7 | */ 8 | 9 | // Vamos começar com um try...catch usual: 10 | try { 11 | throw Error('Crash!') // Exceção lançada. 12 | } catch(error) { // Exceção capturada. 13 | console.log(error) 14 | } finally { // Independente da exceção ter sido capturada ou lançada, finally vai executar. 15 | console.log('I got it') 16 | } 17 | // Error: Crash 18 | // I got it 19 | 20 | // Agora, vamos aninhar sem o catch interno: 21 | try { 22 | try { 23 | throw Error('Boom!') 24 | } finally { 25 | console.log('The End.') 26 | } 27 | } catch(error) { 28 | console.log(error) 29 | } 30 | // The End. 31 | // Error: Boom! 32 | 33 | // Por fim, vamos inserir o catch interno lançando novamente uma exceção: 34 | try { 35 | try { 36 | throw Error('Bang!') 37 | } catch (error) { 38 | console.log(error) 39 | throw error // *** Lançando novamente a exceção 'Bang!'. 40 | } finally { 41 | console.log('Goodbye.') 42 | } 43 | } catch(error) { // *** Que é capturada neste catch. 44 | console.log(error) 45 | } 46 | // Error: Bang! 47 | // Goodbye. 48 | // Error: Bang! -------------------------------------------------------------------------------- /2020-03-22-fillintervalarray.js: -------------------------------------------------------------------------------- 1 | const numbers = [2, 5, 7, 10] // Vetor sequencial ordenado com buracos. Vamos preenchê-los em um novo vetor de 1 até o último elemento de numbers 2 | 3 | const last = numbers[numbers.length-1] + 1 // Último elemento (10) + 1 4 | 5 | const newNumbers = Array.from(Array(last).keys()) // Preenche um vetor com 11 elementos (0 a 10) 6 | 7 | newNumbers.shift() // Remove o primeiro elemento (0) 8 | 9 | console.log(newNumbers) // [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] -------------------------------------------------------------------------------- /2020-04-06-whitespaceremove.js: -------------------------------------------------------------------------------- 1 | const word = 'R e s i l i ê n c i a' 2 | 3 | /* 4 | replace() - Retorna uma nova string, onde o padrão informado é substituido pela string fornecida. 5 | \s - representa em um único caractere todos os tipos de espaço em branco (tab, space, etc.) 6 | /g - Encontra todas as ocorrências do padrão fornecido. 7 | */ 8 | 9 | const flat = word.replace(/\s+/g, ''); // Resiliência 10 | 11 | console.log(flat) -------------------------------------------------------------------------------- /2020-04-09-removelastchar.js: -------------------------------------------------------------------------------- 1 | const backEnd = "'node.js','python','php'," 2 | // substring vai capturar os caracteres do índice 0 até o penúltimo índice da string 3 | const lastRemoved = backEnd.substring(0, backEnd.length-1); 4 | console.log(lastRemoved); //'node.js','python','php' -------------------------------------------------------------------------------- /2020-04-26-selectrandomitemarray.js: -------------------------------------------------------------------------------- 1 | const responsiveWays = ["Flexbox", "Css Grid", "Bootstrap"] 2 | 3 | const random = responsiveWays[ 4 | Math.floor( 5 | Math.random() * responsiveWays.length 6 | ) 7 | ] 8 | 9 | console.log(random) // Exibe um dos itens da array responsiveWays -------------------------------------------------------------------------------- /2020-06-17-functiondeclarationandexpression.js: -------------------------------------------------------------------------------- 1 | /* 2 | O Javascript ordena declarações de variáveis "var" (não o conteúdo) 3 | e "Functions Declarations" no topo do código (hoisting) antes de efetivamente 4 | executar o código e é por este motivo que as Functions Declarations funcionam 5 | independente da ordem onde foram escritas. 6 | 7 | Por isso, no caso das Functions Expressions devemos atentar que a "variável" 8 | abaixo (var printOS) que recebe a função é sim colocada no topo, mas não o seu 9 | conteúdo (a função que está dentro dela). Logo, essa variável é inicializada 10 | como "undefined" e na linha onde a função é atribuída, finalmente essa variável 11 | se torna uma função. 12 | 13 | A solução para contornar confusões como esta veio com let e const, que 14 | obrigatoriamente diz que uma variável declarada let ou const só pode ser usada 15 | depois de ter sido declarada e inicializada. 16 | */ 17 | 18 | // Function Declaration 19 | printManufacturer('Samsung') // Sistema Operacional: Android 20 | 21 | function printManufacturer(manufacturer) { 22 | console.log(`Fabricante: ${manufacturer}`) 23 | } 24 | 25 | printManufacturer('Samsung') // Sistema Operacional: Android 26 | 27 | 28 | // Function Expression 29 | printOS('Android') // Error: Function is not defined 30 | 31 | var printOS = function(os) { 32 | console.log(`Sistema Operacional: ${os}`) 33 | } 34 | 35 | printOS('Android') // Sistema Operacional: Android -------------------------------------------------------------------------------- /2020-12-27-compareobjects.js: -------------------------------------------------------------------------------- 1 | // Vamos comparar rapidamente se dois objetos são estritamente iguais? 2 | 3 | const obj1 = [ 4 | { 5 | id: 1, 6 | name: "John", 7 | }, 8 | { 9 | id: 2, 10 | name: "Martin", 11 | }, 12 | ]; 13 | 14 | const obj2 = [ 15 | { 16 | id: 1, 17 | name: "John", 18 | }, 19 | { 20 | id: 2, 21 | name: "Martin", 22 | }, 23 | ]; 24 | 25 | console.log(JSON.stringify(obj1) === JSON.stringify(obj2)); // true 26 | 27 | obj2[0].name = "Frank"; 28 | 29 | console.log(JSON.stringify(obj1) === JSON.stringify(obj2)); // false 30 | -------------------------------------------------------------------------------- /2021-01-29-consoledir.js: -------------------------------------------------------------------------------- 1 | /* 2 | Existem algumas maneiras de inspecionar todos os níveis de um objeto 3 | com node.js. Uma que acho prática é com o uso de 'console.dir'. 4 | */ 5 | 6 | const player = [ 7 | { 8 | born: "19 november 1888", 9 | name: "José Raul Capablanca y Graupera", 10 | surname: "Capablanca", 11 | tournaments: [ 12 | { 13 | city: "New York", 14 | yean: 1911, 15 | place: "2nd", 16 | opponent: "Marshall", 17 | }, 18 | 19 | { 20 | city: "Budapest", 21 | year: 1928, 22 | place: "winner", 23 | opponent: "Rubinstein", 24 | }, 25 | ], 26 | }, 27 | ]; 28 | 29 | console.log(player); 30 | 31 | /* Output: 32 | [ 33 | { 34 | born: '19 november 1888', 35 | name: 'José Raul Capablanca y Graupera', 36 | surname: 'Capablanca', 37 | tournaments: [ [Object], [Object] ] 38 | } 39 | ] 40 | */ 41 | 42 | // depth: null vai recursivamente ler todos os níveis de profundidade do objeto 43 | console.dir(player, { depth: null }); 44 | 45 | /* Output: 46 | [ 47 | { 48 | born: '19 november 1888', 49 | name: 'José Raul Capablanca y Graupera', 50 | surname: 'Capablanca', 51 | tournaments: [ 52 | { 53 | city: 'New York', 54 | yean: 1911, 55 | place: '2nd', 56 | opponent: 'Marshall' 57 | }, 58 | { 59 | city: 'Budapest', 60 | year: 1928, 61 | place: 'winner', 62 | opponent: 'Rubinstein' 63 | } 64 | ] 65 | } 66 | ] 67 | */ 68 | --------------------------------------------------------------------------------