tiến trình chức năng[sự kiện] {
var appId = event. getApp_id[];
if [appId. = “something”] {
throw "Sự kiện phía máy chủ có app_id không hợp lệ. " + appId;
}
return ;
}
nó sẽ báo lỗi
". {"dấu thời gian". “2021-09-29T11. 10. 00. 536670108Z”,“tin nhắn”. [{“làm giàu”. {“lược đồKey”. “giấu. com. snowplowanalytics. snowplow/javascript_script_config/jsonschema/1-0-0”,“mã định danh”. “Làm giàu Javascript”},“thông điệp”. {"lỗi". “Lỗi khi biên dịch hàm JavaScript. [Không thể gọi “javax. script. biên dịch được. compile[String]” vì giá trị trả về của “com. snowplowanalytics. đồ ủi tuyết. làm giàu. phổ thông. làm giàu. đăng ký. Làm giàu tập lệnh Javascript. engine[]” là null]”}}]},
Khi thảo luận về các kiểu dữ liệu nguyên thủy trong JavaScript, hầu hết mọi người đều biết những điều cơ bản, bắt đầu với Chuỗi, Số và Boolean. Những nguyên mẫu này khá đơn giản và hoạt động như bạn mong đợi. Tuy nhiên, bài viết này sẽ tập trung vào các kiểu dữ liệu nguyên thủy độc đáo hơn được gọi là Null và Undefined;
Hiểu Null và Undefined
Trong JavaScript,
undefined === null; // false
1 là một từ khóa theo nghĩa đen và ngôn ngữ không đại diện cho giá trị đối tượng rõ ràng. Nói cách khác, đó là dấu hiệu “không có giá trị. ” Trong khi tương tự, undefined === null; // false
0 thực sự đại diện cho sự không tồn tại của một giá trị. Cả hai đều hoàn toàn bất biến, không có thuộc tính hoặc phương thức và không có khả năng gán thuộc tính. Trên thực tế, việc cố gắng truy cập hoặc xác định một thuộc tính sẽ làm tăng undefined === null; // false
1. Chúng, như tên gọi của chúng, hoàn toàn vô giá trịViệc không có giá trị cho thấy đặc điểm của chúng là giá trị giả, nghĩa là chúng đánh giá là sai khi được sử dụng trong ngữ cảnh của một điều kiện, chẳng hạn như câu lệnh
undefined === null; // false
2. So sánh hai giá trị này với các giá trị giả khác bằng cách sử dụng toán tử đẳng thức [undefined === null; // false
3] cho thấy rằng chúng không bằng bất kỳ thứ gì ngoại trừ chính chúngnull == 0; // false
undefined == ""; // false
null == false; // false
undefined == false; // false
null == undefined; // true
Bất chấp điều này và những điểm tương đồng khác,
undefined === null; // false
1 và undefined === null; // false
0 không tương đương. Mỗi cái đóng vai trò là thành viên duy nhất của loại riêng biệt của nó; . So sánh cả hai với toán tử đẳng thức nghiêm ngặt [undefined === null; // false
8], tương đương với cả giá trị và loại, là đủ để chứng minh rằngundefined === null; // false
Đây là một dấu hiệu đặc biệt quan trọng; . Để phân biệt giữa hai loại này, bạn có thể nghĩ về
undefined === null; // false
0 đại diện cho sự vắng mặt bất ngờ của giá trị và undefined === null; // false
1 đại diện cho sự vắng mặt dự kiến của giá trịnăng suất không xác định
Có một số cách để tạo ra giá trị
undefined === null; // false
0 trong mã. Nó thường gặp phải khi cố gắng truy cập một giá trị không tồn tại giá trị. Trong trường hợp này, JavaScript, là ngôn ngữ động và được gõ yếu, sẽ chỉ mặc định là giá trị undefined === null; // false
0 thay vì gây ra lỗiBất kỳ biến được khai báo nào chưa được cung cấp giá trị ban đầu sẽ có giá trị mặc định là
undefined === null; // false
0undefined === null; // false
3Giá trị
undefined === null; // false
0 được cấp khi cố gắng truy cập thuộc tính đối tượng hoặc mục mảng không tồn tạiundefined === null; // false
5Nếu một câu lệnh return bị bỏ qua trong một hàm, thì thay vào đó,
undefined === null; // false
0 sẽ được trả vềundefined === null; // false
7Một đối số không được cung cấp cho lời gọi hàm sẽ dẫn đến tham số
undefined === null; // false
0undefined === null; // false
9Toán tử
undefined === null; // false
37 cũng có thể được sử dụng để trả về giá trị undefined === null; // false
0. Các thư viện chẳng hạn như sử dụng nó như một phương tiện kiểm tra loại chống đạn vì nó không thay đổi và có thể dựa vào để trả về undefined === null; // false
0 trong bất kỳ ngữ cảnh nàoundefined === null; // false
3Cuối cùng,
undefined === null; // false
0 là biến toàn cục được xác định trước [không phải từ khóa như undefined === null; // false
1] được khởi tạo thành giá trị undefined === null; // false
0undefined === null; // false
6Kể từ ECMAScript 5, biến này là , đây không phải là trường hợp trước đây
Trường hợp sử dụng cho Null
Trường hợp sử dụng cho
undefined === null; // false
1 là khía cạnh chính làm nên sự khác biệt của nó, bởi vì không giống như undefined === null; // false
0, undefined === null; // false
1 được coi là có giá trị chuyển nhượng nhiều hơn. Đây chính là lý do tại sao toán tử undefined === null; // false
56 trả về “đối tượng” khi được sử dụng kết hợp với giá trị undefined === null; // false
1. Cơ sở ban đầu cho điều này là vì undefined === null; // false
1 đã và vẫn thường được sử dụng như một tham chiếu trống trong đó một đối tượng được mong đợi, giống như một trình giữ chỗ. Hành vi này liên quan đến undefined === null; // false
56 kể từ đó đã được xác định là một lỗi và mặc dù một sự điều chỉnh đã được đề xuất, cho đến thời điểm này nó vẫn không thay đổi vì mục đích tương thích ngượcĐây là lý do tại sao môi trường JavaScript không bao giờ đặt giá trị thành
undefined === null; // false
1; . Như tài liệu trên MDN đặt nóTrong các API,
1 thường được truy xuất ở nơi có thể mong đợi một đối tượng nhưng không có đối tượng nào phù hợpundefined === null; // false
Điều này đúng với DOM, không phụ thuộc vào ngôn ngữ và không thuộc phạm vi của đặc tả ECMAScript. Bởi vì nó là một API bên ngoài, cố gắng truy xuất một phần tử không tồn tại sẽ trả về giá trị
undefined === null; // false
1 thay vì undefined === null; // false
0Nói chung, nếu bạn cần gán một giá trị không phải giá trị cho một biến hoặc thuộc tính, chuyển nó vào một hàm hoặc trả về nó từ một hàm, thì
undefined === null; // false
1 hầu như luôn là lựa chọn tốt nhất. Nói một cách đơn giản, JavaScript sử dụng undefined === null; // false
0 và các lập trình viên nên sử dụng undefined === null; // false
1Một trường hợp sử dụng khả thi khác cho
undefined === null; // false
1 cũng được coi là thông lệ tốt là vô hiệu hóa biến rõ ràng [undefined === null; // false
78] khi không còn cần tham chiếu. Bằng cách gán giá trị undefined === null; // false
1, bạn đang xóa tham chiếu một cách hiệu quả và giả sử đối tượng không được tham chiếu ở nơi khác trong mã, chỉ định nó để thu gom rác, do đó lấy lại bộ nhớĐào sâu hơn
Điều khiến
undefined === null; // false
1 và undefined === null; // false
0 trở thành những lỗ đen như vậy không chỉ ở hành vi của chúng mà còn ở cách chúng được xử lý nội bộ trong môi trường JavaScript. Chúng dường như không sở hữu các đặc điểm giống nhau thường được liên kết với các đối tượng nguyên thủy hoặc tích hợp khácKể từ ES5, phương pháp
undefined === null; // false
92, đã trở thành tiêu chuẩn thực tế để kiểm tra loại, chứng tỏ tính nhất quán về vấn đề này đối với cả undefined === null; // false
1 và undefined === null; // false
0undefined === null; // false
6Tuy nhiên, phương thức
undefined === null; // false
92 không thực sự truy xuất thuộc tính undefined === null; // false
96 bên trong của undefined === null; // false
1 hoặc undefined === null; // false
0 để hiển thị các hàm tạo. Theo , các bước sau đây được thực hiện khi gọi
- Nếu giá trị này là
0, trả vềundefined === null; // false
30undefined === null; // false
- Nếu giá trị này là
1, trả vềundefined === null; // false
32undefined === null; // false
- Đặt O là kết quả của việc gọi
33 chuyển giá trịundefined === null; // false
34 làm đối sốundefined === null; // false
- Đặt lớp là giá trị của thuộc tính bên trong
96 của Oundefined === null; // false
- Trả về giá trị Chuỗi là kết quả của việc nối ba Chuỗi
36, lớp vàundefined === null; // false
37undefined === null; // false
Phương thức này thực hiện trả về một chuỗi đơn giản nếu nó chỉ phát hiện ra
undefined === null; // false
1 hoặc undefined === null; // false
0 với chức năng thống nhất với các đối tượng khác. Điều này phổ biến trong toàn bộ đặc tả, vì hầu hết các phương thức đều chứa một lệnh bắt và trả về đơn giản khi chúng gặp các giá trị undefined === null; // false
1 và undefined === null; // false
0. Trên thực tế, không có dấu hiệu nào cho thấy chúng thậm chí chứa bất kỳ đối tượng nào thường được liên kết với mọi đối tượng bản địa. Như thể chúng không phải là đồ vật gì cả? Sự kết luận
Bất kể những nguyên mẫu này có vẻ khác thường như thế nào, việc hiểu rõ về
undefined === null; // false
1 và undefined === null; // false
0, sự khác biệt giữa chúng và vai trò riêng biệt của chúng trong JavaScript là nền tảng của ngôn ngữ. Nó có thể không chính xác tạo ra hoặc phá vỡ ứng dụng của bạn, tuy nhiên, nói chung, nó chỉ có thể chứng minh là có lợi về lâu dài cho cả quá trình phát triển và gỡ lỗiBài viết này ban đầu được xuất bản tại https. //ryanmorr. com/exploring-the-eternal-abyss-of-null-and-undefined/