Kiểm tra tham số bị thiếu trong hàm

Question

Đây có phải là cách đúng để kiểm tra tham số bị thiếu trong một hàm không? Điều này có hoạt động trong tất cả các trình duyệt không? Làm thế nào về IE?

function getName(name){ 
    name = name != null ? name : "default"; 
    return name; 
} 

Answer 1

bạn có thể làm:

name = name || 'default'; 

Điều đó nói nếu name là undefined hoặc falsy (null, 0, "", false, {}, []), đặt nó vào "default".

js (h | l) int sẽ khiếu nại về nó, nhưng nó hoạt động ít nhất cũng như xa như IE7. Nó không phải là mã không hợp lệ ở tất cả hoặc dựa vào một số hành vi không có giấy tờ hoặc.

Answer 2

Cách đúng để kiểm tra là

if (typeof name === "undefined") { 
    // ... 
} 

Trong số những người gọi Dĩ nhiên vẫn có thể "đánh lừa" bạn bằng cách gọi getName(undefined), khi một tham số đã được quy định nhưng việc kiểm tra sẽ cờ nó như là không-được cung cấp dù sao . Nhưng đó thực sự là một tình huống bệnh lý.

Answer 3

Có điều này sẽ làm việc trong tất cả các trình duyệt tuy nhiên nếu bạn muốn để xem nếu nó được định nghĩa bạn có thể sử dụng:

function getName(name){ 
    name = typeof(name) !== "undefined" ? name : "default"; 
    return name; 
} 

Answer 4

Cách để kiểm tra các thông số phụ thuộc vào loại thông tin bạn đang đi đến và cách bạn muốn hàm xử lý các trường hợp cạnh.

Trong hầu hết các trường hợp, bạn chỉ có thể sử dụng:

function foo(bar) { 
    bar = bar || ...default value here...; 
} 

Tuy nhiên, nó có thể là một vấn đề nếu mã của bạn trông như thế này:

function foo(bar) { 
    bar = bar || 5; 
    alert(bar); 
} 
foo(0); //alerts 5, probably not what you wanted 

Vì vậy, thay vào đó, bạn thường có thể kiểm tra chống undefined :

function foo(bar) { 
    if (bar == undefined) { 
     bar = ...default value... 
    } 
} 

...Tuy nhiên bằng cách sử dụng kiểm tra lỏng lẻo cho phép cả hai null và undefined để được ghi đè (null == undefined):

function foo(bar) { 
    if (bar == undefined) { 
     bar = 0; 
    } 
    alert(bar); 
} 
foo(); //alerts 0 
foo(null); //alerts 0 

Vì vậy, thay vào đó, một so sánh bình đẳng nghiêm ngặt (===) thường được ưa thích (null !== undefined):

function foo(bar) { 
    //if you're worried that undefined may be overwritten for any horrible reason 
    //use `typeof bar === 'undefined'` instead 
    if (bar === undefined) { 
     bar = ...default value... 
    } 
} 

Tuy nhiên, điều này có thể dẫn đến rắc rối nếu bạn cần biết liệu undefined có được chuyển thành tham số không:

function foo(bar) { 
    if (bar === undefined) { 
     bar = 0; 
    } 
    alert(bar); 
} 
foo(undefined); //alerts 0, which may or may not be desired 

Nếu bạn muốn trở thành hoàn toàn chắc chắn rằng bạn không đi lên một cuộc tranh cãi đã được cung cấp, bạn có thể kiểm tra số lượng đối số truyền cho hàm:

function foo(bar) { 
    if (arguments.length < 1) { 
     bar = ...default value...; 
    } 
} 

Điều đó có nghĩa rằng bạn có thể thành công vượt qua undefined như một cuộc tranh cãi trong khi cũng lựa chọn để sử dụng một mặc định khác nhau:

function foo(bar) { 
    if (arguments.length < 1) { 
     bar = 0; 
    } 
    alert(bar); 
} 
foo(undefined); //alerts undefined 
foo(); //alerts 0 

---

Nếu bạn có nhiều thông số, bạn có thể muốn sử dụng nhiều giá trị mặc định. Gần đây, tôi đã tìm thấy một trường hợp sử dụng cho fallthrough trên một tuyên bố chuyển đổi, mặc dù the utility is questionable:

function foo(bar, baz, fizz, buzz) { 
    switch (arguments.length) { 
    case 0: 
     bar = 1; 
     //continue; might as well point out that implicit fall-through is desired 
    case 1: 
     baz = 2; 
     //continue; 
    case 2: 
     fizz = 3; 
     //continue; 
    case 3: 
     buzz = 4; 
     //continue; 
    } 
    ...code... 
}