JavaScript模式 读书笔记三

function foo(){}; //函数声明
var bar=function(){}; //函数表达式
var baz=function baz(){};//函数命名表达式

//反模式
//仅用于掩饰

//全局函数
function foo(){
  alert("global foo");
}
function bar(){
  alert("global bar");
}

function hoisMe(){
  console.log(typeof foo); //输出function
  console.log(typeof bar); //输出undefined
  foo();  //输出local foo
  bar();  //输出　TypeError: bar is not a function

  //函数声明
  //变量　foo以其实现者被提升
  function foo(){
    alert("local foo");
  }

  //函数表达式
  //仅变量 bar被提升
  //函数实现并未被提升
  var bar=function(){
     alert("local bar");
  }


}

hoisMe();

//重构findNodes()以接受一个回调函数
var findNodes=function(callback){
  var i=100000,
  nodes=[],
  found;

  if(typeof callback!=="function"){
    callback=false;
  }

  while(i){
    i-=1;
    // 这里是复杂的逻辑...

    //现在进行回调函数
    if(callback){
      callback(found);
    }

    nodes.push(found);

  }
  return nodes;
}

//回调函数
var hide=function(node){
  node.style.display="none";

}
//找到制定节点，并在后续执行中将其隐藏起来
findNodes(hide);

//传递一个匿名回调函数
findNodes(function(node){
  node.style.display="block";
});

//重构findNodes()以接受一个回调函数
var findNodes=function(callback,callback_obj){
  var i=100000,
  nodes=[],
  found;



  while(i){
    i-=1;
    // 这里是复杂的逻辑...

    //现在进行回调函数
    if(typeof callback==="string"){
      callback=callback_obj[callback];
    }
    if(typeof callback==="function"){
       callback.call(callback_obj,found);
    }

    nodes.push(found);

  }
  return nodes;
}

//回调函数
var myapp={};
myapp.color="green";
myapp.paint=function(node){
  node.style.color=this.color;
};
//找到制定节点，并在后续执行中将其隐藏起来
findNodes(myapp.paint,myapp);

var setup=function(){
  alert(1);
  return function(){
    alert(2);
  }
}

//使用setup函数
var my=setup(); //alert1
my(); //alert 2

var setup=function(){
  var count=0;
  return function(){
     return (count+=1);
  }
}

//用法
var next=setup();
next(); //返回1
next(); //返回2
next(); //返回3

var scareMe=function(){
  alert("Boo!");
  scareMe=function(){
    alert("Double boo!");
  }
};

//使用自定义函数
scareMe(); //输出Boo！
scareMe(); //输出Double boo!

var scareMe=function(){
  alert("Boo!");
  scareMe=function(){
    alert("Double boo!");
  }
};

//1 .添加一个新的属性
scareMe.property="properly";

//2. 复制给另一个不同名称的变量
var prank=scareMe;

//3. 作为一个方法使用
var spooky={
  boo:scareMe
};

//calling with a new name
prank(); //输出 Boo!
prank(); //输出 Boo!
 console.log(prank.property); //输出properly

 //作为一个方法来调用
 spooky.boo(); //输出Boo!
 spooky.boo(); //输出Boo!
 console.log(spooky.boo.property); // 输出　 properly

 //使用自定义函数
 scareMe(); //输出 Double boo!
 scareMe(); //输出 Double boo!
console.log(scareMe.property); //undefined

//定义模块module1
(function(){
  //模块1中的所有代码
}());

var getResult=(function(){
  var res=2+2;
  return function(){
    return res;
  }
}());

var o={
  message:(function(){
    var who="me",
    what="call";
    return what + " "+who;
  }()),
  getMsg:function(){
    return this.message;
  }
};

//用法
console.log(o.getMsg());  //输出call me
console.log(o.message);   //输出call me

({
  //在这里可以定义设定值
  //又名配置常数
  maxwidth:600,
  maxheight:400,

  //还可以定义一些实用的方法
  gimmeMax:function(){
    return this.maxwidth+ "X" +this.maxheight;
  },

  //初始化
  init:function(){
    console.log(this.gimmeMax());
    //更多初始化任务。。。
  }

}).init();

//接口
var utils={
  addListener:null,
  removeListener:null
};

//实现　
if(typeof window.addEventListener==="function"){
  utils.addListener=function(el,type,fn){
    el.addEventListener(type,fn,false);
  };
  utils.removeListener=function(el,type,fn){
    el.removeEventListener(type,fn,false);
  }
}else if(typeof document.attachEvent==="function"){  //判断为IE浏览器
  utils.addListener=function(el,type,fn){
    el.attachEvent('on'+type,fn);
  };
  utils.removeListener=function(el,type,fn){
    el.detachEvent("on"+type,fn);
  };

}else{  //更早版本的浏览器　
   utils.addListener=function(el,type,fn){
     el['on'+type]=fn;
   };
   utils.removeListener=function(el,type,fn){
     el['on'+type]=null;
   }
}

function func(a,b,c,d){}
console.log(func.length);

var myFunc=function(param){
  if(!myFunc.cache[param]){
    var result={};
    //。。。开销很大的操作。。。
    myFunc.cache[param]=result;
  }
  return myFunc.cache[param];
}
//缓存存储
myFunc.cache={};

var conf={
  username:"lilu",
  first:"Yi",
  last:"Liu"
}

function addPerson(person){
  return person.username +" " +person.first+" "+person.last;
}

addPerson(conf);

//定义函数
var sayHi=function(who){
  return "Hello"+ (who?", "+who:"")+"!";
};

//调用函数
sayHi(); //输出Hello
sayHi('world'); //输出Hello,World!

//应用函数
sayHi.apply(null,['hello']); //输出Hello, hello!

//curry化的add()函数
//接受部分参数的列表
function add(x,y){
  var oldx=x,oldy=y;
  if(typeof oldy==="undefined"){ //部分
    return function(newy){
      return oldx+newy;
    }
  }
  //完全应用
  return x+y;
}
//测试
typeof add(5); //输出function
add(3)(4); //7
//创建病存储一个新函数
var add2000=add(2000);
add2000(10);//输出2010

function schonfinkelize(fn){
  var slice=Array.prototype.slice,
    stored_args=slice.call(arguments,1);
  return function(){
    var new_args=slice.call(arguments),
        args=stored_args.concat(new_args);
    return fn.apply(null,args);
  }
}

//普通函数
function add(x,y){
  return x+y;
}

//将一个函数curry化以获得一个新的函数
var newadd=schonfinkelize(add,5);
newadd(4); //输出9

/另一种选择——直接调用新函数
schonfinkelize(add,6)(7);

//普通函数
function add(a,b,c,d,e){
  return a+b+c+d+e;
}

//可运行于任意数量的参数
schonfinkelize(add,1,2,3)(5,5); //16

//两步curry化
var addOne=schonfinkelize(add,1);
addOne(10,10,10,10); //输出41

var addSix=schonfinkelize(addOne,2,3);
addSix(5,5); //输出16