├── .gitignore ├── 01-exercicio.js ├── 02-exercicio.js ├── README.md ├── conceitos ├── async-await.js ├── condicionais-if-else.js ├── condicionais-switch-case.js ├── excecoes.js ├── funcoes-de-seta.js ├── funcoes-tradicionais.js ├── modularizacao-export.js ├── modularizacao-import.js ├── operadores-adicionais.js ├── operadores-aritmeticos.js ├── operadores-comparacao.js ├── operadores-logicos.js ├── repeticao-for.js ├── repeticao-forEach.js ├── repeticao-while.js └── testes-de-unidade.js ├── exercicios ├── 03-exercicio.js ├── 04-exercicio.js ├── 05-exercicio.js ├── 06-exercicio.js ├── 07-exercicio.js ├── 08-exercicio.js ├── 09-exercicio.js ├── 10-exercicio-dados.js ├── 10-exercicio-funcao.js └── 10-exercicio-principal.js ├── index.js ├── package.json ├── testes └── 01-testes.js └── trabalho.js /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | node_modules 3 | package-lock.json -------------------------------------------------------------------------------- /01-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | Gerador de tags de identificação 3 | 4 | Crie um script para gerar a etiqueta (tag) de identificação que será presa na coleira de um cachorro no abrigo. O dono irá informar nome, idade, peso, raça e se é adotado ou não. 5 | 6 | A tag deve ter: 7 | O nome em letras maiúsculas 8 | A raça com a primeira letra maiúscula 9 | Peso 10 | 11 | */ 12 | 13 | const nome = "Dogo", raca = "vira-lata" 14 | let idade = 1, peso = 1.2, adotado = false 15 | 16 | const dogThor = { 17 | nome: "Thor", 18 | raca: "SRD", 19 | idade: 1, 20 | peso: 10.5, 21 | adotado: true 22 | } 23 | 24 | let nameUpperCase = nome.toUpperCase() 25 | let racaFirsletter = raca.slice(0, 1).toUpperCase() + raca.slice(1).toLowerCase() 26 | 27 | 28 | 29 | const animal = [{ 30 | nome: nameUpperCase, 31 | peso: peso, 32 | raca: racaFirsletter 33 | }] 34 | 35 | console.log(animal) 36 | 37 | const dogThorTag = { 38 | nome: dogThor.nome.toUpperCase(), 39 | raca: dogThor.raca.slice(0, 1).toUpperCase() + dogThor.raca.slice(1).toLowerCase(), 40 | peso: dogThor.peso 41 | } 42 | 43 | console.table(dogThorTag) 44 | // console.log(`Nome: ${ dogThor.nome.toUpperCase() } - Raça ${ dogThor.raca.slice(0, 1).toUpperCase() + dogThor.raca.slice(1).toLowerCase() } - Peso: ${ dogThor.peso }`) 45 | 46 | -------------------------------------------------------------------------------- /02-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Validador de nomes para as tags 4 | 5 | Alguns donos estão registrando os dogs com nomes mal formatados. Crie um script para limpar e padronizar os nomes. 6 | 7 | Aplique as formatações e exiba: 8 | - O nome original, como foi cadastrado 9 | - O nome formatado 10 | 11 | Extra: aplique uma regra que confira se o nome informado possui apenas uma palavra. Exiba se o nome é válido ou não. 12 | 13 | Exemplos: 14 | 15 | - nomes válidos 16 | - Pipoca 17 | - Guaraná 18 | - Paçoca 19 | - nomes inválidos 20 | - Peggy Carter 21 | - Pantera Negra 22 | 23 | */ 24 | 25 | // const nomeDog = "tH oR@!% " 26 | // const nomeDog = ' Ba!ley Mari@ ' 27 | const nomeDog = 'Doguinho123' 28 | 29 | let nomeFormatado = nomeDog.trim() 30 | nomeFormatado = removerCaracteresEspeciais(nomeFormatado) 31 | nomeFormatado = tornarAPrimeiraLetraMaiuscula(nomeFormatado) 32 | 33 | // const palavras = nomeFormatado.split(/\s+/); 34 | // const palavras = nomeFormatado.split(" "); 35 | // const valido = palavras.length === 1; 36 | 37 | // 10 == '10' 38 | // 10 === '10' 39 | 40 | /* 41 | 42 | operadores = comparacao, logica, aritmética 43 | 44 | VALOR A maior que VALOR B 45 | VALOR A menor que VALOR B 46 | 47 | == -> VARIAVEL A 'possui o mesmo valor que' VARIAVEL B 48 | === -> VARIAVEL A 'possui o mesmo valor E possui o mesmo tipo de dado que' VARIAVEL B 49 | 50 | */ 51 | 52 | const valido = verificarSeONomeEValido(nomeFormatado) 53 | 54 | console.log(nomeDog) 55 | console.log(nomeFormatado) 56 | console.log(valido) 57 | 58 | 59 | 60 | function removerCaracteresEspeciais(nome) { 61 | // return nome.replace(/[^a-zA-ZÀ-ÿ]/g, ""); 62 | return nome.replace(/[^a-zA-ZÀ-ÿ\s]/g, ""); 63 | } 64 | 65 | function removerEspacosEntreAPalavra(nome) { 66 | return nome.replace(/\s+/g, "") 67 | } 68 | 69 | function tornarAPrimeiraLetraMaiuscula(nome) { 70 | return nome.charAt(0).toUpperCase() + nome.slice(1, nome.length).toLowerCase() 71 | } 72 | 73 | function verificarSeONomeEValido(nome) { 74 | return nome.split(" ").length === 1 75 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # pgats-programacao-js 2 | -------------------------------------------------------------------------------- /conceitos/async-await.js: -------------------------------------------------------------------------------- 1 | 2 | 3 | // async - assíncrono 4 | async function exibirNomeDogFormatado (nome) { 5 | return nome.toUpperCase() 6 | } 7 | 8 | // await - esperar 9 | console.log(await exibirNomeDogFormatado(`Pipoca`)) 10 | -------------------------------------------------------------------------------- /conceitos/condicionais-if-else.js: -------------------------------------------------------------------------------- 1 | /** 2 | condicao (se verdadeira) 3 | acao dentro do if 4 | senao se (outra condicao) 5 | acao dentro do if 6 | senao 7 | acao dentro do else 8 | 9 | */ 10 | 11 | if (10 < 5) { 12 | console.log(`valor é maior`) 13 | } else { 14 | console.log(`valor é menor`) 15 | } 16 | 17 | const idade = 3 18 | const porte = 'P' 19 | 20 | if (idade >= 2) { 21 | console.log(`Pode ser adotado, pela idade`) 22 | } else if (porte === 'P') { 23 | console.log(`Pode ser adotado, pelo porte`) 24 | } else { 25 | console.log(`Não pode ser adotado`) 26 | } 27 | -------------------------------------------------------------------------------- /conceitos/condicionais-switch-case.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | escolha (condicao): 4 | caso x: faca 5 | caso y: faca 6 | caso z: faca 7 | 8 | */ 9 | 10 | const peso = 31 11 | 12 | switch (peso) { 13 | case 10: 14 | console.log('P') 15 | break 16 | case 20: 17 | console.log('M') 18 | break 19 | case 30: 20 | console.log('G') 21 | break 22 | case 40: 23 | console.log('G') 24 | break 25 | default: 26 | console.log('ND') 27 | } 28 | 29 | // Se quiser muito usar switch, dá para fazer um truque com true, tipo: 30 | switch (true) { 31 | case peso <= 10: 32 | console.log('P'); 33 | break; 34 | case peso <= 20: 35 | console.log('M'); 36 | break; 37 | case peso <= 30: 38 | console.log('G'); 39 | break; 40 | default: 41 | console.log('ND'); 42 | } -------------------------------------------------------------------------------- /conceitos/excecoes.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | tentar { 4 | // conexao com banco (exemplo) 5 | 6 | } pegar (erro/excecao) { 7 | // salvar a excecao em algum lugar... 8 | // exibir 9 | } 10 | 11 | lançar = throw 12 | 13 | */ 14 | 15 | // TENTAR FAZER ALGO QUE PODE DAR ERRO 16 | try { 17 | console.log(`Tentando alimentar o Pet...`) 18 | throw new TypeError('pet nao quis alimento') 19 | 20 | // TENTAR CONECTAR NO BANCO 21 | // EXECUTAR UMA QUERY 22 | } catch (excecao) { 23 | // TRATAR ESTE ERRO - EXIBIR, SALVAR, MELHOR A DESCRIÇÃO DESSE ERRO 24 | // console.log(excecao) 25 | console.log(excecao.name) 26 | console.log(excecao.message) 27 | 28 | // CAPTURAR A EXCECAO 29 | 30 | } finally { 31 | // SEMPRE EXECUTA, COMO SE FOSSE UMA ACAO FINAL 32 | console.log(`SEMPRE SEREI EXECUTADO`) 33 | 34 | // FECHAR A CONEXAO COM O BANCO (AO MENOS GARANTIR QUE FOI FECHADA) 35 | } 36 | 37 | 38 | 39 | // -------------------------------------------------------------------------------- /conceitos/funcoes-de-seta.js: -------------------------------------------------------------------------------- 1 | // funcoes de seta / flecha 2 | 3 | // funcao nomeada, com parametro, sem retorno 4 | const exibirNomeDoDog = (nome) => { 5 | console.log(nome) 6 | } 7 | 8 | // funcao nomeada, com parametro + valor default, sem retorno 9 | const exibirPorteDoDog = (porte = 'ND') => { 10 | console.log(porte) 11 | } 12 | 13 | // funcao nomeada, com parametro, com retorno 14 | const obterNomeDoDogFormatado = (nome) => { 15 | return nome.toUpperCase() 16 | } 17 | 18 | const obterObjetoDog = () => { 19 | return { 20 | nome: 'Bailey Maria', 21 | peso: 11.5, 22 | dogIrmao: { 23 | nome: 'Billy' 24 | }, 25 | adotado: true 26 | } 27 | } 28 | 29 | const listarObjetosDog = () => { 30 | return [{ 31 | nome: 'Bailey Maria', 32 | peso: 11.5 33 | }, { 34 | nome: 'Bailey Maria', 35 | peso: 11.5 36 | }] 37 | } 38 | 39 | const listarNomesDeDogs = () => { 40 | const nomes = [ 41 | 'Pituca', 42 | 'Marea', 43 | 'Anderson' 44 | ] 45 | 46 | console.log(`Passou pela função listarNomesDeDogs`) 47 | 48 | return nomes 49 | } 50 | 51 | // arrow function sem bloco + com return 'automatico' 52 | const dobrar = (numero) => numero * 2 53 | const saudacoes = (nome) => `Olá, ${nome}!` 54 | 55 | exibirNomeDoDog("Pipoca") 56 | exibirPorteDoDog() 57 | console.log(obterNomeDoDogFormatado("Bailey Maria")) 58 | console.log(obterObjetoDog()) 59 | console.log(listarObjetosDog()) 60 | console.log(listarNomesDeDogs()) 61 | 62 | console.log(`--------`) 63 | 64 | listarNomesDeDogs() 65 | 66 | const nomesDeDogs = listarNomesDeDogs() 67 | 68 | // 69 | 70 | // function filtrarNumeros(lista) { 71 | // return lista.filter(item => typeof item === 'number'); 72 | // } 73 | 74 | 75 | // Mocha 76 | teste ('nome do teste', { tags: 'critico' }, function () { 77 | // implementacao do teste 78 | }) 79 | 80 | 81 | 82 | /** 83 | * Gere 5 perguntas (sem a resposta) sobre tema xpto; avalie minhas respostas como correta ou errada e me explique o porque da resposta correta. 84 | * 85 | */ -------------------------------------------------------------------------------- /conceitos/funcoes-tradicionais.js: -------------------------------------------------------------------------------- 1 | // funcao nomeada, com parametro, sem retorno 2 | function exibirNomeDoDog(nome) { 3 | console.log(nome) 4 | } 5 | 6 | // funcao nomeada, com parametro + valor default, sem retorno 7 | function exibirPorteDoDog(porte = 'ND') { 8 | console.log(porte) 9 | } 10 | 11 | // funcao nomeada, com parametro, com retorno 12 | function obterNomeDoDogFormatado(nome) { 13 | return nome.toUpperCase() 14 | } 15 | 16 | function obterObjetoDog() { 17 | return { 18 | nome: 'Bailey Maria', 19 | peso: 11.5, 20 | dogIrmao: { 21 | nome: 'Billy' 22 | }, 23 | adotado: true 24 | } 25 | } 26 | 27 | function listarObjetosDog() { 28 | return [{ 29 | nome: 'Bailey Maria', 30 | peso: 11.5 31 | }, { 32 | nome: 'Bailey Maria', 33 | peso: 11.5 34 | }] 35 | } 36 | 37 | function listarNomesDeDogs() { 38 | const nomes = [ 39 | 'Pituca', 40 | 'Marea', 41 | 'Anderson' 42 | ] 43 | 44 | console.log(`Passou pela função listarNomesDeDogs`) 45 | 46 | return nomes 47 | } 48 | 49 | 50 | exibirNomeDoDog("Pipoca") 51 | exibirPorteDoDog() 52 | console.log(obterNomeDoDogFormatado("Bailey Maria")) 53 | console.log(obterObjetoDog()) 54 | console.log(listarObjetosDog()) 55 | console.log(listarNomesDeDogs()) 56 | 57 | console.log(`--------`) 58 | 59 | listarNomesDeDogs() 60 | 61 | const nomesDeDogs = listarNomesDeDogs() 62 | 63 | -------------------------------------------------------------------------------- /conceitos/modularizacao-export.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Sintaxe CommonJS (commonjs) (até 2019 ~ 2020): 4 | module.exports = {} / require('') 5 | 6 | 7 | ESM (module) - Ecmascript Standard Modules (> 2019) 8 | export {} / import 9 | 10 | */ 11 | // const nomePet = `Pitoco` 12 | // console.log(`O nome do pet é ${nomePet}`) 13 | 14 | // const nomePet2 = `Pipoca` 15 | // console.log(`O nome do pet é ${nomePet2}`) 16 | 17 | // const nomePet3 = `Pantera` 18 | // console.log(`O nome do pet é ${nomePet3}`) 19 | 20 | const BRINQUEDOS = [ 21 | 'Osso', 22 | 'Peteca', 23 | 'Chocalho' 24 | ] 25 | 26 | function exibirNomePet(paramNomePet = 'valor padrao') { 27 | 28 | if (paramNomePet === undefined) { 29 | console.log() 30 | return 31 | } 32 | 33 | console.log(`O nome do pet é ${paramNomePet}`) 34 | } 35 | 36 | function exibirIdade(paramIdadePet) { 37 | console.log(`Idade do Pet é ${paramIdadePet}`) 38 | } 39 | 40 | // export {} / import 41 | export { 42 | exibirNomePet, 43 | exibirIdade, 44 | BRINQUEDOS 45 | } -------------------------------------------------------------------------------- /conceitos/modularizacao-import.js: -------------------------------------------------------------------------------- 1 | // export {} / import 2 | 3 | // importar { o que queremos } de 'caminho do arquivo' 4 | import { exibirNomePet } from './modularizacao-export.js' 5 | 6 | exibirNomePet(`Pipoca`) 7 | exibirNomePet() 8 | -------------------------------------------------------------------------------- /conceitos/operadores-adicionais.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | -- decremento 4 | ++ incremento 5 | 6 | ? ternário 7 | 8 | */ 9 | 10 | // incremento 11 | let pesoDoDog = 10 12 | console.log(pesoDoDog) 13 | 14 | pesoDoDog++ 15 | console.log(pesoDoDog) 16 | 17 | // decremento 18 | let pesoDoTutor = 100 19 | console.log(pesoDoTutor) 20 | 21 | pesoDoTutor-- 22 | console.log(pesoDoTutor) 23 | 24 | // ternário 25 | // const porte = pesoDoDog <= 10 ? 'pequeno' : 'médio' 26 | 27 | const pesoDoDogOperadorTernario = 21 28 | const porte = pesoDoDogOperadorTernario <= 10 // se if 29 | ? 'pequeno' 30 | : pesoDoDogOperadorTernario <= 20 // senao se / else if 31 | ? 'médio' 32 | : 'grande' // senao 33 | 34 | // pesoDoDogOperadorTernario <= 10 ? 'pequeno' : pesoDoDogOperadorTernario <= 20 ? 'médio' : 'grande' 35 | 36 | // console.log(porte) 37 | 38 | {/* ? : */} -------------------------------------------------------------------------------- /conceitos/operadores-aritmeticos.js: -------------------------------------------------------------------------------- 1 | /** 2 | + adição 3 | - subtração 4 | * multiplicação 5 | / divisão 6 | % resto 7 | ** exponencial 8 | */ 9 | 10 | console.log(1 + 1) // 2 11 | console.log(10 - 7) // 3 12 | console.log(2 * 2) // 4 13 | 14 | console.log(11 / 2) 15 | console.log(11 % 2) 16 | 17 | console.log(4 ** 4) 18 | 19 | console.log(2 + 3 * 4) // precedencia - multiplicao, adicao 20 | console.log((2 + 3) * 4) // precedência - dentro do parenteses, depois o que está fora 21 | 22 | // 3 * 4 == 12 23 | // 12 + 2 == 14 24 | console.log(11 / 2) // 5.5 25 | console.log(parseInt(11 / 2)) // 5.5 -> 5 26 | 27 | // arredondamento 28 | 29 | // arredonda para baixo 30 | console.log(Math.floor(5.8)) 31 | 32 | // arredonda para cima 33 | console.log(Math.ceil(5.8)) 34 | 35 | 36 | // arredonda para o mais próximo 37 | console.log(Math.round(5.8)) 38 | console.log(Math.round(5.4)) 39 | console.log(Math.round(5.5)) 40 | 41 | // 42 | const valorDecimal = 2.123123 43 | console.log(valorDecimal.toFixed(3)) 44 | 45 | -------------------------------------------------------------------------------- /conceitos/operadores-comparacao.js: -------------------------------------------------------------------------------- 1 | /* 2 | > - maior que 3 | >= - maior ou igual que 4 | < - menor que 5 | <= - menor ou igual que 6 | == - igualdade somente de valores 7 | != - diferença somente de valores 8 | === - igualdade de valores e tipo de dado 9 | */ 10 | 11 | // console.log(`10 > 5 = ${ 10 > 5 }`) // verdadeiro = true 12 | // console.log("10 > 5 = ${ 10 > 5 }") // verdadeiro = true 13 | 14 | // maior que 15 | console.log(10 > 5) // verdadeiro 16 | console.log(10 > 20) // falso 17 | 18 | // maior ou igual 19 | console.log(10 >= 10) // verdadeiro 20 | console.log(10 >= 9) // verdadeiro 21 | 22 | // menor que 23 | console.log(10 < 5) // falso 24 | console.log(10 < 20) // verdadeiro 25 | 26 | // menor ou igual 27 | 28 | console.log(10 <= 10) // verdadeiro 29 | console.log(10 <= 9) // falso 30 | 31 | // igualdade somente de valores 32 | 33 | console.log(1 == '1') 34 | console.log(true == 1) // verdadeiro 35 | console.log(false == 1) // falso 36 | console.log(null == undefined) // verdadeiro 37 | console.log('' == 0) // verdadeiro 38 | 39 | // igualdade de valores e tipo de dado 40 | console.log(1 === '1') // falso 41 | console.log(true === 1) // falso 42 | console.log(false === 1) // falso 43 | 44 | // diferença de valores 45 | console.log(1 != 2) // verdadeiro 46 | console.log(1 !== 2) // verdadeiro -------------------------------------------------------------------------------- /conceitos/operadores-logicos.js: -------------------------------------------------------------------------------- 1 | /** 2 | && - E / AND 3 | || - OU / OR 4 | ! - NÃO / NOT 5 | */ 6 | 7 | // && - E / AND 8 | const nomeDog = "Pipoca" 9 | const nomePossuiApenasUmaPalavra = nomeDog.split(" ").length === 1 10 | const nomePossuiAteDezCaracteres = nomeDog.length <= 10 11 | 12 | console.log(nomePossuiApenasUmaPalavra && nomePossuiAteDezCaracteres) // true 13 | 14 | // || - OU / OR 15 | const dog = { 16 | adotado: false, 17 | peso: 5.3 18 | } 19 | 20 | console.log(dog.adotado || dog.peso < 10) // verdadeiro 21 | 22 | console.log(true || true) // verdadeiro 23 | console.log(true || false) // verdadeiro 24 | console.log(false || true) // verdadeiro 25 | console.log(false || false) // falso 26 | 27 | 28 | // ! - NÃO / NOT 29 | 30 | console.log(true) // verdadeiro 31 | console.log(!true) -------------------------------------------------------------------------------- /conceitos/repeticao-for.js: -------------------------------------------------------------------------------- 1 | /** 2 | para, faca 3 | contador; condicao; manipulacao do contador (incremento/decremento) 4 | 5 | quantidadeDePetiscos; quantidadeDePetiscos <= quantidadeCalculada; quantidadeDePetiscos++ 6 | 7 | */ 8 | 9 | const quantidadeCalculada = 3 10 | 11 | for (let quantidadeDePetiscos = 1; quantidadeDePetiscos <= quantidadeCalculada; quantidadeDePetiscos++) { 12 | // acao de dar um petisco 13 | console.log(`Dando o petisco de nº ${quantidadeDePetiscos}`) 14 | 15 | } 16 | 17 | const gatos = ['Lessie', 'Pony', 'Fumaca'] 18 | 19 | for (let indice = 0; indice < gatos.length; indice++) { 20 | console.log(`Dando o Petisco para ${gatos[indice]} `) 21 | 22 | 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /conceitos/repeticao-forEach.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | listaDeAlunos 4 | Matheus 5 | Renata 6 | Leandro 7 | Ana 8 | Lucas 9 | 10 | paraCada (item da) listaDeAlunos 11 | // dar uma nota aleatória 12 | 13 | */ 14 | 15 | const listaDeAlunos = [ 16 | 'Matheus', 17 | 'Renata', 18 | 'Leandro', 19 | 'Ana', 20 | 'Lucas' 21 | ] 22 | 23 | listaDeAlunos.forEach(aluno => { 24 | console.log(aluno) 25 | }) 26 | 27 | const listaDeAlunosENotas = [ 28 | { 29 | nome: 'Matheus', 30 | nota: 7 31 | }, 32 | { 33 | nome: 'Renata', 34 | nota: 7 35 | }, 36 | { 37 | nome: 'Leandro', 38 | nota: 7 39 | }, 40 | { 41 | nome: 'Ana', 42 | nota: 9 43 | }, 44 | { 45 | nome: 'Lucas', 46 | nota: 7 47 | } 48 | ] 49 | 50 | listaDeAlunosENotas.forEach(aluno => { 51 | 52 | console.log(index) 53 | 54 | if (aluno.nota < 7) { 55 | console.log(`O aluno ${aluno.nome} precisa do trabalho extra`) 56 | console.log(`O aluno ${aluno.nome} tem a nota ${aluno.nota}`) 57 | } 58 | 59 | }) 60 | -------------------------------------------------------------------------------- /conceitos/repeticao-while.js: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | enquanto (pet não estiver cansado); faca { 4 | dar uma volta na quadra 5 | } 6 | 7 | * 8 | */ 9 | 10 | let voltasAteFicarCansado = 5 11 | let quantidadeVoltasAtual = 0 12 | 13 | while (quantidadeVoltasAtual < voltasAteFicarCansado) { 14 | console.log(`Dar uma volta na quadra`) 15 | 16 | quantidadeVoltasAtual++ 17 | } 18 | 19 | // execucao do código - 20 | // over engineering - 21 | 22 | // boilerplate 23 | // templates 24 | 25 | // template playwright + cucumber github -------------------------------------------------------------------------------- /conceitos/testes-de-unidade.js: -------------------------------------------------------------------------------- 1 | function exibirNomeDogFormatado (nome) { 2 | return nome.toUpperCase() 3 | } 4 | 5 | export { 6 | exibirNomeDogFormatado 7 | } -------------------------------------------------------------------------------- /exercicios/03-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Validador de idade mínima para adoção 4 | 5 | Crie um script que verifique se um dog pode ser adotado com base na idade mínima definida, por exemplo, 2 anos. 6 | 7 | Use os operadores adequados e exiba: 8 | Nome do dog 9 | Idade 10 | Se está apto ou não para adoção 11 | 12 | Extra: aplique uma regra com operador lógico para permitir que se o cão for de pequeno porte, pode ser adotado independente da idade 13 | 14 | Exemplos: 15 | mínimo = 2 16 | 17 | idade 1 + porte M = nao 18 | idade 2 + porte M = sim, pela idade 19 | idade 2 + porte P = sim, pela idade 20 | idade 1 + porte P = sim, pelo porte 21 | 22 | */ 23 | 24 | const nome = 'Ada' 25 | const idade = 0 26 | const porte = 'P' 27 | 28 | const idadeMinima = 2 29 | 30 | const adocao = idade >= idadeMinima 31 | ? 'sim' 32 | : porte === 'P' 33 | ? 'sim' 34 | : 'não' 35 | 36 | const adocaov2 = idade >= idadeMinima || porte === 'P' 37 | 38 | console.log(adocao) 39 | console.log(adocaov2) 40 | 41 | function verificarSePodeSerAdotado(idade, porte) { 42 | const adocao = idade >= idadeMinima 43 | ? 'sim' 44 | : porte === 'P' 45 | ? 'sim' 46 | : 'não' 47 | 48 | // return adocao 49 | console.log(adocao) 50 | } 51 | 52 | // idade 1 + porte M = nao 53 | // idade 2 + porte M = sim, pela idade 54 | // idade 2 + porte P = sim, pela idade 55 | // idade 1 + porte P = sim, pelo porte 56 | 57 | verificarSePodeSerAdotado(1, 'M') 58 | verificarSePodeSerAdotado(2, 'M') 59 | verificarSePodeSerAdotado(2, 'P') 60 | verificarSePodeSerAdotado(1, 'P') -------------------------------------------------------------------------------- /exercicios/04-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | Calculadora de ração diária 3 | 4 | Crie um script que receba o peso do dog em kg + estoque atual de ração em gramas. Calcule a quantidade diária de ração com base na seguinte fórmula: 5 | 6 | Gramas por dia = Peso x 30 gramas 7 | 8 | Exiba: 9 | Nome do dog 10 | Peso 11 | Quantidade de ração recomendada por dia 12 | Quantos dias o estoque atual vai durar 13 | 14 | */ 15 | 16 | // ALTERNATIVA 1, simplificado sem função 17 | 18 | const nome = `Mel` 19 | const peso = 10 20 | const estoque = 5000 21 | 22 | const gramasPorDia = peso * 30 23 | const duracaoEstoque = estoque / gramasPorDia 24 | 25 | console.log(`Nome do dog: ${nome}`) 26 | console.log(`Peso: ${peso}`) 27 | console.log(`Gramas por dia: ${gramasPorDia}`) 28 | console.log(`O estoque vai durar: ${duracaoEstoque}`) 29 | 30 | // ALTERNATIVA 2, usando função com parâmetros 31 | 32 | function calcularConsumoDeRacao(nome, peso, estoque) { 33 | const gramasPorDia = peso * 30 34 | const duracaoEstoque = Math.floor(estoque / gramasPorDia) 35 | 36 | console.log(`----------------------`) 37 | console.log(`Nome do dog: ${nome}`) 38 | console.log(`Peso: ${peso}kg`) 39 | console.log(`Gramas por dia: ${gramasPorDia}g`) 40 | console.log(`O estoque vai durar: ${duracaoEstoque} dias`) 41 | console.log(`----------------------`) 42 | } 43 | 44 | calcularConsumoDeRacao('Ada', 1, 2000) 45 | calcularConsumoDeRacao('Laninha', 4.2, 15000) 46 | calcularConsumoDeRacao('Pantera', 14.5, 5000) -------------------------------------------------------------------------------- /exercicios/05-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Classificador de porte automático 4 | 5 | Muitos tutores não fazem ideia do porte de seu Dog. 6 | Crie um script que classifique o porte com base no peso de forma simplificada, sendo: 7 | 8 | Até 10kg -> Pequeno; acima disso -> Médio 9 | 10 | Use o operador ternário para determinar o porte. Exiba: 11 | Nome 12 | Peso 13 | Porte classificado 14 | 15 | Extra: transforme a lógica em uma função (da forma que conseguir) 16 | Extra: adicionar mais condições exemplo: >= 50 -> porte grande 17 | 18 | */ 19 | 20 | const nome = `Ada` 21 | const peso = 11 22 | 23 | const porte = peso <= 10 ? 'pequeno' : 'médio' 24 | 25 | console.log(`------`) 26 | console.log(`Nome: ${nome}`) 27 | console.log(`Peso: ${peso}`) 28 | console.log(`Porte: ${porte}`) 29 | console.log(`------`) 30 | 31 | // ALTERNATIVA com a função (Extra) 32 | function classificarPortePorPeso(nome, peso) { 33 | const porte = peso <= 10 ? 'pequeno' : 'médio' 34 | 35 | console.log(`------`) 36 | console.log(`Nome: ${nome}`) 37 | console.log(`Peso: ${peso}`) 38 | console.log(`Porte: ${porte}`) 39 | console.log(`------`) 40 | } 41 | 42 | classificarPortePorPeso('Pantera', 14.5) 43 | classificarPortePorPeso('Bandite', 35) 44 | classificarPortePorPeso('Rex', 8) -------------------------------------------------------------------------------- /exercicios/06-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Plano de atividades para o Pet 4 | 5 | Crie um script que defina o plano de atividades para os dogs durante a estadia. O script vai receber o porte (pequeno, médio ou grande); e o tempo disponível para a atividade representado em minutos. Exemplo: 6 | 7 | Pantera - Médio - 45 8 | 9 | Use uma condicional para decidir o tipo de atividade com base no porte: 10 | pequeno -> brincar dentro de casa 11 | médio -> caminhada no quarteirão 12 | grande -> correr no parque 13 | qualquer outro -> porte inválido 14 | 15 | Depois, uma condicional para ajustar a mensagem de acordo com o tempo: 16 | menor que 15 -> "atividade rápida: [atividade]" 17 | de 15 a 30 -> "tempo ideal: [atividade]" 18 | acima de 30 -> "hora da diversão: [atividade] 19 | 20 | 21 | */ 22 | 23 | const nome = `Pantera` 24 | const porte = `médio` 25 | const tempo = 30 26 | 27 | 28 | // decidir o tipo de atividade com base no porte 29 | let atividade 30 | 31 | switch (porte) { 32 | case 'pequeno': 33 | atividade = `brincar dentro de casa` 34 | break 35 | case 'médio': 36 | atividade = `caminhada no quarteirão` 37 | break 38 | case 'grande': 39 | atividade = `correr no parque` 40 | break 41 | default: 42 | atividade = `porte inválido` 43 | } 44 | 45 | // ajustar a mensagem de acordo com o tempo 46 | // Depois, uma condicional para ajustar a mensagem de acordo com o tempo: 47 | // menor que 15 -> "atividade rápida: [atividade]" 48 | // de 15 a 30 -> "tempo ideal: [atividade]" 49 | // acima de 30 -> "hora da diversão: [atividade] 50 | let mensagem 51 | 52 | if (tempo < 15) { 53 | mensagem = `atividade rápida` 54 | } else if (tempo <= 30) { 55 | mensagem = `tempo ideal` 56 | } else if (tempo > 30) { 57 | mensagem = `hora da diversão` 58 | } 59 | 60 | console.log(`${ mensagem }: [${ atividade }]`) -------------------------------------------------------------------------------- /exercicios/07-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Contador de satisfação de passeio 4 | 5 | Crie um script que avise quando o Dog já passeou o suficiente. 6 | Para saber, vamos considerar que ele se sentirá satisfeito somente a partir de 5 voltas na quadra. 7 | 8 | Use a estrutura de repetição while. 9 | 10 | Exiba: 11 | Qual o número da volta atual 12 | Quando o dog estiver satisfeito 13 | 14 | Extra: transforme a lógica em uma função (da forma que conseguir) 15 | 16 | */ 17 | 18 | const voltasParaDogFicarSatisfeito = 5 19 | let volta = 0 20 | 21 | while (volta <= voltasParaDogFicarSatisfeito) { 22 | 23 | console.log(`Volta de nº ${volta} com o Pitoco`) 24 | console.log(`Pitoco ainda não está satisfeito!`) 25 | 26 | volta++ 27 | } 28 | 29 | console.log(`Acaboooooou o passeio, Pitoco!`) 30 | console.log(`----------------------------`) 31 | 32 | // com a função (extra) 33 | function verificarSeEstaSatisfeito() { 34 | 35 | const voltasParaDogFicarSatisfeito = 5 36 | let volta = 0 37 | 38 | while (volta <= voltasParaDogFicarSatisfeito) { 39 | 40 | console.log(`Volta de nº ${volta} com o Pitoco`) 41 | console.log(`Pitoco ainda não está satisfeito!`) 42 | 43 | volta++ 44 | } 45 | 46 | console.log(`Acaboooooou o passeio, Pitoco!`) 47 | } 48 | 49 | verificarSeEstaSatisfeito(10) 50 | 51 | -------------------------------------------------------------------------------- /exercicios/08-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Controle de petiscos 4 | 5 | Crie um script que receba uma quantidade de petiscos e dê 1 por vez até o dog estiver satisfeito. 6 | 7 | Use a estrutura de repetição for contado. 8 | 9 | Exiba: 10 | Cada vez que um petisco for entregue 11 | Quando o dog estiver satisfeito (que é quando terminar os petiscos) 12 | 13 | Extra: transforme a lógica em uma função (da forma que conseguir) 14 | 15 | */ 16 | 17 | const quantidadePetiscosDisponiveis = 4 18 | 19 | for (let petisco = 1; petisco <= quantidadePetiscosDisponiveis; petisco++) { 20 | console.log(`Dando o petisco de nº ${petisco} para o Totó`) 21 | } 22 | 23 | console.log(`Satisfeito, chega de petiscos por hoje!`) 24 | 25 | // Exemplo aluno - extra 26 | 27 | const alimentarDog = (quantidadePetiscos) => { 28 | for (let i = 1; i <= quantidadePetiscos; i++) { 29 | console.log(i < quantidadePetiscos ? `Ganhei ${i} petisco. Quero mais!` : 'Agora estou satisfeito!'); 30 | } 31 | } 32 | 33 | alimentarDog(4) 34 | 35 | // Exemplo de aluno 36 | 37 | // function alimentar(...treats) { 38 | // let chance = 0; // Starting chance of being full 39 | // let isFull = false; 40 | 41 | // for (let i = 0; i < treats.length; i++) { 42 | // chance += 5; // Increase the chance by 5% per treat 43 | // const random = Math.random() * 100; // Random number between 0 and 100 44 | 45 | // console.log(`Petisco ${i + 1}: Cachorro comeu "${treats[i]}". Chance de estar cheio: ${chance}%.`); 46 | 47 | // if (random < chance) { 48 | // console.log("O cachorro está cheio!"); 49 | // isFull = true; 50 | // break; 51 | // } else { 52 | // console.log("O cachorro ainda está com fome!"); 53 | // } 54 | // } 55 | 56 | // if (!isFull) { 57 | // console.log("Comeu todos os petiscos, mas ainda está com fome!"); 58 | // } 59 | // } 60 | 61 | // // Example usage: 62 | // alimentar("Biscoito", "Galinha", "Porco", "Queijo", "Ração"); 63 | 64 | -------------------------------------------------------------------------------- /exercicios/09-exercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Entregador de brinquedos para os dogs 4 | 5 | Dado que você tenha uma lista de brinquedos com: Bola, Osso, Corda, Sino 6 | Crie um script que passe pela lista de brinquedos e entregue um por vez. 7 | Exiba o nome de cada brinquedo que for entregue. 8 | 9 | Use a estrutura de repetição forEach. 10 | 11 | Extra: transforme a lógica em uma função (da forma que conseguir) 12 | 13 | */ 14 | 15 | const brinquedos = [ 16 | 'Bola', 17 | 'Osso', 18 | 'Corda', 19 | 'Sino' 20 | ] 21 | 22 | brinquedos.forEach(brinquedo => { 23 | console.log(`Entregando o brinquedo - ${brinquedo}`) 24 | }) 25 | 26 | console.log(`Todos brinquedos foram entregues!`) 27 | 28 | // Exemplo de aluno 29 | 30 | const brinquedosEntregues = [] 31 | 32 | const brinquedos2 = [ 33 | 'Bola', 34 | 'Osso', 35 | 'Corda', 36 | 'Sino' 37 | ] 38 | 39 | brinquedos2.forEach(brinquedo => { 40 | console.log(`Entregando o brinquedo - ${brinquedo}`) 41 | 42 | brinquedosEntregues.push(brinquedo) 43 | }) 44 | 45 | console.log(`Todos brinquedos foram entregues! - ${brinquedosEntregues.join(',')}`) 46 | 47 | // Exemplo de aluno 48 | 49 | const brinquedosComNomeECor = [ 50 | { 51 | nome: 'Bola', 52 | cor: 'Amarela' 53 | }, 54 | { 55 | nome: 'Osso', 56 | cor: 'Cinza' 57 | } 58 | ] 59 | 60 | brinquedosComNomeECor.forEach(brinquedo => { 61 | console.log(`Entregando o brinquedo ${brinquedo.nome}, de cor ${brinquedo.cor}`) 62 | }) 63 | 64 | // --- 65 | 66 | const listaDeBrinquedosDoCachorro = [ 67 | 'Bola', 68 | 'Osso', 69 | 'Corda', 70 | 'Sino', 71 | ] 72 | 73 | listaDeBrinquedosDoCachorro.forEach(Cachorro => { 74 | console.log(Cachorro) 75 | }) 76 | 77 | // exemplo de aluno - extra 78 | 79 | function entregarBrinquedos(brinquedos) { 80 | brinquedos.forEach((brinquedo, i) => { 81 | console.log(`Entregando brinquedo ${i + 1}: ${brinquedo}`); 82 | }); 83 | } 84 | 85 | entregarBrinquedos(brinquedos) 86 | -------------------------------------------------------------------------------- /exercicios/10-exercicio-dados.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Distribuidor de petiscos 4 | 5 | Você tem uma lista de cães: Pantera, Luna e Thor 6 | Crie um script que "entregue" 1 petisco para cada cão da lista. 7 | Exiba uma mensagem como: "Entregando petisco para Pantera" 8 | 9 | Mantenha os dados e a função em arquivos separados; use modularização para organizar. 10 | 11 | */ 12 | 13 | const DOGS = ['Pantera', 'Luna', 'Thor'] 14 | const CATS = ['Mimosa', 'Lessy', 'Frajola', 'Mingau'] 15 | 16 | export { 17 | DOGS, 18 | CATS 19 | } -------------------------------------------------------------------------------- /exercicios/10-exercicio-funcao.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Distribuidor de petiscos 4 | 5 | Você tem uma lista de cães: Pantera, Luna e Thor 6 | Crie um script que "entregue" 1 petisco para cada cão da lista. 7 | Exiba uma mensagem como: "Entregando petisco para Pantera" 8 | 9 | Mantenha os dados e a função em arquivos separados; use modularização para organizar. 10 | 11 | */ 12 | 13 | function entregarPetiscos(listaDeDogs) { 14 | listaDeDogs.forEach(dog => { 15 | console.log(`Entregando petisco para ${dog}`) 16 | }) 17 | } 18 | 19 | export { 20 | entregarPetiscos 21 | } 22 | 23 | -------------------------------------------------------------------------------- /exercicios/10-exercicio-principal.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | Distribuidor de petiscos 4 | 5 | Você tem uma lista de cães: Pantera, Luna e Thor 6 | Crie um script que "entregue" 1 petisco para cada cão da lista. 7 | Exiba uma mensagem como: "Entregando petisco para Pantera" 8 | 9 | Mantenha os dados e a função em arquivos separados; use modularização para organizar. 10 | 11 | */ 12 | 13 | import { CATS, DOGS } from './10-exercicio-dados.js' 14 | import { entregarPetiscos } from './10-exercicio-funcao.js' 15 | 16 | entregarPetiscos(DOGS) 17 | entregarPetiscos(CATS) 18 | 19 | -------------------------------------------------------------------------------- /index.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Console API 3 | */ 4 | 5 | console.log("Aula inicial JS") 6 | console.error("Falha na execução") 7 | console.warn("Atenção") 8 | console.table([{ 9 | nome: 'Samuel', 10 | turma: '02', 11 | disciplina: 'Prog JS' 12 | }, 13 | { 14 | nome: 'Lucas', 15 | turma: '02', 16 | disciplina: 'Prog JS' 17 | }]) 18 | 19 | /** 20 | * Constantes e Variáveis 21 | */ 22 | 23 | // const - para informações que nunca mudam 24 | // var ou let - para informações que podem mudar 25 | 26 | // informacoes de um dog que nao mudam 27 | const nome = 'Loki' 28 | const raca = 'SRD / vira lata' 29 | const sexo = 'Macho' 30 | const cor = 'Caramelo' 31 | const dataDeNascimento = '01/01/2020' 32 | const porte = 'M' 33 | 34 | // informacoes que mudam 35 | let idade = 5 // Number 36 | let peso = 10.5 // Number 37 | let vacinado = true // Boolean 38 | let castrado = false // Boolean 39 | let tamanho = 'M' // String 40 | 41 | // hoisting -> içamento ou elevação 42 | 43 | const irmaos = [ 44 | { 45 | nome: "Thor", 46 | idade: 2 47 | }, 48 | { 49 | nome: "Hela", 50 | idade: 3 51 | } 52 | ] 53 | 54 | console.table(irmaos) 55 | 56 | /** 57 | * Tipos de Dados - cadeia, inteiro, real, logico, vetor, matriz 58 | * (funcoes - leia e escreva) 59 | * 60 | 61 | String - cadeia 62 | Number - inteiros/real 63 | Boolean - logico 64 | Array - vetor/matriz 65 | 66 | undefined 67 | null 68 | 69 | BigInt = Number para números extremamente grandes 70 | Symbol = 'identificador único' 71 | 72 | */ 73 | 74 | // const valor = "50" 75 | 76 | // console.log(valor) 77 | 78 | 79 | /** 80 | * Strings 81 | */ 82 | 83 | // 'Turma 02 do PGATS' - aspas simples ou single quote 84 | // "Turma 02 do PGATS" - aspas duplas ou double quote 85 | // `Turma 02 do PGATS` - template strings 86 | 87 | const numeroAula = "03" 88 | const turma = "02" 89 | let data = "05 de Abril" 90 | 91 | console.log("Aula 03 da Turma " + turma + " no Sábado dia 05 de Abril") 92 | 93 | console.log(`Aula ${ numeroAula } da Turma ${ turma } no Sábado dia ${ data }`) 94 | 95 | console.log(data.length) 96 | 97 | // split - separar a string 98 | const nomesDeAlunos = "Giuliana André Goku Lucas Lenilson" 99 | 100 | const nomesDeAlunosSplit = nomesDeAlunos.split(" ") 101 | 102 | console.log(nomesDeAlunosSplit) 103 | 104 | console.log(nomesDeAlunos.toLowerCase()) // minúsculo 105 | console.log(nomesDeAlunos.toUpperCase()) // maiúsculo 106 | 107 | console.log(nomesDeAlunos.includes("G")) 108 | 109 | // Chai - biblioteca de asserções 110 | 111 | console.log(nomesDeAlunos.replaceAll('a', 'i')) 112 | 113 | const conceitosLogica = " inteiro real cadeia de caracteres... " 114 | 115 | console.log(conceitosLogica.trim()) 116 | 117 | 118 | let dataParaCortar = "05 de Abril" 119 | const cpf = "86189924611" 120 | 121 | console.log(dataParaCortar.slice(0, 2)) 122 | console.log(cpf.slice(0, 3)) 123 | 124 | // 05 de Abril 125 | // 0123456789 -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "pgats-programacao", 3 | "version": "1.0.0", 4 | "description": "", 5 | "main": "index.js", 6 | "type": "module", 7 | "scripts": { 8 | "test": "echo \"Error: no test specified\" && exit 1" 9 | }, 10 | "keywords": [], 11 | "author": "", 12 | "license": "ISC", 13 | "devDependencies": { 14 | "mocha": "^11.2.2" 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testes/01-testes.js: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | describe -> agrupador de testes 4 | it -> implementação do teste 5 | 6 | TDD 7 | crio o teste 8 | vejo o teste falhar 9 | crio a implementaçào para o teste passar 10 | rodo o teste denovo 11 | refatoro o código para melhorar ... 12 | 13 | ASSERTION/ASSERCAO 14 | verificar se um comportamento está de acordo com o esperado 15 | 16 | */ 17 | 18 | import { exibirNomeDogFormatado } from '../conceitos/testes-de-unidade.js' 19 | import assert from 'node:assert' 20 | 21 | describe('Testes do Projeto', () => { 22 | it(`deve exibir o nome do dog com letras maiúsculas`, () => { 23 | assert.strictEqual(exibirNomeDogFormatado('Mimosa'), 'MIMOSA') 24 | 25 | // verifique se: É IGUAL A 26 | }) 27 | 28 | it('primeiro teste', () => { 29 | 30 | }) 31 | 32 | it('segundo teste', () => { 33 | throw new Error() 34 | }) 35 | 36 | }) -------------------------------------------------------------------------------- /trabalho.js: -------------------------------------------------------------------------------- 1 | function geradorDeTagsDeIdentificacao(nome) { 2 | return 'PANTERA' 3 | } --------------------------------------------------------------------------------