javascript学习_0219

1、filter高级函数的使用（使用函数进行过滤）

请尝试用filter()筛选出素数：

'use strict';

function get_primes(arr) {

return (arr.filter(function(x){

        if(x <= 1){ return false;}else{
        for(var i = 2;i <= x / 2;i++){
            if(x % i == 0) return false; 
}
        return true;
}
})
);//余数为不为0

}

// 测试:
var
    x,
    r,
    arr = [];
for (x = 1; x < 100; x++) {
    arr.push(x);
}
r = get_primes(arr);
if (r.toString() === [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97].toString()) {
    alert('测试通过!');
} else {
    alert('测试失败: ' + r.toString());
}

2、sort排序函数：通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1。

var arr = [10, 20, 1, 2];
arr.sort(function (x, y) {
    if (x < y) {
        return -1;
    }
    if (x > y) {
        return 1;
    }
    return 0;
}); // [1, 2, 10, 20]

var arr = ['Google', 'apple', 'Microsoft'];
arr.sort(function (s1, s2) {
    x1 = s1.toUpperCase();
    x2 = s2.toUpperCase();
    if (x1 < x2) {
        return -1;
    }
    if (x1 > x2) {
        return 1;
    }
    return 0;
}); // ['apple', 'Google', 'Microsoft']

sort()方法会直接对Array进行修改，它返回的结果仍是当前Array

3、闭包

  例：

function lazy_sum(arr) {
    var sum = function () {
        return arr.reduce(function (x, y) {
            return x + y;
        });
    }
    return sum;
}

var f = lazy_sum([1, 2, 3, 4, 5]); // 返回function sum([1, 2, 3, 4, 5])函数

f();  // 返回函数值15

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

而要注意的一点是当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数，即

var f1 = lazy_sum([1, 2, 3, 4, 5]);
var f2 = lazy_sum([1, 2, 3, 4, 5]);
f1 === f2; // false

f1()和f2()的调用结果互不影响，（意思是两个函数分配到不同的指针上了吧？？）

深入理解：

function count() {
    var arr = [];
    for (var i=1; i<=3; i++) {
        arr.push(function () {
            return i * i;
        });
    }
    return arr;
}

var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];

f1(); // 16
f2(); // 16
f3(); // 16  三个结果相同..

首先，count（）函数返回的是一个函数数组，当count函数运行时，它会一直运行，直到产生三个函数元素，“arr[0],arr[1],arr[2]"，而此时i的值已经成为4（i++）了，于是当这三个元素函数继续调用时，值都是16。而解决方法是不用或者

function count() {
    var arr = [];
    for (var i=1; i<=3; i++) {
        arr.push((function (n) {
            return function () {
                return n * n;
            }
        })(i));
    }
    return arr;
}

var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];

f1(); // 1
f2(); // 4
f3(); // 9

//注意这里用了一个“创建一个匿名函数并立刻执行”的语法：
(function (n) {
            return function () {
                return n * n;
            }
        })(i)

(function (x) {
    return x * x;
})(3); // 9

ps：function (x) { return x * x } (3);会报SyntaxError错误，因此需要用括号把整个函数定义括起来

闭包的作用主要体现在模块化的生成，即私有变量，

'use strict';

function create_counter(initial) {
    var x = initial || 0; //当initail不为空时，x = initail，否则为0
    return {
        inc: function () {
            x += 1;
            return x;
        }
    }
}   //计数器

var c1 = create_counter(); //c1 => { var x ; inc: function () { x +=1; return x; } }
c1.inc(); // 1
c1.inc(); // 2
c1.inc(); // 3

var c2 = create_counter(10);
c2.inc(); // 11
c2.inc(); // 12
c2.inc(); // 13

在返回的对象中，实现了一个闭包，该闭包携带了局部变量x，并且，从外部代码根本无法访问到变量x。换句话说，闭包就是携带状态的函数，并且它的状态可以完全对外隐藏起来。

闭包还可以把多参数的函数变成单参数的函数。例如，要计算xy可以用Math.pow(x, y)函数，不过考虑到经常计算x2或x3，我们可以利用闭包创建新的函数pow2和pow3：

function make_pow(n) {
    return function (x) {
        return Math.pow(x, n);
    }
}

// 创建两个新函数:
var pow2 = make_pow(2); //相当于pow2=>function(x){ return Math.pow(x,2); }
var pow3 = make_pow(3); //相当于pow3=>function(x){ return Math.pow(x,3); }
 
pow2(5); // 25 
pow3(7); // 343

理解下面代码

'use strict';

// 定义数字0:
var zero = function (f) {
    return function (x) {
        return x;
    }
};

// 定义数字1:
var one = function (f) {
    return function (x) {
        return f(x);
    }
};

// 定义加法:
function add(n, m) {
    return function (f) {
        return function (x) {
            return m(f)(n(f)(x));
        }
    }
}

// 计算数字2 = 1 + 1:
var two = add(one, one);

// 计算数字3 = 1 + 2:
var three = add(one, two);

// 计算数字5 = 2 + 3:
var five = add(two, three);

// 你说它是3就是3，你说它是5就是5，你怎么证明？

// 呵呵，看这里:

// 给3传一个函数,会打印3次:
(three(function () {
    console.log('print 3 times');
}))();

// 给5传一个函数,会打印5次:
(five(function () {
    console.log('print 5 times');
}))();