sanketmaru

function getValidationData(param, param1){
  return {
  pattern:param,
  data: param1,
  }
}

getValidationData.apply(this, [param, param1]);

sanketmaru

// Flyweight.js - Copyright Addy Osmani, 2012.
// Consider public domain
// My implementation in JS of this:
// http://en.wikipedia.org/wiki/Flyweight_pattern

// Simulate pure virtual inheritance/'implement' keyword for JS
Function.prototype.implementsFor = function (parentClassOrObject) {
    if (parentClassOrObject.constructor == Function) {
        // Normal Inheritance 
        this.prototype = new parentClassOrObject;

sanketmaru

Composition

On an architectural level, the way we craft large-scale applications in JavaScript has changed in at least one fundamental way in the last four years. Once you remove the minutia of machinery bringing forth data-binding, immutable data-structures and virtual-DOM (all of which are interesting problem spaces) the one key concept that many devs seem to have organically converged on is composition. Composition is incredibly powerful, allowing us to stitch together reusable pieces of functionality to "compose" a larger application. Composition eschews in a mindset of things being good when they're modular, smaller and easier to test. Easier to reason with. Easier to distribute. Heck, just look at how well that works for Node.

Composition is one of the reasons we regularly talk about React "Components", "Ember.Component"s, Angular directives, Polymer elements and of course, straight-up Web Components. We may argue about the frameworks and libraries surrounding t

sanketmaru

var inputString = 'We came, we saw, we conquered...then we ate Bill\'s (Mille-Feuille) cake.'

function(inputString){
  var words = [];
  for(var i=0;i<inputString.length;i++){
    var word = [];
    var stringElem = inputString[i];
    word.push(stringElem);
    if(stringElem === ' ' || stringElem === ',' ){ // marks the end of word
      words.push(word);

sanketmaru

(function(){
  var w1,w2,w3,w4;
  //w1+w2+w3+w4 = 40;
  
  // applying a brute force approach
  for(w1=1;w1<40;w1++){
    
    for(w2=1;w1<40;w2++){
      
      for(w3=1;w3<40;w3++){

sanketmaru

Promise.map(emailParams,function(emailParam) {
    logger.info('sending email to  sendmail for %j', emailParam, {});
    var host = "www.example.com/";
    var html = jadeS.renderFile(template, {
      farms: emailParam.farms,
      headerImage: "image",
      heading: emailParam.heading,
      fieldFocusUrl: "someurl",
      host: host
    });

sanketmaru

JSFiddle demonstrating the isolated scopes

http://jsfiddle.net/juanmendez/k6chmnch/

sanketmaru

http://thatjsdude.com/interview/js2.html

http://code.tutsplus.com/articles/master-developers-addy-osmani--net-31661

sanketmaru

// code has been copied from http://rosettacode.org/wiki/Levenshtein_distance#Java

package main.java;

public class Levenstein {
	
	public static int distance(String a, String b) {
        a = a.toLowerCase();
        b = b.toLowerCase();
        // i == 0

sanketmaru

Below is the jsperf test which creates instances when methods are defined inside constructor methods vs in prototype object.

Methods defined in prototype object is faster as each instance shares the same prototype object thats with the constructor function.

http://jsperf.com/prototype-vs-constructor-methods