gryzzly

return !!(// double negation is required since logical operators dont always return Booleans
  ENV_VAR || 
  SomeLongStore.get('key') ||
  SomeConfig.get('layer', 'sub-layer') === 'required-value' ||
  this.anotherLongCondition()
)

vs

gryzzly

Example of a tedious task when using backbone MVC

You have three components each of which might have certain state. These components depend on one particular component that emits events. These three views have to all define the emitting component as a dependency and manually subscribe to the events in order to sync the state.

var View = require('lib/View'),
    source = require('source'); 
    
module.exports = View.extend({

gryzzly

var createRedux = require('redux').createRedux;
var reducer = function (state, action) {
  return state;
};
var redux = createRedux(reducer);
redux.dispatch({
  type: 'FOO',
  payload: {}
});

gryzzly

var reverseString = function ( subj ) {
  var helper = subj.split (''), 
      i = 0, k = helper.length, len = helper.length / 2, 
      swap

  for ( ; i < len; i += 1, k -= 1 ) {
    swap = helper[ k ];
    helper[ k ] = helper[ i ];
    helper[ i ] = swap;
  }

gryzzly

// Render JavaScript template (from http://git.io/B7KxZg DoAT Touchy)
// 
// You can place your template in a script tag with type other than "text/javascript"
// such as "text/html", like this:
// <script type="text/html" id="item-template">
// <li id="{{id}}">
//   <p>{{content}}</p>
// </li>
// You'd then render your template like this:
// var itemTemplate = document.getElementById('item-template').innerHTML;

gryzzly

// Helper function to correctly set up the prototype chain, for subclasses.
// Similar to `goog.inherits`, but uses a hash of prototype properties and
// class properties to be extended.
var inherits = function(parent, protoProps, staticProps) {
    var child;

    // The constructor function for the new subclass is either defined by you
    // (the "constructor" property in your `extend` definition), or defaulted
    // by us to simply call the parent's constructor.
    if (protoProps && protoProps.hasOwnProperty('constructor')) {

gryzzly

// naïve bind implementation
Function.prototype.bind = function () {
    var obj = arguments[0], args = [].slice.call(arguments, 1);

    return function () {
        this.apply(
            obj,
            [].concat.call(args, [].slice.call(arguments))
        );
    }

gryzzly

function () {}

gryzzly

Combining handleEvent and Backbone

I'm sure for most of you it's the old news, but here's a short reminder anyway:

song = {
	handleEvent: function (event) {
    	switch (event.type) {
          case: "click":

console.log(this.name);

gryzzly

var down = "touchup" in window ? "touchup" : "click";

var abstractView = Backbone.View.extend({
    // we don't want both click and touch handlers
    // delegated on touch-enabled devices
    events: function () {
        "click .toggler" : "foo", 
        "touchup .toggler" : "bar"
    },
    initialize: function () {