Hướng dẫn how do you check if an argument is empty in javascript? - làm cách nào để kiểm tra xem một đối số có trống trong javascript không?

Trống rỗng

Tôi không khuyên bạn nên cố gắng xác định hoặc sử dụng một hàm tính toán xem bất kỳ giá trị nào trên toàn thế giới có trống không. Nó thực sự có nghĩa là "trống" "? Nếu tôi có

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

1,

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

2 sẽ trả lại

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

3? Nếu tôi có

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

4,

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

5 sẽ trả lại

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

3? Thế còn

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

7 - Danh sách này chỉ chứa sự trống rỗng, vậy chính danh sách này có trống không? Tôi muốn đưa ra ở đây một số ghi chú về "sự trống rỗng" (một từ có chủ ý, để tránh các hiệp hội có từ trước) trong JavaScript - và tôi muốn lập luận rằng "sự trống rỗng" trong các giá trị JavaScript không bao giờ nên được xử lý chung.

---

Truthiness/Falsiness

Để quyết định làm thế nào để xác định "độ trống" của các giá trị, chúng ta cần phải chấp nhận ý nghĩa sẵn có của JavaScript, cố hữu về việc các giá trị là "sự thật" hay "giả". Đương nhiên,

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

8 và

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9 đều là "giả". Ít tự nhiên hơn, số

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

0 (và không có số nào khác ngoại trừ

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

1) cũng là "giả". Ít nhất một cách tự nhiên:

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

2 là giả, nhưng

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

3 và

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

4 (và

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

5, và

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

6) là sự thật - mặc dù tất cả chúng đều có vẻ không kém!

---

Null vs không xác định

Ngoài ra còn có một số cuộc thảo luận liên quan đến

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

8 so với

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9 - chúng ta có thực sự cần cả hai để thể hiện sự trống rỗng trong các chương trình của chúng ta không? Cá nhân tôi tránh được

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9 xuất hiện trong mã của mình. Tôi luôn sử dụng

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

8 để biểu thị "độ trống". Tuy nhiên, một lần nữa, chúng ta cần phải điều chỉnh ý nghĩa vốn có của JavaScript về cách

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

8 và

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9 khác nhau:

• Cố gắng truy cập một thuộc tính không tồn tại cho

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  9
• Bỏ qua một tham số khi gọi một hàm dẫn đến tham số đó nhận

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  9:

let f = a => a;
console.log(f('hi'));
console.log(f());

• Tham số với các giá trị mặc định chỉ nhận được mặc định khi được cho

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  9, không phải

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  8:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

Đối với tôi,

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

8 là một dấu hiệu rõ ràng của sự trống rỗng; "Một cái gì đó có thể được điền vào đã được cố tình để trống".

Thực sự

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9 là một biến chứng cần thiết cho phép một số tính năng JS tồn tại, nhưng theo tôi, nó phải luôn luôn bị bỏ lại phía sau hậu trường; không tương tác trực tiếp. Chúng ta có thể nghĩ về

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9, ví dụ, cơ chế của JavaScript để thực hiện các đối số chức năng mặc định. Nếu bạn không cung cấp một đối số cho một hàm, nó sẽ nhận được giá trị

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9 thay thế. Và một giá trị mặc định sẽ được áp dụng cho một đối số chức năng nếu đối số đó ban đầu được đặt thành

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9. Trong trường hợp này

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9 là linchpin của các đối số chức năng mặc định, nhưng nó vẫn ở chế độ nền: chúng ta có thể đạt được chức năng đối số mặc định mà không bao giờ đề cập đến

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9:

Đây là một triển khai xấu các đối số mặc định vì nó tương tác trực tiếp với

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

9:

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

Đây là một triển khai tốt:

let fnWithDefaults = (arg='default') => { ... };

Đây là một cách tồi để chấp nhận đối số mặc định:

fnWithDefaults(undefined);

Chỉ cần làm điều này thay vào đó:

fnWithDefaults();

Nhân tiện: Bạn có chức năng với nhiều đối số và bạn muốn cung cấp một số đối số trong khi chấp nhận mặc định cho người khác không? do you have a function with multiple arguments, and you want to provide some arguments while accepting defaults for others?

E.g.:

let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);

Nếu bạn muốn cung cấp các giá trị cho

fnWithDefaults(undefined);

5 và

fnWithDefaults(undefined);

6 và chấp nhận mặc định cho những người khác phải làm gì? Điều này có vẻ sai:

fnWithDefaults(10, undefined, undefined, 40);

Câu trả lời là: Refactor

fnWithDefaults(undefined);

7 để chấp nhận một đối tượng duy nhất:

let fnWithDefaults = ({ a=1, b=2, c=3, d=4 }={}) => console.log(a, b, c, d);
fnWithDefaults({ a: 10, d: 40 }); // Now this looks really nice! (And never talks about "undefined")

---

Không trống rỗng không thể công tử

Tôi tin rằng sự trống rỗng không bao giờ nên được xử lý một cách chung chung. Thay vào đó, chúng ta nên luôn có sự nghiêm ngặt để có thêm thông tin về dữ liệu của mình trước khi xác định xem nó có bị trống không - tôi chủ yếu làm điều này bằng cách kiểm tra loại dữ liệu nào tôi đang xử lý:

let isType = (value, Cls) => {
  // Intentional use of loose comparison operator detects `null`
  // and `undefined`, and nothing else!
  return value != null && Object.getPrototypeOf(value).constructor === Cls;
};

Lưu ý rằng chức năng này bỏ qua sự kế thừa - nó hy vọng

fnWithDefaults(undefined);

8 sẽ là một ví dụ trực tiếp của

fnWithDefaults(undefined);

9, và không phải là một ví dụ của một lớp con của

fnWithDefaults(undefined);

9. Tôi tránh

fnWithDefaults();

1 vì hai lý do chính:

• fnWithDefaults();
  

  2 ("Một mảng là một đối tượng")

• fnWithDefaults();
  

  3 ("Chuỗi không phải là chuỗi")

Lưu ý rằng

fnWithDefaults();

4 được sử dụng để tránh trường hợp cạnh (tối nghĩa), chẳng hạn như

fnWithDefaults();

5 Hàm

fnWithDefaults();

6 vẫn trả về chính xác cho

fnWithDefaults();

7 (sai) và

fnWithDefaults();

8 (true).

Nhìn chung, tôi khuyên bạn nên sử dụng chức năng

fnWithDefaults();

6 này cùng với các mẹo sau:

• Giảm thiểu số lượng giá trị xử lý mã của loại không xác định. Ví dụ: đối với

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  0, biến

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 của chúng tôi hiện không rõ loại. Càng sớm nhất có thể, chúng ta nên hạn chế khả năng của mình. Cách tốt nhất để làm điều này có thể là yêu cầu một loại cụ thể: ví dụ:

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  2 - Đây là một cách thực sự nhanh chóng và biểu cảm để loại bỏ bản chất chung của

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 và đảm bảo nó luôn luôn là

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  4. Tuy nhiên, đôi khi, chúng ta cần cho phép

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 có nhiều loại. Trong những trường hợp đó, chúng ta nên tạo các khối mã trong đó

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 không còn chung, càng sớm càng tốt: E.g., for

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  0, our

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 variable is now of unknown type. As early as possible, we should limit our possibilities. The best way to do this can be by requiring a particular type: e.g.

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  2 - this is a really quick and expressive way to remove the generic nature of

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1, and ensure it's always an

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  4. Sometimes, though, we need to allow

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 to be of multiple types. In those cases, we should create blocks of code where

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 is no longer generic, as early as possible:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

0

• Luôn luôn sử dụng "danh sách trắng" để xác nhận. Nếu bạn yêu cầu một giá trị, ví dụ, một chuỗi, số hoặc mảng, hãy kiểm tra các khả năng "trắng" đó và ném lỗi nếu không có 3 trong số 3 được thỏa mãn. Chúng ta sẽ có thể thấy rằng việc kiểm tra các khả năng "đen" không hữu ích: giả sử chúng ta viết

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  7 - điều này là tuyệt vời để đảm bảo rằng các giá trị

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  8 không làm cho nó thông qua, nhưng nếu một giá trị vượt qua, chúng ta vẫn hầu như không biết bất cứ điều gì về nó. Một giá trị

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 vượt qua bản kiểm tra null này vẫn rất chung chung - đó là bất cứ điều gì ngoại trừ

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  8! Danh sách đen hầu như không xua tan chung chung. If you require a value to be, e.g., a String, Number, or Array, check for those 3 "white" possibilities, and throw an Error if none of the 3 are satisfied. We should be able to see that checking for "black" possibilities isn't very useful: Say we write

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  7 - this is great for ensuring that

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  8 values don't make it through, but if a value does make it through, we still know hardly anything about it. A value

  let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);
  

  1 which passes this null-check is still VERY generic - it's anything but

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  8! Blacklists hardly dispell generic-ness.
• Trừ khi một giá trị là

  let f = (v='hello') => v;
  console.log(f(null));
  console.log(f(undefined));

  8, không bao giờ xem xét "giá trị trống". Thay vào đó, hãy xem xét "một x là trống". Về cơ bản, không bao giờ xem xét làm bất cứ điều gì như

  fnWithDefaults(10, undefined, undefined, 40);
  

  2 - bất kể chức năng

  fnWithDefaults(10, undefined, undefined, 40);
  

  3 đó được thực hiện như thế nào (tôi không muốn biết ...), nó không có ý nghĩa! Và đó là cách quá chung chung! Độ trống chỉ nên được tính toán với kiến ​​thức về loại của ____ 74. Checks trống sẽ trông như thế này: Essentially, never consider doing anything like

  fnWithDefaults(10, undefined, undefined, 40);
  

  2 - no matter how that

  fnWithDefaults(10, undefined, undefined, 40);
  

  3 function is implemented (I don't want to know...), it isn't meaningful! And it's way too generic! Vacuousness should only be calculated with knowledge of

  fnWithDefaults(10, undefined, undefined, 40);
  

  4's type. Vacuousness-checks should look like this:

  • "Một chuỗi, không có ký tự":

    fnWithDefaults(10, undefined, undefined, 40);
    

    5

  • "Một đối tượng, với 0 đạo cụ":

    fnWithDefaults(10, undefined, undefined, 40);
    

    6

  • "Một số, bằng hoặc nhỏ hơn 0":

    fnWithDefaults(10, undefined, undefined, 40);
    

    7

  • "Một mảng, không có vật phẩm":

    fnWithDefaults(10, undefined, undefined, 40);
    

    8

  • Ngoại lệ duy nhất là khi

    let f = (v='hello') => v;
    console.log(f(null));
    console.log(f(undefined));

    8 được sử dụng để biểu thị một số chức năng nhất định. Trong trường hợp này, có ý nghĩa nói: "Giá trị trống":

    let fnWithDefaults = ({ a=1, b=2, c=3, d=4 }={}) => console.log(a, b, c, d);
    fnWithDefaults({ a: 10, d: 40 }); // Now this looks really nice! (And never talks about "undefined")
    

    0

Làm thế nào kiểm tra biến trống hoặc không trong javascript?

Null == null trong javascript?

Null == trong javascript?

Làm thế nào để bạn kiểm tra nếu một biến trống?