javascript learning notes——function

函数：一次定义，多次执行。js的函数调用还有一个特性，每次调用都会拥有另一个值——本次调用的this值（上下文/context）。函数可以作为对象的一个属性，称为对象的方法。当通过对象调用函数时，该对象就是此次调用的上下文。

//在定义的时候递归
var f = function fact(x) {if (x<=1) return 1; else return x*fact(x-1);};
//作为参数传递
data.sort(function(a,b){return a-b;});
//定义后立即使用
var tensquared = (function(x){return x*x}(10));

如果一个函数定义表达式包含名称，就像上面的乘阶函数，函数的局部作用域将会包含一个绑定到函数对象的名称，称为函数内部的一个局部变量。

var caculator = 
{//对象直接量
    operand1:1;
    operand2:2;
    add:function(){
    //注意this关键字的用法，this指代当前对象
        this.result=this.operand1 + this.operand2;
    }  
};
calculator.add();
calculator.result;//=>2

没有return语句的函数(过程←好久没有听见这个词了，泪流满面QAQ)也会返回undefined。ECMAScript规范不允许函数声明语句出现在循环、条件判断，或者try/catch/finally/with中。

//定义并调用一个函数来确定当前脚本运行时是否为严格模式
var strict = (function(){return !this;});
//方法链(方法中直接返回this)
shape.setX(100).setY(100).setSize(50).setOutLine("red").setFill("blue").draw();

如果嵌套函数作为方法调用，其this值指向调用它的对象。如果嵌套函数作为函数调用，其this值指向全局对象/undefined。
var o = new Object();
var o = new Object;//和上面的表达式等价
可选形参

//将对象o中可枚举的属性名最加到数组a中，并返回这个数组a
//如果省略a，则穿件一个新数组并返回这个新数组
function getPropertyNames(o, /* optional */ a)
{
    if (a == undefined) a = [];//如果这个数组a未定义，则使用新数组
    //a = a || []; //这样用的前提是a已近定义，否则会报引用错误
    for (var property in o){
        a.push(property);
    }
    return a;
}
//这个函数调用可以传入1个或者2个参数
var a =  getPropertyNames(o);//将o的属性存储到一个新的数组中
getPropertyNames(p, a);//将p的属性最加到数组a中

没有办法省略前面的形参而传入后面的形参，只能前面的形参传入undefined/null。
实参对象

function max(/*...*/)
{
    var max = Number.NEGATIVE_INFINITY;
    //遍历实参，查找最大值
    for (var i = 0;i <arguments.length; i++)
    {
        if (arguments[i] > max){
            max = arguments[i];
            //返回最大值
            return max;
        }
    }
}

检查传入的实参类型

//返回数组a的元素累加和
//元素必须为数字，跳过null和undefined
function sum(a)
{
    if (isArrayLike(a))
    {
        var total = 0;
        for (var i = 0;i < a.length; i++)
        {
            var element = a[i];
            if (element == null) continue;//
            if (isFinite(element)) total += element;
            else throw new Error('');
        }
        return total;
    }else throw new Error('');
}

利用函数自定义属性计算阶乘

function factorial(n)
{
    if (isFinite(n) && n>0 && n==Math.round(n))
    {
        if (!(n in factorial)) factorial[n] = n * factorial(n-1);
        return factorial[n];
    }else return NaN;
}
factorial[1]=1;

monkey-patching

//将对象o中名为m的方法替换为另外一个方法，同时输出日志
function trace(o,m)
{
    var original = o[m];
    o[m] = function()
    {
        console.log('');
        var result = original.apply(this.arguments);
        console.log('');
        return result;
    };
}

bind

var sum = function(x,y){return x+y};
var succ = sum.bind(null,1);
succ(2);//=>3

function f(y,z){return this.x+y+z};
var g = f.bind({x:1},2);
g(3);//=>1+2+3

function bind(f,o)
{
    if (f.bind) return f.bind(o);
    else return function()
    {
        return f.apply(o,arguments);
    };
}