jsFunction函数
jsarray删除元素函数
var abs = function (x) {
if (x >= 0) {
return x;
} else {
return -x;
}
};
函数体内部的语句在执⾏时，⼀旦执⾏到return时，函数就执⾏完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现⾮常复杂的逻辑。
在这种⽅式下，function (x) { ... }是⼀个匿名函数，它没有函数名。但是，这个匿名函数赋值给了变量abs，所以，通过变量abs就可以调⽤该函数
如果没有return语句，函数执⾏完毕后也会返回结果，只是结果为undefined。
要避免收到undefined，可以对参数进⾏检查：
function abs(x) {
if (typeof x !== 'number') {
throw 'Not a number';
}
if (x >= 0) {
return x;
} else {
return -x;
}
}
arguments
它只在函数内部起作⽤，并且永远指向当前函数的调⽤者传⼊的所有参数。arguments类似Array但它不是⼀个Array：
function foo(x) {
alert(x); // 10
for (var i=0; i<arguments.length; i++) {
alert(arguments[i]); // 10, 20, 30
}
}
foo(10, 20, 30);
利⽤arguments，你可以获得调⽤者传⼊的所有参数。也就是说，即使函数不定义任何参数，还是可以拿到参数的值：
function abs() {
if (arguments.length === 0) {
return 0;
}
var x = arguments[0];
return x >= 0 ? x : -x;
}
abs(); // 0
abs(10); // 10
abs(-9); // 9
实际上arguments最常⽤于判断传⼊参数的个数。你可能会看到这样的写法：
// foo(a[, b], c)
// 接收2~3个参数，b是可选参数，如果只传2个参数，b默认为null：
function foo(a, b, c) {
if (arguments.length === 2) {
// 实际拿到的参数是a和b，c为undefined
c = b; // 把b赋给c
b = null; // b变为默认值
}
// ...
}
要把中间的参数b变为“可选”参数，就只能通过arguments判断，然后重新调整参数并赋值。
rest
由于JavaScript函数允许接收任意个参数，于是我们就不得不⽤arguments来获取所有参数：
function foo(a, b) {
var i, rest = [];
if (arguments.length > 2) {
for (i = 2; i<arguments.length; i++) {
rest.push(arguments[i]);
}
}
console.log('a = ' + a);
console.log('b = ' + b);
console.log(rest);
}
为了获取除了已定义参数a、b之外的参数，我们不得不⽤arguments，并且循环要从索引2开始以便排除前两个参数，这种写法很别扭，只是为了获得额外的rest参数，有没有更好的⽅法？
ES6标准引⼊了rest参数，上⾯的函数可以改写为：
function foo(a, b, ...rest) {
console.log('a = ' + a);
console.log('b = ' + b);
console.log(rest);
}
foo(1, 2, 3, 4, 5);
// 结果:
// a = 1
// b = 2
// Array [ 3, 4, 5 ]
foo(1);
// 结果:
// a = 1
// b = undefined
// Array []
rest参数只能写在最后，前⾯⽤...标识，从运⾏结果可知，传⼊的参数先绑定a、b，多余的参数以数组形式交给变量rest，所以，不再需要arguments我们就获取了全部参数。
如果传⼊的参数连正常定义的参数都没填满，也不要紧，rest参数会接收⼀个空数组（注意不是undefined）。
⼩⼼你的return语句
前⾯我们讲到了JavaScript引擎有⼀个在⾏末⾃动添加分号的机制，这可能让你栽到return语句的⼀个⼤坑：
function foo() {
return { name: 'foo' };
}
foo(); // { name: 'foo' }
如果把return语句拆成两⾏：
function foo() {
return
{ name: 'foo' };
}
foo(); // undefined
要⼩⼼了，由于JavaScript引擎在⾏末⾃动添加分号的机制，上⾯的代码实际上变成了：
function foo() {
return; // ⾃动添加了分号，相当于return undefined;
{ name: 'foo' }; // 这⾏语句已经没法执⾏到了
}
所以正确的多⾏写法是：
function foo() {
return { // 这⾥不会⾃动加分号，因为{表⽰语句尚未结束
name: 'foo'
};
}
变量提升
JavaScript的函数定义有个特点，它会先扫描整个函数体的语句，把所有申明的变量“提升”到函数顶部：
'use strict';
function foo() {
var x = 'Hello, ' + y;
alert(x);
var y = 'Bob';
}
foo();
虽然是strict模式，但语句var x = 'Hello, ' + y；并不报错，原因是变量y在稍后申明了。但是alert显⽰Hello, undefined，说明变量y的值为undefined。这正是因为JavaScript引擎⾃动提升了变量y的声明，但不会提升变量y的赋值。
对于上述foo()函数，JavaScript引擎看到的代码相当于：
function foo() {
var y; // 提升变量y的申明
var x = 'Hello, ' + y;
alert(x);
y = 'Bob';
}
由于JavaScript的这⼀怪异的“特性”，我们在函数内部定义变量时，请严格遵守“在函数内部⾸先申明所
有变量”这⼀规则。最常见的做法是⽤⼀个var申明函数内部⽤到的所有变量：
function foo() {
var
x = 1, // x初始化为1
y = x + 1, // y初始化为2
z, i; // z和i为undefined
// 其他语句:
for (i=0; i<100; i++) {
...
}
}
⾼阶函数
⾼阶函数英⽂叫Higher-order function。那么什么是⾼阶函数？
JavaScript的函数其实都指向某个变量。既然变量可以指向函数，函数的参数能接收变量，那么⼀个函数就可以接收另⼀个函数作为参数，这种函数就称之为⾼阶函数。
⼀个最简单的⾼阶函数：
function add(x, y, f) {
return f(x) + f(y);
}
当我们调⽤add(-5, 6, Math.abs)时，参数x，y和f分别接收-5，6和函数Math.abs，根据函数定义，我们可以推导计算过程为：
x = -5;
y = 6;
f = Math.abs;
f(x) + f(y) ==> Math.abs(-5) + Math.abs(6) ==> 11;
return 11;
⽤代码验证⼀下：
add(-5, 6, Math.abs); // 11
编写⾼阶函数，就是让函数的参数能够接收别的函数。
举例说明，⽐如我们有⼀个函数f(x)=x2，要把这个函数作⽤在⼀个数组[1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以⽤map实现如下：
由于map()⽅法定义在JavaScript的Array中，我们调⽤Array的map()⽅法，传⼊我们⾃⼰的函数，就得到了⼀个新的Array作为结果：
function pow(x) {
return x * x;
}
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(pow); // [1, 4, 9, 16, 25, 36, 49, 64, 81]
map()传⼊的参数是pow，即函数对象本⾝。
你可能会想，不需要map()，写⼀个循环，也可以计算出结果：
var f = function (x) {
return x * x;
};
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var result = [];
for (var i=0; i<arr.length; i++) {
result.push(f(arr[i]));
}
的确可以，但是，从上⾯的循环代码，我们⽆法⼀眼看明⽩“把f(x)作⽤在Array的每⼀个元素并把结果⽣成⼀个新的Array”。
所以，map()作为⾼阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，⽐如，把Array的所有数字转为字符串：
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(String); // ['1', '2', '3', '4', '5', '6', '7', '8', '9']
只需要⼀⾏代码。