Hướng dẫn 8 data types in javascript - 8 kiểu dữ liệu trong javascript

Một giá trị trong JavaScript luôn thuộc một loại nhất định. Ví dụ: một chuỗi hoặc một số.

Có tám loại dữ liệu cơ bản trong JavaScript. Ở đây, chúng tôi sẽ bao gồm chúng nói chung và trong các chương tiếp theo, chúng tôi sẽ nói về từng người trong số họ một cách chi tiết.

Chúng tôi có thể đặt bất kỳ loại trong một biến. Ví dụ: một biến có thể tại một thời điểm là một chuỗi và sau đó lưu trữ một số:

// no error
let message = "hello";
message = 123456;

Các ngôn ngữ lập trình cho phép những thứ như vậy, chẳng hạn như JavaScript, được gọi là gõ một cách tự động, có nghĩa là có các loại dữ liệu tồn tại, nhưng các biến không bị ràng buộc với bất kỳ loại nào trong số chúng.

Con số

Loại số đại diện cho cả số số nguyên và số nổi.

Có nhiều hoạt động cho các số, ví dụ: phép nhân

alert( 1 / 0 ); // Infinity

alert( 1 / 0 ); // Infinity

alert( 1 / 0 ); // Infinity

alert( 1 / 0 ); // Infinity

Bên cạnh các số thông thường, còn có các giá trị số đặc biệt được gọi là, cũng thuộc loại dữ liệu này:

alert( 1 / 0 ); // Infinity

alert( Infinity ); // Infinity

alert( Infinity ); // Infinity

• alert( 1 / 0 ); // Infinity

  9 đại diện cho vô cùng toán học. Đó là một giá trị đặc biệt mà LỚN lớn hơn bất kỳ số nào.

  Chúng ta có thể nhận được nó như là kết quả của sự phân chia theo 0:

  alert( 1 / 0 ); // Infinity

  Hoặc chỉ tham khảo trực tiếp nó:

  alert( Infinity ); // Infinity

• alert( Infinity ); // Infinity

  1 đại diện cho một lỗi tính toán. Nó là kết quả của một hoạt động toán học không chính xác hoặc không xác định, ví dụ:

  alert( "not a number" / 2 ); // NaN, such division is erroneous

  alert( Infinity ); // Infinity

  1 là dính. Bất kỳ hoạt động toán học nào trên

  alert( Infinity ); // Infinity

  1 trả về

  alert( Infinity ); // Infinity

  1:

  alert( NaN + 1 ); // NaN
  alert( 3 * NaN ); // NaN
  alert( "not a number" / 2 - 1 ); // NaN

  Vì vậy, nếu có một

  alert( Infinity ); // Infinity

  1 ở đâu đó trong một biểu thức toán học, nó sẽ truyền vào toàn bộ kết quả (có một ngoại lệ chỉ là một ngoại lệ:

  alert( Infinity ); // Infinity

  8 là

  alert( Infinity ); // Infinity

  9).

Hoạt động toán học an toàn

Làm toán là một người an toàn trong JavaScript. Chúng ta có thể làm bất cứ điều gì: chia cho 0, coi các chuỗi không phải là số là số, v.v.

Kịch bản sẽ không bao giờ dừng lại với một lỗi nghiêm trọng (Die Die). Tệ nhất, chúng tôi sẽ nhận được

alert( Infinity ); // Infinity

Các giá trị số đặc biệt chính thức thuộc về loại số trực tuyến. Tất nhiên chúng không phải là những con số theo nghĩa chung của từ này.

Chúng tôi sẽ thấy nhiều hơn về việc làm việc với các số trong các số chương.

Bigint

Trong JavaScript, loại số của người Viking không thể biểu thị một cách an toàn các giá trị số nguyên lớn hơn

alert( "not a number" / 2 ); // NaN, such division is erroneous

alert( "not a number" / 2 ); // NaN, such division is erroneous

alert( "not a number" / 2 ); // NaN, such division is erroneous

Nói một cách chính xác, loại số của người Viking có thể lưu trữ các số nguyên lớn hơn (lên đến

alert( "not a number" / 2 ); // NaN, such division is erroneous

alert( "not a number" / 2 ); // NaN, such division is erroneous

Ví dụ: hai số này (ngay trên phạm vi an toàn) là như nhau:

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Vì vậy, để nói, tất cả các số nguyên lẻ lớn hơn

alert( "not a number" / 2 ); // NaN, such division is erroneous

Đối với hầu hết các mục đích

alert( "not a number" / 2 ); // NaN, such division is erroneous

Loại

alert( "not a number" / 2 ); // NaN, such division is erroneous

Giá trị

alert( "not a number" / 2 ); // NaN, such division is erroneous

alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "not a number" / 2 - 1 ); // NaN

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Vì các số

alert( "not a number" / 2 ); // NaN, such division is erroneous

Những vấn đề tương thích

Ngay bây giờ,

alert( "not a number" / 2 ); // NaN, such division is erroneous

Bạn có thể kiểm tra bảng tương thích MDN Bigint để biết phiên bản nào của trình duyệt được hỗ trợ.

Sợi dây

Một chuỗi trong JavaScript phải được bao quanh bởi các trích dẫn.

let str = "Hello";
let str2 = 'Single quotes are ok too';
let phrase = `can embed another ${str}`;

Trong JavaScript, có 3 loại trích dẫn.

1. Báo giá kép:

   alert( NaN + 1 ); // NaN
   alert( 3 * NaN ); // NaN
   alert( "not a number" / 2 - 1 ); // NaN

   3.
2. Trích dẫn đơn:

   alert( NaN + 1 ); // NaN
   alert( 3 * NaN ); // NaN
   alert( "not a number" / 2 - 1 ); // NaN

   4.
3. Backticks:

   alert( NaN + 1 ); // NaN
   alert( 3 * NaN ); // NaN
   alert( "not a number" / 2 - 1 ); // NaN

   5.

Trích dẫn kép và đơn là trích dẫn đơn giản của người Viking. Thực tế, không có sự khác biệt giữa họ trong JavaScript.

Backticks là các trích dẫn chức năng mở rộng của người Viking. Chúng cho phép chúng tôi nhúng các biến và biểu thức vào một chuỗi bằng cách gói chúng trong

alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "not a number" / 2 - 1 ); // NaN

let name = "John";

// embed a variable
alert( `Hello, ${name}!` ); // Hello, John!

// embed an expression
alert( `the result is ${1 + 2}` ); // the result is 3

Biểu thức bên trong

alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "not a number" / 2 - 1 ); // NaN

alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "not a number" / 2 - 1 ); // NaN

alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "not a number" / 2 - 1 ); // NaN

Xin lưu ý rằng điều này chỉ có thể được thực hiện trong backticks. Các trích dẫn khác don lồng có chức năng nhúng này!

alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)

Chúng tôi bao gồm các chuỗi kỹ lưỡng hơn trong chuỗi chương.

Không có loại nhân vật.

Trong một số ngôn ngữ, có một loại nhân vật đặc biệt của người Viking cho một ký tự. Ví dụ, trong ngôn ngữ C và trong Java, nó được gọi là Char Char.

Trong JavaScript, không có loại như vậy. Có một loại chỉ có một loại:

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Boolean (loại logic)

Loại Boolean chỉ có hai giá trị:

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Loại này thường được sử dụng để lưu trữ các giá trị có/không:

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Ví dụ:

alert( 1 / 0 ); // Infinity

Các giá trị Boolean cũng là kết quả của sự so sánh:

alert( 1 / 0 ); // Infinity

Chúng tôi sẽ bao gồm Booleans sâu hơn trong các toán tử logic chương.

Giá trị của NULL ”

Giá trị

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Nó tạo thành một loại riêng biệt của riêng mình chỉ chứa giá trị

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Trong JavaScript,

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Nó chỉ là một giá trị đặc biệt đại diện cho không có gì, không có giá trị nào.

Mã trên nêu rõ rằng

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Giá trị "không xác định"

Giá trị đặc biệt

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Ý nghĩa của

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Nếu một biến được khai báo, nhưng không được gán, thì giá trị của nó là

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

alert( 1 / 0 ); // Infinity

Về mặt kỹ thuật, có thể gán rõ ràng

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

alert( 1 / 0 ); // Infinity

Nhưng chúng tôi không khuyên bạn nên làm điều đó. Thông thường, người ta sử dụng

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Đối tượng và biểu tượng

Loại

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Tất cả các loại khác được gọi là nguyên thủy, vì các giá trị của chúng chỉ có thể chứa một thứ duy nhất (có thể là một chuỗi hoặc một số hoặc bất cứ điều gì). Ngược lại, các đối tượng được sử dụng để lưu trữ các bộ sưu tập dữ liệu và các thực thể phức tạp hơn.

Là quan trọng, các đối tượng xứng đáng được đối xử đặc biệt. Chúng tôi sẽ đối phó với chúng sau này trong các đối tượng chương, sau khi chúng tôi tìm hiểu thêm về các nguyên thủy.

Loại

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Toán tử loại

Toán tử

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Một cuộc gọi đến

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

alert( 1 / 0 ); // Infinity

Ba dòng cuối cùng có thể cần giải thích bổ sung:

1. let str = "Hello";
   let str2 = 'Single quotes are ok too';
   let phrase = `can embed another ${str}`;

   0 là một đối tượng tích hợp cung cấp các hoạt động toán học. Chúng tôi sẽ học nó trong các số chương. Ở đây, nó chỉ phục vụ như một ví dụ về một đối tượng.
2. Kết quả của

   let str = "Hello";
   let str2 = 'Single quotes are ok too';
   let phrase = `can embed another ${str}`;

   1 là

   let str = "Hello";
   let str2 = 'Single quotes are ok too';
   let phrase = `can embed another ${str}`;

   2. Đó là một lỗi chính thức được công nhận trong

   // the "n" at the end means it's a BigInt
   const bigInt = 1234567890123456789012345678901234567890n;

   8, đến từ những ngày đầu của JavaScript và được giữ để tương thích. Chắc chắn,

   console.log(9007199254740991 + 1); // 9007199254740992
   console.log(9007199254740991 + 2); // 9007199254740992

   5 không phải là một đối tượng. Nó là một giá trị đặc biệt với một loại riêng của riêng nó. Hành vi của

   // the "n" at the end means it's a BigInt
   const bigInt = 1234567890123456789012345678901234567890n;

   8 là sai ở đây.
3. Kết quả của

   let str = "Hello";
   let str2 = 'Single quotes are ok too';
   let phrase = `can embed another ${str}`;

   6 là

   let str = "Hello";
   let str2 = 'Single quotes are ok too';
   let phrase = `can embed another ${str}`;

   7, vì

   let str = "Hello";
   let str2 = 'Single quotes are ok too';
   let phrase = `can embed another ${str}`;

   8 là một hàm. Chúng tôi sẽ nghiên cứu các chức năng trong các chương tiếp theo, nơi chúng tôi cũng sẽ thấy rằng không có loại chức năng đặc biệt nào trong JavaScript. Các chức năng thuộc loại đối tượng. Nhưng

   // the "n" at the end means it's a BigInt
   const bigInt = 1234567890123456789012345678901234567890n;

   8 đối xử với họ khác nhau, trả lại

   let str = "Hello";
   let str2 = 'Single quotes are ok too';
   let phrase = `can embed another ${str}`;

   7. Điều đó cũng đến từ những ngày đầu của JavaScript. Về mặt kỹ thuật, hành vi như vậy là chính xác, nhưng có thể thuận tiện trong thực tế.

Cú pháp

let name = "John";

// embed a variable
alert( `Hello, ${name}!` ); // Hello, John!

// embed an expression
alert( `the result is ${1 + 2}` ); // the result is 3

Bạn cũng có thể bắt gặp một cú pháp khác:

let name = "John";

// embed a variable
alert( `Hello, ${name}!` ); // Hello, John!

// embed an expression
alert( `the result is ${1 + 2}` ); // the result is 3

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Nói rõ ràng:

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Thông thường, các dấu ngoặc đơn như vậy chứa một biểu thức toán học, chẳng hạn như

let name = "John";

// embed a variable
alert( `Hello, ${name}!` ); // Hello, John!

// embed an expression
alert( `the result is ${1 + 2}` ); // the result is 3

let name = "John";

// embed a variable
alert( `Hello, ${name}!` ); // Hello, John!

// embed an expression
alert( `the result is ${1 + 2}` ); // the result is 3

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Một số người thích

let name = "John";

// embed a variable
alert( `Hello, ${name}!` ); // Hello, John!

// embed an expression
alert( `the result is ${1 + 2}` ); // the result is 3

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Bản tóm tắt

Có 8 loại dữ liệu cơ bản trong JavaScript.

• Bảy loại dữ liệu nguyên thủy:

  • alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)

    1 Đối với số lượng bất kỳ loại nào: số nguyên hoặc dấu nổi, số nguyên bị giới hạn bởi

    alert( "not a number" / 2 ); // NaN, such division is erroneous

    5.

  • alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)

    3 cho số nguyên có độ dài tùy ý.

  • console.log(9007199254740991 + 1); // 9007199254740992
    console.log(9007199254740991 + 2); // 9007199254740992

    0 cho chuỗi. Một chuỗi có thể không có ký tự hoặc nhiều ký tự, không có loại ký tự đơn riêng biệt.

  • alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)

    5 cho ________ 51/________ 52.

  • console.log(9007199254740991 + 1); // 9007199254740992
    console.log(9007199254740991 + 2); // 9007199254740992

    5 cho các giá trị không xác định - một loại độc lập có một giá trị duy nhất

    console.log(9007199254740991 + 1); // 9007199254740992
    console.log(9007199254740991 + 2); // 9007199254740992

    5.

  • console.log(9007199254740991 + 1); // 9007199254740992
    console.log(9007199254740991 + 2); // 9007199254740992

    9 cho các giá trị không được chỉ định - một loại độc lập có một giá trị duy nhất

    console.log(9007199254740991 + 1); // 9007199254740992
    console.log(9007199254740991 + 2); // 9007199254740992

    9.

  • // the "n" at the end means it's a BigInt
    const bigInt = 1234567890123456789012345678901234567890n;

    7 cho các định danh duy nhất.
• Và một loại dữ liệu không nguyên thủy:

  • // the "n" at the end means it's a BigInt
    const bigInt = 1234567890123456789012345678901234567890n;

    6 cho các cấu trúc dữ liệu phức tạp hơn.

Toán tử

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

• Thường được sử dụng là

  // the "n" at the end means it's a BigInt
  const bigInt = 1234567890123456789012345678901234567890n;

  9, nhưng

  let name = "John";
  
  // embed a variable
  alert( `Hello, ${name}!` ); // Hello, John!
  
  // embed an expression
  alert( `the result is ${1 + 2}` ); // the result is 3

  1 cũng có thể.
• Trả về một chuỗi với tên của loại, như

  alert( 1 / 0 ); // Infinity

  07.
• Đối với

  console.log(9007199254740991 + 1); // 9007199254740992
  console.log(9007199254740991 + 2); // 9007199254740992

  5 trả về

  let str = "Hello";
  let str2 = 'Single quotes are ok too';
  let phrase = `can embed another ${str}`;

  2 - đây là một lỗi trong ngôn ngữ, nó không thực sự là một đối tượng.

Trong các chương tiếp theo, chúng tôi sẽ tập trung vào các giá trị nguyên thủy và một khi chúng tôi quen thuộc với chúng, chúng tôi sẽ chuyển sang các đối tượng.

8 loại dữ liệu là gì?

7 loại dữ liệu trong JS là gì?

Các loại dữ liệu trong JavaScript là gì?

Có bao nhiêu loại dữ liệu trong JavaScript?