// 函数调用
function hello(name){
    return 'hello '+name;
}
hello('tom'); // hello tom

// 方法调用
var obj = {
    hello: function(){
        return 'hello '+ this.name;
    },
    name: 'han'
}
obj.hello(); // hello han
// 此处hello通过this变量访问obj对象的属性
// 在方法调用中,是由调用表达式自身来确定this变量的绑定,


// 通过构造函数使用
function User(name, pass){
    this.name = name;
    this.pass = pass;
}
var u = new User('aa', 'psa');
u.name; // aa
// 构造函数调用将一个全新对象作为this变量的值,并隐式返回这个新对象作为调用结果
// 构造函数的主要职责是初始化该新对象

var names = ['fred', 'wilma', 'pebbles'];
var upper = [];
for( var i = 0, n = names.length; i < n; ++i){
    upper[i] = names[i].toUpperCase();
}
upper; // ['FRED', 'WILMA', 'PEBBLES']

// 使用map方法,可以大大简化,
var upper = names.map(function(name){
    return name.toUpperCase();
});

// 创建一个字符串,通过循环连接
function buildStr(n, cb){
    var result = '';
    for(var i = 0; i < n; ++i){
        result += cb(i);
    }
    return result;
}

var alphabet = buildStr(26, function(i){
    return String.fromCharCode('a'.charCodeAt() + i);
});
alphabet; // 'abcdefghigklmnopqrstuvwxyz'

var digits = buildStr(10, function(i){
    return i;
});
digits; // '0123456789'

var random = buildStr(8, function(i){
    return String.fromCharCode('a'.charCodeAt() + Math.floor(Math.random() * 26));
});
random; // 随机值

obj.temporary = f;
var result = obj.temporary(arg1, arg2, arg3);
delete obj.temporary;

dict.hasOwnProperty = 1;
dict.hasOwnProperty('foo'); // error: 1 is not a function, 此时hasOwnProperty被覆盖为一个属性了, 而不是一个方法

var hasOwnProperty = {}.hasOwnProperty;
dict.foo = 1;
delete dict.hasOwnProperty;
hasOwnProperty.call(dict, 'foo'); // true
hasOwnProperty.call(dict, 'hasOwnProperty'); // false

// 允许table对象的使用者将一个方法作为table.forEach的回调函数f, 并可自定义接收者
var table = {
    entries: [],
    addEntry: function(key, value){
        this.entries.push({key: key, value: value});
    },
    forEach: function(f, thisArg){
        var entries = this.entries;
        for(var i = 0, n = entries.length; i < n; ++i){
            var entry = entries[i];
            f.call(thisArg, entry.key, entry.value, i);
        }
    }
}
// 将一个table内容复制到另一个table中
table1.forEach(table2.addEntry, table2);
// 从table2中提取addEntry方法, forEach方法将table2作为接收者, 并反复调用该addEntry方法.
// 虽然addEntry方法期望2个参数,但是forEach方法调用它时却传递了三个参数,键, 值, 索引.
// 多余的参数是无害的, 因为addEntry方法会简单的忽略多余参数

function average(){
    return averageOfArray(arguments);
}

var it = values(1,4,1,4,2,1,3,5,6);
it.next(); // 1
it.next(); // 4
it.next(); // 1

function values(){
    var i = 0, n = arguments.length;
    // var a = arguments;
    return {
        hasNext: function(){
            return i < n;
        },
        next: function(){
            if(i >= n){
                throw new Error('end of iteration');
            }else{
                // return a[i++];
                return arguments[i++]; // wrong arguments,此时的arguments已经改变
            }
        }
    }
}

var buffer = {
    entries: [],
    add: function(s){
        this.entries.push(s);
    },
    concat: function(){
        this.entries.join(' ');
    }
};

var source = ['567', '-', '1234'];
source.forEach(buffer.add); // error: entries is undefined

source.forEach(buffer.add, source);
buffer.join(); // '567-1234'

source.forEach(function(s){
    buffer.add(s);
});
buffer.join(); // '567-1234'

source.forEach(buffer.add.bind(buffer));

buffer.add === buffer.add.bind(buffer); // false

function simpleURL(protocol, domain, path){
    return protocol + '://' + domain +'/path';
}

// 一个paths数组中保存着相对路径, 使用这些相对路径构造绝对路径
var urls = paths.map(function(path){
    return simpleURL('http', siteDomain, path);
});

// 可以用bind方法简化
var urls = paths.map(simpleURL.bind(null,'http', siteDomain));

function repeat(n, action){
    for(var i = 0; i < n; ++i){
        eval(action);
    }
}

// 测试函数执行速度的脚本,
var start = [], end = [], timings = [];

repeat(1000, 'start.push(Date.now()); f(); end.push(Date.now())');

for(var i = 0, n = start.length; i < n; ++i){
    timings[i] = end[i] - start[i];
}

// 直接执行没问题,但是若移到函数中,则定义的start, end 不再是全局变量了
function benchmark(){
    var start = [], end = [], timings = [];

    repeat(1000, 'start.push(Date.now()); f(); end.push(Date.now())');

    for(var i = 0, n = start.length; i < n; ++i){
        timings[i] = end[i] - start[i];
    }
    return timings;
}

function repeat(n, action){
    for(var i = 0; i < n; ++i){
        action();
    }
}

function benchmark(){
    var start = [], end = [], timings = [];

    repeat(1000, function(){
        start.push(Date.now());
        f();
        end.push(Date.now());
    });

    for(var i = 0, n = start.length; i < n; ++i){
        timings[i] = end[i] - start[i];
    }
    return timings;
}

(function(x){
    return x + 1;
}).toString(); // 'function(x){\n return x + 1;\n}'

(function(x){
    return x + 1;
}).bind(16).toString(); // 'function(x){ [native code] }'

(function(x){
    return function(y){
        x + y;
    }
})(42).toString(); // 'function(y){ return x + y; }'

var factorial = (function(n){
    return (n <= 1) ? 1 : (n * arguments.callee(n-1));
});

function revealCaller(){
    return revealCaller.caller;
}

function start(){
    return revealCaller();
}

start() === start; // true

function getCallStack(){
    var stack = [];
    for(var f = getCallStack.caller; f; f= f.caller){
        stack.push(f);
    }
    return stack;
}

function f1(){
    return getCallStack();
}

function f2(){
    return f1();
}

var trace = f2();
trace; // [f1, f2]

function f(n){
    return n === 0 ? getCallStack() : f(n-1);
}
var trace = f(1); // infinite loop

function f(){
    ;"use strict";
    return f.caller;
}
f(); // error: caller may not be accessed on strict functions