Bỏ qua nội dung
Môn học
  • 1 Bắt đầu
    1.1

    Chương trình đầu tiên của bạn

    Một chương trình là danh sách các lệnh dành cho máy tính. Trong JavaScript, mỗi lệnh là một câu lệnh, và máy tính chạy các câu lệnh từ trên xuống dưới.

    console.log(...) in một giá trị ra console, khu vực văn bản nằm dưới phần mã:

    console.log("Hello, world!");
    console.log(7 * 6);   // 42
    
    • Văn bản đi vào trong dấu ngoặc kép: "Hello" hoặc 'Hello'. Số thì không cần.
    • Kết thúc mỗi câu lệnh bằng dấu chấm phẩy ;. JavaScript thường có thể đoán được nơi thiếu dấu chấm phẩy, nhưng việc viết nó rõ ràng hơn.
    • JavaScript phân biệt hoa/thường: console.log hoạt động, Console.Log thì không.

    console.log có thể in nhiều giá cùng lúc. Nó đặt một khoảng trắng giữa chúng:

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

    Nhận xét & phong cách viết mã

    Một comment là ghi chú dành cho người đọc. JavaScript bỏ qua khi chương trình chạy.

    // 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");
    

    Phong cách tốt giúp mã dễ đọc hơn:

    • Thụt lề các dòng bên trong { } hai hoặc bốn khoảng trắng, và làm tương tự mỗi lần.
    • Đặt tên biến sao cho mô tả đúng giá trị chúng chứa: total, chứ không phải t.
    • Tên biến JavaScript dùng camelCase: firstName, scoreTotal.
    // Work out the area of a rectangle
    const width = 4;
    const height = 3;
    console.log(width * height);   // 12
    

    Lỗi thường gặp

    • Văn bản cần dấu ngoặc kép khớp nhau: "Hi' là lỗi.
    • console.log phải viết toàn bộ chữ thường: Console.log và console.Log là lỗi.
    • Everything sau // trên một dòng bị bỏ qua, nên // console.log(x) sẽ không in gì.
  • 2 Giá trị, biến & kiểu dữ liệu
    2.1

    let và const

    A variable 变量 is a named box that holds a value. Make one with let or const, then use its name:

    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
    
    • = means assign 赋值: work out the right side, then store it in the box on the left.
    • Use const by default. Use let only when the value must change later.
    • Reassigning a const is an error: name = "Tom" is not allowed. A const object or array can still have its contents changed.
    2.2

    Số & toán học

    These examples use the number type for whole and decimal values. BigInt is a separate integer type. The arithmetic operators 运算符 are:

    Operator Meaning Example Result
    + - add, subtract 7 - 2 5
    * / multiply, divide 7 / 2 3.5
    % remainder 余数 7 % 2 1
    ** power 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
    
    Seven dots grouped into three pairs with one dot left over, beside Math.floor of 7 over 2 equals 3, 7 percent 2 equals 1 and 7 over 2 equals 3.5
    Seven shared into pairs: three whole pairs, one left over.

    Math holds useful functions:

    console.log(Math.round(2.5));    // 3
    console.log(Math.max(4, 9, 2));  // 9
    console.log(Math.sqrt(49));      // 7
    
    • Math.random() gives a random 随机 number from 0 up to (not including) 1. Math.floor(Math.random() * 6) + 1 is a dice roll from 1 to 6.
    • Decimals are stored in binary, so 0.1 + 0.2 prints 0.30000000000000004. Round a result before you show it: (0.1 + 0.2).toFixed(2) is "0.30".
    2.3

    Kiểu & chuyển đổi

    Every value has a type 类型. typeof tells you which:

    console.log(typeof 42);         // number
    console.log(typeof "42");       // string
    console.log(typeof true);       // boolean
    console.log(typeof undefined);  // undefined
    
    • A variable made with let x; and no value is undefined.
    • null means "no value", set on purpose.

    + with a string joins instead of adding, so convert 转换 text to a number first:

    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!
    
    • A text that is not a number gives NaN ("not a number"): Number("abc") is NaN.
    • -, * and / convert text to a number by themselves ("6" * 2 is 12), but do not rely on it: convert on purpose.

    Common mistakes

    • = assigns; it does not compare. Comparing uses === (topic 4).
    • "5" + 1 is "51". Convert input with Number(...) before doing maths with it.
    • Math.round(2.5) is 3, but Math.round(-2.5) is -2: it rounds halves up, towards the larger number.
  • 3 Chuỗi ký tự
    3.1

    Ký tự & độ dài

    Một chuỗi (string) là văn bản nằm trong dấu ngoặc kép. Với các chữ cái đơn giản, mỗi ký tự có một vị trí duy nhất, được gọi là chỉ mục; chỉ mục đầu tiên là 0. JavaScript đếm các đơn vị mã UTF-16: một biểu tượng cảm xúc có thể chiếm hai vị trí.

    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
    
    • Chỉ mục cuối cùng là length - 1. word[6] là undefined, không phải lỗi.
    • Chuỗi không thể thay đổi: word[0] = "s" không thể sửa đổi chuỗi và sẽ gây ra lỗi TypeError trong chế độ nghiêm ngặt. Hãy tạo một chuỗi mới thay thế.

    Ghép chuỗi bằng +, quá trình này được gọi là nối chuỗi:

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

    Các phương thức String

    Một phương thức (method) là một hàm thuộc về một giá trị. Gọi nó bằng dấu chấm. Một phương thức của chuỗi trả về một giá trị mới và giữ nguyên giá trị gốc.

    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)
    
    Phương thức Ý nghĩa Ví dụ Kết quả
    .toUpperCase() / .toLowerCase() thay đổi chữ hoa/thường "Hi".toLowerCase() "hi"
    .trim() xóa khoảng trắng ở cả hai đầu " hi ".trim() "hi"
    .includes(t) có chứa t không? "cat".includes("a") true
    .indexOf(t) vị trí đầu tiên của t, hoặc -1 nếu không tìm thấy "cat".indexOf("t") 2
    .slice(a, b) lấy các ký tự từ a trở đi đến (không bao gồm) b "Script".slice(0, 3) "Scr"
    .split(sep) chia thành mảng "a,b,c".split(",") ["a","b","c"]
    .replace(a, b) thay thế a ký tự đầu tiên bằng 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

    Literal mẫu (Template literals)

    Một literal mẫu là chuỗi được viết giữa các dấu backtick (trên hầu hết bàn phím, là phím bên trái 1). Đặt bất kỳ biểu thức nào bên trong ${ } và giá trị của nó sẽ được chèn vào văn bản:

    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
    
    • Dấu backtick cũng có thể chứa nhiều dòng văn bản.
    • Điều này dễ đọc hơn nhiều so với việc dùng nhiều +: hãy so sánh "Hi " + name + "!" với `Hi ${name}!`.
    const price = 4.5;
    console.log(`Two cost $${(price * 2).toFixed(2)}`);   // Two cost $9.00
    

    Lỗi thường gặp

    • ${ } chỉ hoạt động bên trong dấu backtick. Trong "Hi ${name}", văn bản được in ra chính xác như đã gõ.
    • Các phương thức không làm thay đổi chuỗi: gọi city.trim() trên một dòng riêng lẻ sẽ không có tác dụng gì. Hãy lưu kết quả: const clean = city.trim();.
    • slice(a, b) dừng trước b, giống như chỉ số cuối là length - 1.
  • 4 Quyết định
    4.1

    Booleans & so sánh

    Một giá trị Boolean có thể là true hoặc false. Một phép so sánh trả về một giá trị Boolean:

    Toán tử Ý nghĩa Ví dụ Kết quả
    === bằng nhau (cùng giá trị và cùng kiểu) 5 === 5 true
    !== không bằng nhau 5 !== 3 true
    < > nhỏ hơn, lớn hơn 2 > 7 false
    <= >= tối đa, tối thiểu 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)
    
    • Luôn sử dụng === và !==. Cách làm cũ == chuyển đổi kiểu dữ liệu trước rồi mới so sánh, dẫn đến kết quả khó lường.

    Đối với điều kiện Boolean, hãy sử dụng các toán tử logic bên dưới. Với các giá trị khác, && và || sẽ trả về một trong các toán hạng của chúng; chúng không phải lúc nào cũng trả về giá trị Boolean:

    • && (và): chỉ đúng khi cả hai vế đều đúng.
    • || (hoặc): đúng nếu ít nhất một vế là đúng.
    • ! (không đảo): biến true thành false và ngược lại.
    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

    Cấu trúc if chạy một khối mã lệnh khi điều kiện của nó có giá trị chân thực (được xem là đúng). Với điều kiện Boolean, điều này có nghĩa là giá trị true. else if kiểm tra thêm một điều kiện nữa; else bắt giữ mọi trường hợp còn lại:

    const mark = 72;
    if (mark >= 80) {
      console.log("A");
    } else if (mark >= 60) {
      console.log("B");
    } else {
      console.log("C");
    }
    // prints B
    
    • JavaScript kiểm tra các điều kiện từ trên xuống dưới và chỉ chạy nhánh đầu tiên thỏa mãn.
    • Điều kiện nằm trong ngoặc tròn; mã lệnh cần chạy nằm trong ngoặc nhọn { }.

    Vì vậy thứ tự rất quan trọng. Hãy đặt phép kiểm tra chặt chẽ nhất lên đầu:

    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

    công tắc

    Cấu trúc switch so sánh một giá trị với nhiều trường hợp cố định. Nó gọn gàng hơn một chuỗi dài else if khi mỗi phép kiểm tra đều là "có phải bằng …?":

    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 so sánh với ===, do đó case 1: không khớp với chuỗi "1".
    • break kết thúc switch. Nếu thiếu nó, mã lệnh sẽ chảy xuống vào trường hợp tiếp theo.
    • default được thực thi khi không có trường hợp nào khớp, giống như một else cuối cùng.
    • Hai trường hợp không có mã lệnh nào giữa chúng sẽ chia sẻ cùng một đoạn mã, ví dụ như "Sat" và "Sun" ở đây.

    Lỗi thường gặp

    • if (x = 5) gán thay vì so sánh, nên điều kiện kiểm tra luôn đúng. Hãy viết if (x === 5).
    • if (age > 13 && < 19) là một lỗi: lặp lại biến, age > 13 && age < 19.
    • Việc thiếu break trong một switch sẽ khiến trường hợp tiếp theo cũng được thực thi.
  • 5 Vòng lặp
    5.1

    Vòng lặp for

    Ba phần của vòng lặp for và thứ tự chúng chạy

    Một vòng lặp lặp lại một khối mã. Một vòng lặp for phù hợp nhất khi bạn biết trước số lần lặp. Các ngoặc vuông chứa ba phần, cách nhau bởi dấu chấm phẩy:

    for (let i = 1; i <= 3; i++) {
      console.log(i);
    }
    // 1
    // 2
    // 3
    
    1. start: let i = 1 chạy một lần, trước vòng lặp.
    2. điều kiện: i <= 3 được kiểm tra trước mỗi lần lặp; vòng lặp dừng lại khi điều kiện này sai.
    3. bước nhảy: i++ (cộng 1 vào i) chạy sau mỗi lần lặp.

    Mỗi lần chạy qua vòng lặp được gọi là một lần lặp. Thay đổi bước nhảy để đếm theo cách khác:

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

    Mẫu tích lũy tạo ra một biến trước vòng lặp và cập nhật nó trong mỗi lần lặp:

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

    Vòng lặp while

    Một vòng lặp while lặp lại khi điều kiện của nó còn đúng. Sử dụng nó khi bạn không biết trước số lần lặp cần thiết:

    let money = 100;
    let years = 0;
    while (money < 200) {
      money = money * 1.1;   // 10% interest each year
      years++;
    }
    console.log(years);      // 8
    
    • Điều kiện được kiểm tra trước mỗi lần lặp, nên thân vòng lặp có thể không bao giờ chạy.
    • Nếu điều kiện vẫn đúng và không có break hay điểm thoát nào khác được thực hiện, bạn sẽ gặp vòng lặp vô hạn. (Nhấn Dừng nếu điều đó xảy ra.)
    5.3

    for...of, break & continue

    for...of duyệt qua từng mục của mảng (hoặc từng ký tự của chuỗi) lần lượt, mà không cần quản lý chỉ số:

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

    break thoát ngay khỏi vòng lặp; continue bỏ qua phần còn lại của lượt hiện tại và chuyển sang lượt tiếp theo:

    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
    

    Lỗi thường gặp

    • Lỗi lệch một đơn vị: i < 3 chạy cho 0, 1, 2; i <= 3 chạy thêm một lần nữa. Hãy đếm số lần lặp.
    • Khởi tạo tổng bên trong vòng lặp: let total = 0; phải nằm trước vòng lặp, nếu không nó sẽ bị đặt lại giá trị ở mỗi lần lặp.
    • Một vòng lặp while sẽ chạy mãi mãi nếu điều kiện của nó luôn đúng và không có điểm thoát nào được thực hiện.
  • 6 Hàm số
    6.1

    Tham số & giá trị trả về

    Hàm là một đoạn mã có thể tái sử dụng. Khai báo hàm giúp đặt tên cho nó, để bạn có thể gọi:

    function greet(name) {
      return `Hello, ${name}!`;
    }
    
    console.log(greet("Mei"));   // Hello, Mei!
    console.log(greet("Tom"));   // Hello, Tom!
    
    • name là tham số: một biến nhận giá trị khi hàm được gọi.
    • "Mei" là đối số: giá trị thực tế được truyền vào.
    • return gửi lại giá trị cho nơi gọi và kết thúc hàm ngay lập tức.

    Một hàm thông thường đạt đến cuối mà không trả về giá trị sẽ trả về undefined. Vì vậy trả về kết quả, và để nơi gọi quyết định có in ra hay không:

    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

    Hàm mũi tên

    Hàm mũi tên là cách viết ngắn gọn hơn cho hàm. Lưu nó trong một const:

    const square = (n) => n * n;
    const add = (a, b) => a + b;
    
    console.log(square(5));      // 25
    console.log(add(2, 3));      // 5
    
    • Với một biểu thức sau =>, giá trị của nó sẽ được trả về mà không cần viết return.
    • Khi dùng ngoặc nhọn, bạn cần thêm return nữa:
    const grade = (mark) => {
      if (mark >= 50) {
        return "pass";
      }
      return "fail";
    };
    console.log(grade(64));      // pass
    

    Hàm mũi tên thường được truyền đến các hàm khác, như bạn sẽ thấy với map và filter trong chủ đề 7.

    6.3

    Phạm vi

    Phạm vi của một biến là phần mã có thể nhìn thấy nó. Biến được tạo bằng let hoặc const bên trong { } có thể truy cập trong khối đó và các phạm vi lồng nhau. Hàm lồng có thể giữ quyền truy cập sau khi hàm ngoài trả về:

    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)
    
    • Biến được tạo bên trong hàm là biến cục bộ; mỗi lần gọi sẽ có một biến mới.
    • Truyền giá trị vào qua tham số và nhận kết quả ra qua return, thay vì thay đổi biến ngoài từ bên trong hàm.

    Lỗi thường gặp

    • Quên return: hàm tính toán ra đáp án, sau đó trả về undefined.
    • Gọi mà không có dấu ngoặc: greet chính là bản thân hàm; greet("Mei") thực thi nó.
    • In nội dung trong hàm và in kết quả trả về sẽ in hai lần, hoặc in undefined.
  • 7 Mảng
    7.1

    Tạo & thay đổi mảng

    Mảng chứa danh sách các giá trị theo thứ tự, nằm trong ngoặc vuông. Mỗi mục là một phần tử, và chỉ số đầu tiên là 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 ngăn bạn gán scores một mảng hoàn toàn mới, nhưng bạn vẫn có thể thay đổi những gì ở bên trong nó.
    • Đọc vượt quá cuối trả về undefined: scores[3] là undefined.

    Thêm và xóa ở cuối với push và 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
    

    Mảng có thể chứa các mảng. Điều này tạo thành một lưới, truy xuất bằng hai chỉ số, hàng trước:

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

    map, filter & reduce

    Các phương thức này nhận một hàm và áp dụng nó vào các phần tử của mảng. Chúng trả về một mảng mới (hoặc giá trị) mà không thay thế các mục ban đầu. Hàm bạn truyền vào vẫn có thể thay đổi mảng gốc hoặc các đối tượng của nó:

    • map tạo ra một mảng mới bằng cách thay đổi mọi phần tử.
    • filter giữ lại chỉ những phần tử mà tại đó hàm trả về true.
    • reduce gộp tất cả các phần tử thành một giá trị duy nhất, chẳng hạn như tổng.
    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
    

    Trong reduce, sum là bộ tích lũy. Nó bắt đầu từ đối số cuối cùng (0) và nhận kết quả của hàm sau mỗi phần tử.

    7.3

    Tìm kiếm & Sắp xếp

    sort() không có hàm so sánh sẽ sắp xếp số dưới dạng văn bản
    Phương thức Trả về Ví dụ với [5, 8, 2] Kết quả
    .includes(x) true hoặc false .includes(8) true
    .indexOf(x) chỉ số đầu tiên của x, hoặc -1 .indexOf(2) 2
    .find(f) phần tử đầu tiên mà f là true .find((n) => n > 6) 8
    .findIndex(f) chỉ số của nó, hoặc -1 .findIndex((n) => n > 6) 1

    sort sắp xếp các phần tử theo thứ tự. Không có hàm nào, nó sắp xếp chúng dưới dạng văn bản, nên các con số sẽ bị sắp xếp sai thứ tự:

    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]
    
    • Hàm so sánh trả về số âm khi a nên đến trước, và số dương khi b nên đến trước.
    • sort thay đổi trực tiếp mảng. [...nums] tạo bản sao trước, do đó nums giữ nguyên thứ tự của nó.

    Lỗi thường gặp

    • Phần tử cuối cùng là arr[arr.length - 1], không phải arr[arr.length].
    • map và filter không thay đổi mảng: hãy lưu kết quả của chúng.
    • nums.sort() trên số sắp xếp chúng như văn bản. Hãy truyền (a, b) => a - b.
  • 8 Đối tượng
    8.1

    Đối tượng & thuộc tính

    Một đối tượng nhóm các giá trị liên quan dưới các tên. Mỗi cặp tên-giá trị là một thuộc tính. Tên được gọi là khóa:

    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)
    
    • Đọc một thuộc tính bằng dấu chấm (pupil.age) hoặc bằng ngoặc vuông (pupil["age"]). Sử dụng ngoặc vuông khi khóa nằm trong biến: pupil[field].
    • Một khóa không tồn tại sẽ trả về undefined.

    Thay đổi một thuộc tính, hoặc thêm mới, bằng cách gán giá trị cho nó:

    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

    Mảng đối tượng

    Danh sách các bản ghi là một mảng đối tượng. Kết hợp nó với các phương thức mảng từ chủ đề 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
    

    Để tính tổng một thuộc tính, sử dụng reduce hoặc vòng lặp:

    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

    Lặp qua một đối tượng

    Object.keys trả về mảng các khóa, và Object.entries trả về các cặp [key, value], để bạn có thể lặp qua chúng:

    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
    

    Một đối tượng là bộ đếm tốt: hãy sử dụng mỗi thứ bạn đếm làm khóa.

    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}
    

    Lỗi thường gặp

    • pupil.field tìm kiếm một khóa tên là field. Khi khóa nằm trong biến, viết pupil[field].
    • Dấu phẩy đặt giữa các thuộc tính, không phải dấu chấm phẩy: { name: "Mei", age: 17 }.
    • for...of không thể lặp trực tiếp qua một đối tượng. Hãy lặp qua Object.keys(...) hoặc Object.entries(...).
  • 9 Lỗi
    9.1

    Đọc thông báo lỗi

    Khi JavaScript không thể tiếp tục, nó dừng lại và hiển thị lỗi. Từ đầu tiên chỉ loại lỗi; phần còn lại nói về điều gì đã sai và ở đâu. Hãy đọc nó, sau đó xem dòng mà nó đề cập đến.

    SyntaxError: missing ) after argument list
    ReferenceError: totl is not defined
    TypeError: Cannot read properties of undefined (reading 'length')
    
    Lỗi Ý nghĩa Nguyên nhân điển hình
    SyntaxError mã nguồn không được viết đúng, nên không có gì chạy thiếu dấu ngoặc hoặc dấu ngoặc kép
    ReferenceError một tên không tồn tại lỗi chính tả: totl thay vì total
    TypeError giá trị này sai kiểu so với thao tác bạn thực hiện sử dụng .length trên undefined

    Định danh chính xác có thể khác nhau giữa các trình duyệt, nhưng tên của lỗi là như nhau. Chương trình này bắt từng lỗi để in ra tên của nó:

    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
    }
    

    Một số lỗi không sinh ra thông báo gì cả, chỉ cho kết quả sai: đó là lỗi logic. Để tìm ra chúng, hãy in ra các giá trị dọc theo quá trình thực thi bằng console.log và kiểm tra bằng tay.

    9.2

    try, catch & throw

    Code có khả năng thất bại được đặt trong khối try. Nếu có lỗi xảy ra ở đó, JavaScript sẽ chuyển sang catch thay vì dừng lại, và e sẽ chứa lỗi đó:

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

    Code do bạn viết có thể tạo ra lỗi bằng throw. Điều này giúp một hàm từ chối đầu vào xấu một cách rõ ràng, thay vì trả về kết quả sai:

    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("…") tạo ra một lỗi có message là văn bản của bạn.
    • Chỉ sử dụng try quanh code thực sự có thể thất bại, chẳng hạn như đọc dữ liệu. Đừng dùng nó để che đậy những sai sót trong code của bạn.

    Lỗi thường gặp

    • Bỏ qua thông báo. Dòng đầu tiên nêu loại lỗi và điều đã đi sai; hãy bắt đầu từ đó.
    • Một catch không làm gì (catch (e) {}) sẽ ẩn đi vấn đề: ít nhất hãy in e.message.
    • throw "text" hoạt động, nhưng throw new Error("text") còn ghi lại vị trí xảy ra lỗi.

Đăng nhập hoặc tạo tài khoản

IGCSE, A-Level & AP