function foo(opts){
    var defaults = {bar: "baz", foo: "biff"};
    _.defaults(opts, defaults);
    // do things with opts here...
  }

The advantage is, using _.defaults, that you aren't passing a defaults object around within the body of your method and using it as if it were the opts, or reassigning to yet another var (see `finalParams` defined in the last example). This makes the method a bit clearer.

    var myopts = {foo: 1}
    foo(myopts)
    console.log(myopts) // => {foo: 1, bar: "baz"}

    var actual_opts = _.defaults({}, opts, {
        // Your defaults here
    });

This also fixes the issue of a caller passing in no options (or "null" or "undefined") without having to add an `||`

Unless you have a truly huge set of options, I'd suggest using

    var final_opts = _.defaults({}, opts, defaults);

How and why? I don't consider mutating the original object to be an advantage of using _.defaults, unless the object is completely under your control and you're essentially calling `_.defaults(this, defaults)`.

    function(arg1, arg2) {
      arg1 = arg1 || "foo";
      arg2 = arg2 || "bar";
    }

    arg1 = arg1 !== 0     ? 1234  : arg1;
    arg1 = arg1 !== false ? "foo" : arg1;
    arg1 = arg1 !== null  ? "foo" : arg1;
    arg1 = arg1 !== ""    ? "foo" : arg1;

A slightly more verbose, yet hardy syntax would go like this:

  function foo(arg1, arg2){
    arg1 = arg1 === undefined ? "foo" : arg1;
    arg2 = arg2 === undefined ? "bar" : arg2;
  }

In fact you're just compacting an if:

    if (arg1 == null) { // check for both `undefined` and `null`
      arg1 = 'default';
    }
    // compacted to:
    arg1 = arg1 == null ? 'default' : arg1;

    (arg1 == null) && (arg1 = 'default');

I could see, using the if statement form, that you might have a programmer decide to compact it and drop the brackets - and then you might fall in the trap where somebody thinks they're in an if block when they're really not. Happens pretty often.

In addition, I don't know if you really would want to check for null. I usually just check for undefined, which would be the absence of any provided value (as opposed to a provided value that just happens to be null). Of course, it depends on the app.

In addition, I really don't like using short-circuited boolean ops for assignment. The style is grating to me - it's not immediately obvious what it's really doing. To each his own.

EDIT: Created a simple jsperf test. Difference is about 6.8%, but we're talking hundreds of millions of ops/s. Not the kind of stuff that matters outside of raw benches.

http://jsperf.com/ternary-vs-if-for-default-args

    myfn('a',undefined,'b');

  JSON.parse(object, undefined, 2);

    var foo = function(a, b) {
        if (arguments.length < 2) {
            b = 'some default value';
        }
        // ...
    };

    function(kwargs) {
      kwargs = _.extend({param1: true, param2: 42}, kwargs)
      // ...
    }

    var args = _.defaults({}, kwargs, {param1: true, param2: 42}).