I am sorry i am not a good in this, but I want create a function like this
function show (message['head':'error','body':'msg'])
{ // 'error' and 'msg' and the default values
alert(message[head]);
}
show ({'head' : 'this is head', 'body' : 'this is body'});
What is the correct way to above method work properly ?
Like this:
function show (message)
{
alert(message.head);
// or
alert(message['head']); // Note the quotes
}
Your call to it is fine.
To supply defaults, as David points out, you can use the curiously powerful || operator:
function show (message)
{
var head = message.head || 'error',
body = message.body || 'msg';
alert(head);
}
(The above is slightly different from David's approach in that it avoids changing the message object that was passed in, which is usually not a good idea as the function doesn't own the object, the caller does.)
That works because if head (for example) isn't on the message object at all, it's falsey, and so head = message.head || 'error' ends up assigning 'error' to head. This is a handy trick, but there's a gotcha: If head could have a falsey value already, and that's valid, you don't want to use the || trick. Instead, you can use in to check:
function show (message)
{
var head = 'head' in message ? message.head : 'error',
body = 'body' in message ? message.body : 'msg';
alert(head);
}
That will use the value from message if it's present, regardless of whether it's falsey.
in checks the prototype. Are you sure that's safe?
message.head we'd see a different value (if message is an object with head on its prototype). There's lots of places where you want hasOwnProperty instead, but to me, this isn't one of them.
message.head = 'head' in message ? message.head : 'error';) if you like, just be aware that that's the kind of thing that can have unexpected side-effects (because you're modifying the message object that was passed to you). I've seen a lot of bugs over the years because people weren't expecting a function to modify something it received as an argument. Just be clear in your documentation of the function. But why wouldn't you use a variable? I'm not seeing the downside of doing that.If an object doesn't have a property, access of that property will return the value undefined. We can use this along with the logical OR || operator to assign default values to the object.
function show(message) {
message.head = message.head || 'error';
message.body = message.body || 'msg';
alert(message.head);
}
If message.head is undefined, it will assign "error" to the object property, or it will otherwise retain its value.
As Crower pointed out, this has a potential "gotcha" as an empty string can be deduced as a falsy value causing the unwanted assignment of a default value. Use this version as it checks if the property is actually on the object:
function show(message) {
message.head = message.hasOwnProperty('head') ? message.head : 'error';
message.body = message.hasOwnProperty('body') ? message.body : 'msg';
alert(message.head);
}
message.head can meaningfully be 0 or "", you don't want to indiscriminately do || 'error' on it).Plesae examine This
and mark the correct answer which satisfies you.
function show(message){
alert(message['head']);
}
