Pular para conteúdo

Anotações Javascript

Algumas anoteções sobre meus estudos da linguagem JavaScript.

Variáveis🔗

Não começar nome de uma variável com número, ou colocar espaço. usar o camelCase uma variável Carro é deferente de carro, as letra maiúsculas e minúsculas importam

// definer uma variável
let idade = 20
var nome = 'Caio'

// trocar o valor de uma variável
idade = 24

Constantes🔗

Constantes não poder ter o seu valor mudado

// definir uma constante
const nome = 'João Vitor'

Tipos🔗

String🔗

let nome = 'Gilda' // string literal

Number🔗

let idade = 21 // number literal
let peso = 65.30 // number literal

Undefined🔗

let sobrenome = undefined // undefined

Boolean🔗

true
false

Object🔗

let corSelecionada = null // object: redefinir um valor

let pessoa = {
  nome: 'Gilda',
  idade: 21,
  peso: 65.30,
  estaAprovado: true,
  sobrenome: undefined
}

pessoa.nome      // 'Gilda'
pessoa['idade']  // 21

Class🔗

class Pessoa {
  constructor(nome, idade, peso, estaAprovado, sobrenome) {
    this.nome = nome
    this.idade = idade
    this.estaAprovado = estaAprovado
    this.sobrenome = sobrenome
  }

  nomeCompleto() {
    return `${this.nome} ${this.sobrenome}`
  }
}


let pessoa = new Pessoa('Michely', 21, 65.30, true, 'Silva')
pessoa.nome            // 'Michely'
pessoa.sobrenome       // 'Silva'
pessoa.nomeCompleto()  // 'Michely Silva'

Array🔗

let numeros = [1, 34, 34, 234, 123]
let familia = [true, 45, 'Marília', [123, undefined]]

numeros[3]     // 234
familia[3][0]  // 123

Operadores🔗

Operadores de Atribuição🔗

let contador = 1

// contador = contador + 1
contador += 1

// contador = contador - 1
contador -= 1

Operadores Aritiméticos🔗

Operador Função
+ soma
- subtração
* multiplicação
/ divisão
** exponênciação
% resto da divisão

Faz a operação antes ou depois de retornar o valor que já tem. Se estiver antes da variável, realiza antes de retornar. Se estiver depois da variável, realiza depois de retornar.

++ : incremento -- : decremento

let idadeUm = 18

--idadeUm  // 17
idadeUm    // 17


let idadeDois = 45

idadeDois--  // 45
idadeDois    // 44


let idadeTres = 34

++idadeTres  // 35
idadeTres    // 35


let idadeQuatro = 59

idadeQuatro++  // 59
idadeQuatro    // 60

Operadores de Igualdade🔗

Igualdade estrita. Compara os valorese os tipos

1 === 1   // true
'1' === 1 // false

Igualdade solta. Compara somente os valores

1 == 1   // true
'1' == 1 // true

Operadores Lógicos🔗

e - &&

true && true   // true
true && false  // false
false && true  // false
false && false // false

ou - ||

true || true   // true
true || false  // true
false || true  // true
false || false // false

não - !

!true  // false
!false // true

Operador Ternário🔗

let mensalidade = 20

// <expressão lógica> ? <se true> : <se false>
let tipo = mensalidade > 30 ? 'premium' : 'comum'

Comparações Não Boleanas🔗

Falsy

  • undefined
  • null
  • 0
  • false
  • ''
  • NaN - not a number

Truthy

  • string
  • number
  • true
  • object
  • array

Operadores Condicionais🔗

if, else, else if🔗

if (1 >= 2) {
  console.log(1)
} else if (2 >= 3) {
  console.log(2)
} else {
  console.log(3)
}

switch case🔗

let usuario = 'comum'

switch (usuario) {
  case 'comum':
    console.log('Usuário comum')
    break
  case 'gerente':
    console.log('Usuário gerente')
    break
  case 'diretor':
    console.log('Usuário diretor')
    break
  default:
    console.log('Você estuda aqui?')
}

Laços de Repetição🔗

for🔗

for (let index = 1; index <= 5; index++) {
  console.log(`index = ${index}`)
}

// index = 1
// index = 2
// index = 3
// index = 4
// index = 5

for (let numero = 1; numero <= 10; numero++) {
  if (! (numero % 2)) {
    console.log(`par = ${numero}`)
  }
}

// par = 2
// par = 4
// par = 6
// par = 8
// par = 10

for (let numero = 10; numero >= 1; numero--) {
  if (! (numero % 2)) {
    console.log(`par = ${numero}`)
  }
}

// par = 10
// par = 8
// par = 6
// par = 4
// par = 2

while🔗

let numero = 10

while (numero >= 1) {
  if (! (numero % 2)) {
    console.log(`par = ${numero}`)
  }
  numero--;
}

// par = 8
// par = 6
// par = 4
// par = 2

do while🔗

// o do...while sempre executa o que estiver dentro do do{} antes de fazer a verificação no while
// ou seja, ele sempreexecuta pelo menos uma vez o comando

let contador = 0

do {
  console.log(`Contador ${contador}`);
  contador++
} while (contador <= 10)

// Contador 0
// Contador 1
// Contador 2
// Contador 3
// Contador 4
// Contador 5
// Contador 6
// Contador 7
// Contador 8
// Contador 9
// Contador 10

for in🔗

var obj = {a: 1, b: 2, c: 3};

for (const prop in obj) {
  console.log(`${prop} = ${obj[prop]}`);
}

// "a = 1"
// "b = 2"
// "c = 3"

for of🔗

const array = ['a', 'b', 'c'];

for (const element of array) {
  console.log(element);
}

// "a"
// "b"
// "c"

const iterable = [10, 20, 30];

for (let value of iterable) {
  value += 1;
  console.log(value);
}

// 11
// 21
// 31

Funções🔗

Function🔗

let corSite = 'Azul'

// verbo + substantivo
function resetaCor() {
  corSite = ''
}

// com argumentos
function resetaCor2(cor) {
  corSite = cor
}

function resetaCor3(cor, tonalidade) {
  // corSite = cor + ' '  + tonalidade
  corSite = `${cor} ${tonalidade}`
}

resetaCor2('Rosa')
corSite  // 'Rosa'

resetaCor3('azul', 'marinho')
corSite  // 'azul marinho'

function soma(x, y) {
  return x + y
}

function soma(x, y = 3) {
  return x + y
}

const soma = function _soma(x, y) {
  return x + y
}


const fatorial = function fat(n) { return n < 2 ? 1 : n * fat(n - 1) }

// Rest parameters
function multiply(multiplier, ...args) {
  return args.map(x => multiplier * x);
}

Funções aninhadas e closures🔗

function addSquares(a, b) {
  function square(x) {
    return x * x;
  }
  return square(a) + square(b);
}

function A(x) {
  function B(y) {
    function C(z) {
      console.log(x + y + z);
    }
    C(3);
  }
  B(2);
}

function outside() {
  let x = 5;
  function inside(y) {
    return x * y;
  }
  return inside;
}

Arrow Function🔗

(x, y) => {
  return x + y
}

x => x * x

// Múltiplos parâmetros requer parênteses
(x, y) => x + y

// Parâmetros default são suportados
(x, y=2) => x + y

// Destructuring dentro dos parâmetros são suportadossuportados
([a, b] = [10, 20]) => a + b
({ a, b } = { a: 10, b: 20 }) => a + b


let soma = (x, y) => x + y

Comentários