面向对象的JavaScript-008-Function介绍

// 函数
/* Declare the function 'myFunc' */
function myFunc(theObject) {
theObject.brand = "Toyota";
}

/*
* Declare variable 'mycar';
* create and initialize a new Object;
* assign reference to it to 'mycar'
*/
var mycar = {
brand: "Honda",
model: "Accord",
year: 1998
};

/* Logs 'Honda' */
console.log(mycar.brand);

/* Pass object reference to the function */
myFunc(mycar);

/*
* Logs 'Toyota' as the value of the 'brand' property
* of the object, as changed to by the function.
*/
console.log(mycar.brand);

//var y = function x() {};
//alert(x); // throws an error
//var foo = new Function("alert(anonymous);");
//foo();    //Uncaught ReferenceError: anonymous is not defined
foo(); // alerts FOO!
function foo() {
alert('FOO!');
}
var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.

var x = 0;               // source element
if (x == 0) {            // source element
x = 10;               // not a source element
function boo() {}     // not a source element
}
function foo() {         // source element
var y = 20;           // source element
function bar() {}     // source element
while (y == 10) {     // source element
function blah() {} // not a source element
y++;               // not a source element
}
}

// function declaration
function foo() {}

// function expression
(function bar() {})

// function expression
x = function hello() {}

if (x) {
// function expression
function world() {}
}

// function declaration
function a() {
// function declaration
function b() {}
if (0) {
// function expression
function c() {}
}
}

// This function returns a string padded with leading zeros
function padZeros(num, totalLen) {
var numStr = num.toString();             // Initialize return value as string
var numZeros = totalLen - numStr.length; // Calculate no. of zeros
for (var i = 1; i <= numZeros; i++) {
numStr = "0" + numStr;
}
return numStr;
}
var result;
result = padZeros(42,4); // returns "0042"
console.log(result);
result = padZeros(42,2); // returns "42"
console.log(result);
result = padZeros(5,4);  // returns "0005"
console.log(result);

// 菲波那其数
var factorial = function fac(n) { return n<2 ? 1 : n*fac(n-1) };
console.log(factorial(3));

function map(f,a) {
var result = [], // Create a new Array
i;
for (i = 0; i != a.length; i++)
result[i] = f(a[i]);
return result;
}
console.log(map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]));    // returns [0, 1, 8, 125, 1000].

// 阶乘
function factorial(n){
if ((n === 0) || (n === 1))
return 1;
else
return (n * factorial(n - 1));
}
var a, b, c, d, e;
a = factorial(1); // a gets the value 1
b = factorial(2); // b gets the value 2
c = factorial(3); // c gets the value 6
d = factorial(4); // d gets the value 24
e = factorial(5); // e gets the value 120
console.log(a);
console.log(b);
console.log(c);
console.log(d);
console.log(e);

// Function scope
// The following variables are defined in the global scope
var num1 = 20,
num2 = 3,
name = "Chamahk";

// This function is defined in the global scope
function multiply() {
return num1 * num2;
}

multiply(); // Returns 60

// A nested function example
function getScore () {
var num1 = 2,
num2 = 3;

function add() {
return name + " scored " + (num1 + num2);
}

return add();
}

console.log(getScore()); // Returns "Chamahk scored 5"

var x = 0;
while (x < 10) { // "x < 10" is the loop condition
// do stuff
x++;
}

// can be converted into a recursive function and a call to that function:
function loop(x) {
if (x >= 10) // "x >= 10" is the exit condition (equivalent to "!(x < 10)")
return;
// do stuff
loop(x + 1); // the recursive call
}
loop(0);

// However, some algorithms cannot be simple iterative loops. For example, getting all the nodes of a tree structure (e.g. the DOM) is more easily done using recursion:
function walkTree(node) {
if (node == null) //
return;
// do something with node
for (var i = 0; i < node.childNodes.length; i++) {
walkTree(node.childNodes[i]);
}
}

// function foo(i) {
//   if (i < 0)
//     return;
//   console.log('begin:' + i);
//   foo(i - 1);
//   console.log('end:' + i);
// }
//foo(3);
// Output:

// begin:3
// begin:2
// begin:1
// begin:0
// end:0
// end:1
// end:2
// end:3

// Nested functions and closures
function addSquares(a,b) {
function square(x) {
return x * x;
}
return square(a) + square(b);
}
a = addSquares(2,3); // returns 13
b = addSquares(3,4); // returns 25
c = addSquares(4,5); // returns 41

// Since the inner function forms a closure, you can call the outer function and specify arguments for both the outer and inner function:

function outside(x) {
function inside(y) {
return x + y;
}
return inside;
}
fn_inside = outside(3); // Think of it like: give me a function that adds 3 to whatever you give it
result = fn_inside(5); // returns 8

result1 = outside(3)(5); // returns 8

// Multiply-nested functions
function A(x) {
function B(y) {
function C(z) {
console.log(x + y + z);
}
C(3);
}
B(2);
}
A(1); // logs 6 (1 + 2 + 3)

// Name conflicts
function outside() {
var x = 10;
function inside(x) {
return x;
}
return inside;
}
result = outside()(20); // returns 20 instead of 10

// Closures
var pet = function(name) {   // The outer function defines a variable called "name"
var getName = function() {
return name;             // The inner function has access to the "name" variable of the outer function
}
return getName;            // Return the inner function, thereby exposing it to outer scopes
},
myPet = pet("Vivie");

myPet();                     // Returns "Vivie"

var createPet = function(name) {
var sex;

return {
setName: function(newName) {
name = newName;
},

getName: function() {
return name;
},

getSex: function() {
return sex;
},

setSex: function(newSex) {
if(typeof newSex === "string" && (newSex.toLowerCase() === "male" || newSex.toLowerCase() === "female")) {
sex = newSex;
}
}
}
}

var pet = createPet("Vivie");
pet.getName();                  // Vivie

pet.setName("Oliver");
pet.setSex("male");
pet.getSex();                   // male
pet.getName();                  // Oliver

var getCode = (function(){
var secureCode = "0]Eal(eh&2";    // A code we do not want outsiders to be able to modify...

return function () {
return secureCode;
};
})();

getCode();    // Returns the secureCode

var createPet = function(name) {  // Outer function defines a variable called "name"
return {
setName: function(name) {    // Enclosed function also defines a variable called "name"
name = name;               // ??? How do we access the "name" defined by the outer function ???
}
}
}

// Using the arguments object
function myConcat(separator) {
var result = "", // initialize list
i;
// iterate through arguments
for (i = 1; i < arguments.length; i++) {
result += arguments[i] + separator;
}
return result;
}

// returns "red, orange, blue, "
myConcat(", ", "red", "orange", "blue");

// returns "elephant; giraffe; lion; cheetah; "
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");

// returns "sage. basil. oregano. pepper. parsley. "
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");

// Default parameters
function multiply(a, b) {
b = typeof b !== 'undefined' ?  b : 1;

return a*b;
}

multiply(5); // 5

// function multiply2(a, b = 1) {
//   return a*b;
// }

// multiply2(5); // 5

// Rest parameters
// function multiply(multiplier, ...theArgs) {
//   return theArgs.map(x => multiplier * x);
// }

// var arr = multiply(2, 1, 2, 3);
// console.log(arr); // [2, 4, 6]

// Arrow functions
var a = [
"Hydrogen",
"Helium",
"Lithium",
"Beryl­lium"
];

var a2 = a.map(function(s){ return s.length });

// var a3 = a.map( s => s.length );

// Lexical this

function Person() {
// The Person() constructor defines `this` as itself.
this.age = 0;

setInterval(function growUp() {
// In nonstrict mode, the growUp() function defines `this`
// as the global object, which is different from the `this`
// defined by the Person() constructor.
this.age++;
}, 1000);
}

var p = new Person();

function Person() {
var self = this; // Some choose `that` instead of `self`.
// Choose one and be consistent.
self.age = 0;

setInterval(function growUp() {
// The callback refers to the `self` variable of which
// the value is the expected object.
self.age++;
}, 1000);
}

// function Person(){
//   this.age = 0;

//   setInterval(() => {
//     this.age++; // |this| properly refers to the person object
//   }, 1000);
// }

// var p = new Person();