Pular para o conteúdo
Matérias
  • 1 Começando
    1.1

    Seu primeiro programa

    A program 程序 is a list of instructions for the computer. In JavaScript, each instruction is a statement 语句, and the computer runs the statements from top to bottom.

    console.log(...) prints a value in the console 控制台, the text area under the code:

    console.log("Hello, world!");
    console.log(7 * 6);   // 42
    
    • Text goes inside quotes: "Hello" or 'Hello'. Numbers do not.
    • End each statement with a semicolon ;. JavaScript can often guess where one is missing, but writing it is clearer.
    • JavaScript is case-sensitive 区分大小写: console.log works, Console.Log does not.

    console.log can print several values at once. It puts one space between them:

    console.log("Total:", 3 + 4);   // Total: 7
    console.log(1, 2, 3);           // 1 2 3
    
    1.2

    Comentários & estilo de código

    A comment 注释 is a note for people. JavaScript ignores it when the program runs.

    // A one-line comment starts with two slashes.
    console.log("This line runs");   // a comment can follow code
    
    /* A block comment
       can cover several lines. */
    console.log("So does this one");
    

    Good style 风格 makes code easy to read:

    • Indent 缩进 the lines inside { } by two or four spaces, and do it the same way every time.
    • Give variables names that say what they hold: total, not t.
    • JavaScript names use camelCase 驼峰命名法: firstName, scoreTotal.
    // Work out the area of a rectangle
    const width = 4;
    const height = 3;
    console.log(width * height);   // 12
    

    Common mistakes

    • Text needs matching quotes: "Hi' is an error.
    • console.log is all lower case: Console.log and console.Log are errors.
    • Everything after // on a line is ignored, so // console.log(x) prints nothing.
  • 2 Valores, variáveis e tipos
    2.1

    let e const

    Uma variável é uma caixa nomeada que armazena um valor. Crie uma com let ou const, depois use seu nome:

    let score = 10;
    score = score + 5;      // let: the value can change
    console.log(score);     // 15
    
    const name = "Mei";     // const: the name cannot be reassigned
    console.log(name);      // Mei
    
    • = significa atribuir: calcule o lado direito e armazene na caixa do lado esquerdo.
    • Use const como padrão. Use let apenas se o valor precisar ser alterado posteriormente.
    • Reatribuir a const é um erro: name = "Tom" não é permitido. Um objeto ou array const ainda pode ter seu conteúdo alterado.
    2.2

    Números & matemática

    Estes exemplos usam o tipo number para valores inteiros e decimais. BigInt é um tipo inteiro separado. Os operadores aritméticos são:

    Operador Significado Exemplo Resultado
    + - somar, subtrair 7 - 2 5
    * / multiplicar, dividir 7 / 2 3.5
    % resto da divisão 7 % 2 1
    ** potência 2 ** 3 8
    console.log(7 / 2);              // 3.5
    console.log(Math.floor(7 / 2));  // 3   (whole-number division)
    console.log(7 % 2);              // 1   (odd numbers leave 1)
    console.log(2 + 3 * 4);          // 14  (* before +)
    console.log((2 + 3) * 4);        // 20
    

    Math contém funções úteis:

    console.log(Math.round(2.5));    // 3
    console.log(Math.max(4, 9, 2));  // 9
    console.log(Math.sqrt(49));      // 7
    
    • Math.random() gera um número aleatório de 0 até (não incluindo) 1. Math.floor(Math.random() * 6) + 1 é uma rolagem de dado de 1 a 6.
    • Decimais são armazenados em binário, então 0.1 + 0.2 imprime 0.30000000000000004. Arredonde um resultado antes de exibi-lo: (0.1 + 0.2).toFixed(2) é "0.30".
    2.3

    Tipos & conversão

    Todo valor tem um tipo. typeof informa qual é:

    console.log(typeof 42);         // number
    console.log(typeof "42");       // string
    console.log(typeof true);       // boolean
    console.log(typeof undefined);  // undefined
    
    • Uma variável criada com let x; e sem valor é undefined.
    • null significa "sem valor", definido intencionalmente.

    + com uma string conecta em vez de somar, então converta texto para número primeiro:

    console.log("5" + 1);           // 51  (joined)
    console.log(Number("5") + 1);   // 6   (added)
    console.log(parseInt("12px"));  // 12  (reads the number at the start)
    console.log(String(9) + "!");   // 9!
    
    • Um texto que não é número retorna NaN ("não é um número"): Number("abc") é NaN.
    • -, * e / convertem texto para número automaticamente ("6" * 2 é 12), mas não dependam disso: faça a conversão intencionalmente.

    Erros comuns

    • = atribui; não compara. A comparação usa === (tópico 4).
    • "5" + 1 é "51". Converta a entrada com Number(...) antes de fazer matemática com ela.
    • Math.round(2.5) é 3, mas Math.round(-2.5) é -2: arredonda meados para cima, em direção ao número maior.
  • 3 Strings
    3.1

    Caracteres & comprimento

    Uma string é texto entre aspas. Com letras simples, cada caractere tem uma posição, seu índice; o primeiro índice é 0. JavaScript conta unidades de código UTF-16: um emoji pode ocupar duas posições.

    const word = "Script";
    console.log(word.length);     // 6
    console.log(word[0]);         // S
    console.log(word[2]);         // r
    console.log(word.at(-1));     // t  (counts back from the end)
    console.log(word[word.length - 1]);   // t
    
    • O último índice é length - 1. word[6] é undefined, não um erro.
    • Strings são imutáveis: word[0] = "s" não pode alterar a string e gera TypeError em modo estrito. Crie uma nova string em vez disso.

    Junte strings com +, chamado de concatenação:

    const first = "Ada";
    const last = "Lovelace";
    console.log(first + " " + last);   // Ada Lovelace
    
    3.2

    Métodos String

    Um método é uma função pertencente a um valor. Chame-o com um ponto. Um método de string retorna um novo valor e deixa o original intacto.

    const city = "  Hong Kong ";
    console.log(city.trim());                 // Hong Kong
    console.log(city.trim().toUpperCase());   // HONG KONG
    console.log(city.length);                 // 12  (the spaces are still there)
    
    Método Significado Exemplo Resultado
    .toUpperCase() / .toLowerCase() alterar caso "Hi".toLowerCase() "hi"
    .trim() remover espaços nas duas extremidades " hi ".trim() "hi"
    .includes(t) contém t? "cat".includes("a") true
    .indexOf(t) primeira posição de t, ou -1 "cat".indexOf("t") 2
    .slice(a, b) caracteres de a até (excluindo) b "Script".slice(0, 3) "Scr"
    .split(sep) dividir em array "a,b,c".split(",") ["a","b","c"]
    .replace(a, b) trocar a primeira a por b "cat".replace("c", "b") "bat"
    const email = "[email protected]";
    const at = email.indexOf("@");
    console.log(email.slice(0, at));          // mei
    console.log(email.slice(at + 1));         // school.org
    console.log(email.split("@"));            // ["mei","school.org"]
    
    3.3

    Literais de modelo

    Um literal de modelo é um texto entre crases (na maioria dos teclados, a tecla à esquerda de 1). Coloque qualquer expressão dentro de ${ } e seu valor será inserido no texto:

    const name = "Mei";
    const age = 17;
    console.log(`${name} is ${age} years old.`);   // Mei is 17 years old.
    console.log(`Next year: ${age + 1}`);          // Next year: 18
    
    • Crases também podem conter várias linhas de texto.
    • É mais legível do que muitos sinais de +: compare "Hi " + name + "!" com `Hi ${name}!`.
    const price = 4.5;
    console.log(`Two cost $${(price * 2).toFixed(2)}`);   // Two cost $9.00
    

    Erros comuns

    • ${ } só funciona dentro de crases. Em "Hi ${name}", o texto é impresso exatamente como digitado.
    • Métodos não alteram a string: city.trim() sozinho não faz nada. Armazene o resultado: const clean = city.trim();.
    • slice(a, b) para antes de b, assim como o último índice é length - 1.
  • 4 Decisões
    4.1

    Booleanos e comparações

    Um Booleano é ou true ou false. Uma comparação resulta em um Booleano:

    Operador Significado Exemplo Resultado
    === igual (mesmo valor e mesmo tipo) 5 === 5 true
    !== não igual 5 !== 3 true
    < > menor que, maior que 2 > 7 false
    <= >= no máximo, no mínimo 7 >= 7 true
    console.log(5 === 5);     // true
    console.log(5 === "5");   // false  (a number is not a string)
    console.log(5 == "5");    // true   (== converts first: avoid it)
    
    • Sempre use === e !==. O antigo == converte tipos primeiro e dá respostas surpreendentes.

    Para condições Booleanas, use os operadores lógicos abaixo. Com outros valores, && e || retornam um de seus operandos; eles nem sempre retornam um Booleano:

    • && (e): verdadeiro apenas se ambos os lados forem verdadeiros.
    • || (ou): verdadeiro se pelo menos um dos lados for verdadeiro.
    • ! (não): inverte true para false e vice-versa.
    const age = 15;
    console.log(age >= 13 && age <= 19);   // true   (a teenager)
    console.log(age < 5 || age > 65);      // false
    console.log(!(age > 18));              // true
    
    4.2

    if / else if / else

    Uma instrução if executa um bloco de código quando sua condição é truthy (tratada como verdadeira). Com condições Booleanas, isso significa o valor true. else if testa outra condição; else captura tudo o que restou:

    const mark = 72;
    if (mark >= 80) {
      console.log("A");
    } else if (mark >= 60) {
      console.log("B");
    } else {
      console.log("C");
    }
    // prints B
    
    • JavaScript verifica as condições de cima para baixo e executa apenas o primeiro ramo verdadeiro.
    • A condição vai entre parênteses redondos; o código a ser executado vai entre chaves { }.

    Portanto, a ordem importa. Coloque o teste mais estrito primeiro:

    const temp = 35;
    if (temp > 30) {
      console.log("hot");
    } else if (temp > 20) {
      console.log("warm");   // skipped: the first branch already ran
    }
    // prints hot
    
    4.3

    interruptor

    Um switch compara um valor contra vários casos fixos. É mais limpo do que uma longa cadeia else if quando todo teste é "é igual a…?":

    const day = "Sat";
    switch (day) {
      case "Sat":
      case "Sun":
        console.log("weekend");
        break;
      case "Fri":
        console.log("nearly there");
        break;
      default:
        console.log("school day");
    }
    // prints weekend
    
    • switch compara com ===, então case 1: não corresponde à string "1".
    • break encerra o switch. Sem ele, o código cai por no próximo caso.
    • default executa quando nenhum caso corresponde, como um último else.
    • Dois casos sem código entre eles compartilham o mesmo código, como "Sat" e "Sun" fazem aqui.

    Erros comuns

    • if (x = 5) atribui em vez de comparar, e o teste torna-se sempre verdadeiro. Escreva if (x === 5).
    • if (age > 13 && < 19) é um erro: repita a variável, age > 13 && age < 19.
    • Um break ausente em um switch executa também o próximo caso.
  • 5 Loops
    5.1

    loops for

    As três partes de um loop for e a ordem em que são executadas

    Um loop repete um bloco de código. Um loop for é ideal quando se sabe quantas vezes será executado. Seus colchetes contêm três partes, separadas por ponto e vírgula:

    for (let i = 1; i <= 3; i++) {
      console.log(i);
    }
    // 1
    // 2
    // 3
    
    1. inicialização: let i = 1 executa uma vez, antes do loop.
    2. condição: i <= 3 é verificada antes de cada iteração; o loop para quando ela for falsa.
    3. incremento: i++ (soma 1 a i) executa após cada iteração.

    Cada passagem pelo loop é uma iteração. Altere o passo para contar de outras formas:

    let line = "";
    for (let i = 10; i > 0; i -= 3) {
      line += i + " ";
    }
    console.log(line);   // 10 7 4 1
    

    O padrão acumulador cria uma variável antes do loop e atualiza-a em cada passagem:

    let total = 0;
    for (let n = 1; n <= 5; n++) {
      total += n;          // the same as total = total + n
    }
    console.log(total);    // 15
    
    5.2

    loops while

    Um loop while repete enquanto sua condição for verdadeira. Use-o quando não souber antecipadamente quantas passagens serão necessárias:

    let money = 100;
    let years = 0;
    while (money < 200) {
      money = money * 1.1;   // 10% interest each year
      years++;
    }
    console.log(years);      // 8
    
    • A condição é verificada antes de cada passagem, então o corpo pode não executar nenhuma vez.
    • Se a condição permanecer verdadeira e nenhum break ou outra saída for alcançado, ocorre um loop infinito. (Pressione Parar se isso acontecer.)
    5.3

    for...of, break e continue

    for...of percorre cada item de um array (ou cada caractere de uma string) sequencialmente, sem gerenciar índice:

    const fruits = ["apple", "kiwi", "plum"];
    for (const fruit of fruits) {
      console.log(fruit.toUpperCase());
    }
    // APPLE
    // KIWI
    // PLUM
    

    break sai imediatamente do loop; continue pula o restante desta passagem e prossegue para a próxima:

    const marks = [55, 80, -1, 90];
    let sum = 0;
    for (const m of marks) {
      if (m < 0) {
        break;            // -1 means "end of the data"
      }
      if (m < 60) {
        continue;         // skip a fail, keep looping
      }
      sum += m;
    }
    console.log(sum);     // 80
    

    Erros comuns

    • Erro off-by-one: i < 3 executa para 0, 1, 2; i <= 3 executa mais uma vez. Conte as passagens.
    • Iniciar o total dentro do loop: let total = 0; deve vir antes do loop, senão é resetado a cada passagem.
    • Um laço while roda infinitamente se sua condição permanecer verdadeira e nenhuma saída for alcançada.
  • 6 Funções
    6.1

    Parâmetros e retorno

    Uma função é um trecho de código reutilizável. Uma declaração de função lhe dá um nome, que você pode usar para chamá-la:

    function greet(name) {
      return `Hello, ${name}!`;
    }
    
    console.log(greet("Mei"));   // Hello, Mei!
    console.log(greet("Tom"));   // Hello, Tom!
    
    • name é um parâmetro: uma variável que recebe um valor quando a função é chamada.
    • "Mei" é o argumento: o valor real passado.
    • return devolve um valor ao chamador e encerra a função imediatamente.

    Uma função regular que atinge o final sem devolver um valor retorna undefined. Portanto, use return na resposta e deixe o chamador decidir se deve imprimi-la:

    function area(width, height) {
      return width * height;
    }
    
    const a = area(4, 3);
    console.log(a + 1);          // 13  (a returned value can be used again)
    
    6.2

    Funções de seta

    Uma função de seta é uma forma mais curta de escrever uma função. Armazene-a em um const:

    const square = (n) => n * n;
    const add = (a, b) => a + b;
    
    console.log(square(5));      // 25
    console.log(add(2, 3));      // 5
    
    • Com uma expressão após =>, seu valor é retornado sem precisar escrever return.
    • Com chaves, você precisa usar return novamente:
    const grade = (mark) => {
      if (mark >= 50) {
        return "pass";
      }
      return "fail";
    };
    console.log(grade(64));      // pass
    

    Funções de seta são frequentemente passadas para outras funções, como você verá com map e filter no tópico 7.

    6.3

    Escopo

    O escopo de uma variável é a parte do código que pode acessá-la. Uma variável declarada com let ou const dentro de { } é acessível naquele bloco e nos seus blocos aninhados. Uma função aninhada pode manter o acesso mesmo após a chamada externa retornar:

    const level = "global";
    
    function show() {
      const inside = "local";
      console.log(level);        // global  (outer variables are visible)
      console.log(inside);       // local
    }
    
    show();
    console.log(typeof inside);  // undefined  (inside does not exist out here)
    
    • Uma variável criada dentro de uma função é local; cada chamada recebe uma nova instância.
    • Passe valores para dentro como parâmetros e obtenha resultados para fora usando return, em vez de alterar variáveis externas de dentro da função.

    Erros comuns

    • Esquecer return: a função calcula a resposta, mas então retorna undefined.
    • Chamar sem parênteses: greet refere-se à própria função; greet("Mei") a executa.
    • Imprimir dentro da função e imprimir seu resultado imprime duas vezes, ou imprime undefined.
  • 7 Matrizes
    7.1

    Criando e alterando arrays

    Um array armazena uma lista de valores em ordem, dentro de colchetes. Cada item é um elemento, e o primeiro índice é 0:

    const scores = [72, 88, 95];
    console.log(scores[0]);        // 72
    console.log(scores.length);    // 3
    scores[1] = 90;                // change one element
    console.log(scores);           // [72,90,95]
    
    • const impede que você substitua scores por um novo array inteiro, mas ainda pode alterar o conteúdo interno dele.
    • Ler além do final retorna undefined: scores[3] é undefined.

    Adicione e remova no final usando push e pop:

    const queue = ["Ann", "Ben"];
    queue.push("Cai");             // add to the end
    console.log(queue);            // ["Ann","Ben","Cai"]
    const last = queue.pop();      // remove from the end and return it
    console.log(last);             // Cai
    console.log(queue.length);     // 2
    

    Um array pode conter arrays. Isso cria uma grade, lida com dois índices, linha primeiro:

    const grid = [
      [1, 2, 3],
      [4, 5, 6],
    ];
    console.log(grid[1][2]);       // 6  (row 1, column 2)
    
    7.2

    map, filter e reduce

    Esses métodos recebem uma função e a aplicam aos elementos do array. Retornam um novo array (ou valor) sem substituir os itens originais. A função passada ainda pode alterar o array original ou seus objetos:

    • map cria um novo array alterando cada elemento.
    • filter mantém apenas os elementos para os quais a função retorna true.
    • reduce combina todos os elementos em um único valor, como um total.
    const prices = [4, 10, 25];
    const withTax = prices.map((p) => p * 1.1);
    console.log(withTax.map((p) => p.toFixed(2)));   // ["4.40","11.00","27.50"]
    
    const cheap = prices.filter((p) => p < 20);
    console.log(cheap);                              // [4,10]
    
    const total = prices.reduce((sum, p) => sum + p, 0);
    console.log(total);                              // 39
    

    Em reduce, sum é o acumulador. Inicia no último argumento (0) e recebe o resultado da função após cada elemento.

    7.3

    Pesquisa e ordenação

    sort() sem função de comparação ordena números como texto
    Método Retorna Exemplo com [5, 8, 2] Resultado
    .includes(x) true ou false .includes(8) true
    .indexOf(x) o primeiro índice de x, ou -1 .indexOf(2) 2
    .find(f) o primeiro elemento onde f é verdadeiro .find((n) => n > 6) 8
    .findIndex(f) seu índice, ou -1 .findIndex((n) => n > 6) 1

    sort coloca os elementos em ordem. Sem função, ordena-os como texto, então os números saem na ordem errada:

    const nums = [10, 9, 100, 1];
    console.log([...nums].sort());                   // [1,10,100,9]   (as text!)
    console.log([...nums].sort((a, b) => a - b));    // [1,9,10,100]
    console.log([...nums].sort((a, b) => b - a));    // [100,10,9,1]
    
    • A função de comparação retorna um número negativo quando a deve vir primeiro, e um positivo quando b deve.
    • sort altera o próprio array. [...nums] faz uma cópia primeiro, assim nums mantém sua ordem.

    Erros comuns

    • O último elemento é arr[arr.length - 1], não arr[arr.length].
    • map e filter não alteram o array: armazene seu resultado.
    • nums.sort() sobre números os ordena como texto. Passe (a, b) => a - b.
  • 8 Objetos
    8.1

    Objetos e propriedades

    Um objeto agrupa valores relacionados sob nomes. Cada par nome-valor é uma propriedade. O nome é chamado de chave:

    const pupil = {
      name: "Mei",
      age: 17,
      form: "11A",
    };
    console.log(pupil.name);       // Mei
    console.log(pupil["form"]);    // 11A  (bracket form, with the key as a string)
    
    • Leia uma propriedade com um ponto (pupil.age) ou com colchetes (pupil["age"]). Use colchetes quando a chave estiver em uma variável: pupil[field].
    • Uma inexistente retorna undefined.

    Altere uma propriedade ou adicione uma nova atribuindo-a:

    const pupil = { name: "Mei", age: 17 };
    pupil.age = 18;                // change
    pupil.house = "Red";           // add
    console.log(pupil);            // {"name":"Mei","age":18,"house":"Red"}
    
    8.2

    Arrays de objetos

    Uma lista de registros é um array de objetos. Combine-o com os métodos de array do tópico 7:

    const pupils = [
      { name: "Mei", mark: 88 },
      { name: "Tom", mark: 64 },
      { name: "Sara", mark: 95 },
    ];
    
    const passed = pupils.filter((p) => p.mark >= 70);
    console.log(passed.map((p) => p.name));            // ["Mei","Sara"]
    
    const best = [...pupils].sort((a, b) => b.mark - a.mark)[0];
    console.log(`${best.name} has the top mark`);       // Sara has the top mark
    

    Para somar uma propriedade, use reduce ou um loop:

    const pupils = [{ mark: 88 }, { mark: 64 }, { mark: 95 }];
    let sum = 0;
    for (const p of pupils) {
      sum += p.mark;
    }
    console.log((sum / pupils.length).toFixed(1));      // 82.3
    
    8.3

    Iterando sobre um objeto

    Object.keys devolve um array das chaves, e Object.entries devolve pares de [key, value], para que você possa iterar sobre eles:

    const stock = { pens: 12, rulers: 0, books: 5 };
    
    console.log(Object.keys(stock));             // ["pens","rulers","books"]
    
    for (const [item, count] of Object.entries(stock)) {
      if (count === 0) {
        console.log(`${item}: sold out`);
      }
    }
    // rulers: sold out
    

    Um objeto funciona bem como contador: use cada item contado como chave.

    const words = ["red", "blue", "red", "red"];
    const counts = {};
    for (const w of words) {
      counts[w] = (counts[w] || 0) + 1;   // 0 the first time the key is seen
    }
    console.log(counts);                  // {"red":3,"blue":1}
    

    Erros comuns

    • pupil.field busca uma chave chamada field. Quando a chave está em uma variável, escreva pupil[field].
    • Use vírgula entre propriedades, não ponto e vírgula: { name: "Mei", age: 17 }.
    • for...of não pode iterar diretamente sobre um objeto. Itere sobre Object.keys(...) ou Object.entries(...).
  • 9 Erros
    9.1

    Lendo mensagens de erro

    Quando o JavaScript não consegue prosseguir, ele para e exibe um erro. A primeira palavra nomeia o tipo; as demais explicam o que deu errado e onde. Leia-a e verifique a linha indicada.

    SyntaxError: missing ) after argument list
    ReferenceError: totl is not defined
    TypeError: Cannot read properties of undefined (reading 'length')
    
    Erro O que significa Causa típica
    SyntaxError código mal escrito, nada roda parêntese ou aspa faltando
    ReferenceError nome inexistente erro de digitação: totl por total
    TypeError valor com tipo incorreto para a operação usar .length em undefined

    A redação exata varia entre navegadores, mas o nome do erro permanece igual. Este programa captura cada erro para imprimir seu nome:

    try {
      const total = 5;
      console.log(totl);
    } catch (e) {
      console.log(e.name);           // ReferenceError
    }
    
    try {
      const pupil = undefined;
      console.log(pupil.length);
    } catch (e) {
      console.log(e.name);           // TypeError
    }
    

    Alguns erros não geram mensagem, apenas resposta errada: erro lógico. Para identificá-lo, imprima os valores intermediários com console.log e verifique manualmente.

    9.2

    tente, pegue e lance

    Código que pode falhar vai em um bloco try. Se um erro ocorrer lá, o JavaScript pula para catch em vez de parar, e e armazena o erro:

    try {
      JSON.parse("{not valid}");
      console.log("parsed");         // skipped
    } catch (e) {
      console.log("Could not read the data");
    }
    console.log("The program carries on");
    

    Seu próprio código pode lançar um erro com throw. Isso permite que uma função recuse entradas inválidas claramente, em vez de retornar uma resposta errada:

    function average(list) {
      if (list.length === 0) {
        throw new Error("the list is empty");
      }
      return list.reduce((s, x) => s + x, 0) / list.length;
    }
    
    console.log(average([4, 6]));    // 5
    try {
      average([]);
    } catch (e) {
      console.log(`Error: ${e.message}`);   // Error: the list is empty
    }
    
    • new Error("…") cria um erro cuja message é seu texto.
    • Use try apenas ao redor de código que realmente possa falhar, como leitura de dados. Não o use para esconder erros em seu próprio código.

    Erros comuns

    • Pular a mensagem. Sua primeira linha nomeia o tipo de erro e o que deu errado; comece por aí.
    • Um catch que não faz nada (catch (e) {}) esconde o problema: pelo menos imprima e.message.
    • throw "text" funciona, mas throw new Error("text") também registra onde o erro ocorreu.

Entrar ou criar conta

IGCSE, A-Level & AP