定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例

1
2

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

题解

反转链表可以用迭代（双指针）或递归两种方法实现

方法一：迭代（双指针）

总体思想是遍历链表，在访问各节点时修改next引用指向。

时间复杂度： 遍历链表使用线性大小时间为O(N)。

空间复杂度： 变量 pre 和 cur 使用常数大小额外空间为O(1)。

1. 分别初始化cur、pre，分别指向头结点和null。

1. 链表指向是单向的，在改变当前节点指向并指向前序节点pre时，当前节点cur和后续节点之间的指向会断开，为了避免这种情况，我们需要在改变节点指向之前设置tmp值将cur的后续节点保存下来。

   

2. 暂存当前节点，并访问下一个节点。

   

3. tmp保存cur的后续节点。

   

4. 以下操作同上~~，最终得到以下结果

   

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *cur = head, *pre = nullptr;
        while(cur != nullptr) {
            ListNode* tmp = cur->next; // 暂存后继节点 cur.next
            cur->next = pre;           // 修改 next 引用指向
            pre = cur;                 // pre 暂存 cur
            cur = tmp;                 // cur 访问下一节点
        }
        return pre;
    }
};

方法二：递归

​ 使用递归的方法去遍历链表，当越过尾节点后终止递归，在回溯时候修改各节点next引用指向。

需要注意以下几点：

• 在recur(cur, pre) 递归函数中，当 cur 为空，则返回尾节点pre（即反转链表的头节点）
• 递归后继节点，记录返回值（即反转链表的头节点）为 res
• 修改当前节点 cur引用指向前驱节点pre；
• 返回反转链表的头节点res；

时间复杂度： 遍历链表使用线性大小时间为 O(N) 。
空间复杂度 ： 遍历链表的递归深度达到N ，系统使用额外空间大小为O(N) 。

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        return recur(head, nullptr);           // 调用递归并返回
    }
private:
    ListNode* recur(ListNode* cur, ListNode* pre) {
        if (cur == nullptr) return pre;        // 终止条件
        ListNode* res = recur(cur->next, cur); // 递归后继节点
        cur->next = pre;                       // 修改节点引用指向
        return res;                            // 返回反转链表的头节点
    }
};

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例

1
2

输入：head = [1,3,2]
输出：[2,3,1]

题解

​ 这道题主体思想是访问链表中的元素并设法倒序输出结果。

方法一：递归法

​ 利用递归的方法先递推至链表末端，在回溯时依次将节点值加入列表，即可实现链表值的倒序输出。

需要注意的是：

• 程序总是要有执行完毕的时候，当head == nullptr时，代表超越了链表尾节点，返回空列表

时间复杂度：遍历链表，递归N次。

空间复杂度：系统递归需要使用O(N)的栈空间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        recur(head);
        return res;
    }
private:
    vector<int> res;
    void recur(ListNode* head) {
        if(head == nullptr) return;
        recur(head->next);
        res.push_back(head->val);
    }
};

方法二：迭代器反转法

​ 链表只能从前往后访问每个节点，因为要倒序输出各节点值，所以我们也可以借助reverse()函数实现链表值的倒序输出。

需要注意的是：

• 当head != nullptr时，从前往后依次访问节点并将其添加到res容器中去

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> res;
        while(head != nullptr)
        {
            res.push_back(head->val);
            head = head->next;
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

方法三：辅助栈法

​ 链表只能从前往后访问每个节点，因为要倒序输出各节点值，我们可以借助栈来实现。

时间复杂度： 入栈和出栈共使用O(N)时间。
空间复杂度： 辅助栈 stack 和数组 res 共使用O(N)的额外空间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        stack<int> stk;
        while(head != nullptr) {
            stk.push(head->val);
            head = head->next;
        }
        vector<int> res;
        while(!stk.empty()) {
            res.push_back(stk.top());
            stk.pop();
        }
        return res;
    }
};

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例

1
2
3
4
5
6
7
8

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

题解

​ 实现能够得到栈的最小元素min函数，需要遍历栈中所有元素，这一过程复杂度为O(N)，题目要求min函数的复杂度是O(1)，我们可以通过分别定义两栈stk和stk_min来实现，其中stk用来存入push进来的栈元素，stk_min用来存储stk中最小值，stk中的最小元素始终对应着stk_min中的栈顶元素，min函数只需返回stk_min中的栈顶元素即可。

设计该数据结构时我们需要注意以下几点：

• push(x)函数中，在元素x压入stk后，如果stk_min为空则将元素x压入stk_min，如果stk_min不为空，则判断stk_min中当前栈顶元素是否小于元素x，如果小于则返回stk_min中的栈顶元素，反之返回元素x，将当前的值压入stk_min中。
• pop()函数中要将stk和stk_min中对应的最小值元素同时弹出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class MinStack {
public:
    stack<int> stk, stk_min;

    /** initialize your data structure here. */
    MinStack() {}
    
    void push(int x) {
        stk.push(x);
        if (!stk_min.empty())
        {
            int num = stk_min.top() < x ? stk_min.top():x;
            stk_min.push(num);
        }
        else 
        {
            stk_min.push(x);
        }
    }
    
    void pop() {
        stk.pop();
        stk_min.pop();
    }
    
    int top() {
        return stk.top();
    }
    
    int min() {
        return stk_min.top();
    }
};

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )。

示例

1
2
3
4
5
6
7
8
9

输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]

题解

​ 两栈实现一个队列，appendTail需要实现队列尾部插入整数，deleteHead需要实现队列头部删除整数，因为栈的数据结构特征是先进后出，所以栈底元素无法直接被删除，如要删除需要将其上方的元素进行出栈操作，使用两栈实现列表倒序操作可以实现此功能，顺应两栈实现一队列。

​ 分别定义stk1和stk2两栈，将元素压入stk1中，执行删除操作要循环执行stk1元素出栈将其添加入栈到stk2中，实现了stk2中元素为stk1中元素的倒序，stk2中栈首的元素弹出即为删除stk1中栈底元素，即删除队列头部元素。

在deleteHead()我们需要注意以下情况：

• 当stk2不为空时，stk2中依然有已完成倒序的元素，因此要直接返回stk2的栈顶元素。
• 当stk1为空时，两栈都为空，无元素返回-1。
• 当stk1不为空时，将stk1元素全部压到stk2中，实现元素倒序，并返回stk2的栈顶元素。

时间复杂度：appendTail()函数为O(1) ；deleteHead() 函数在 N 次队首元素删除操作中总共需完成 N 个元素的倒序。

空间复杂度 O(N) ： 最差情况下，stk1 和 stk2 共保存 N 个元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class CQueue {
public:
    stack<int> stk1, stk2;
    CQueue() {}
    
    void appendTail(int value) {
        stk1.push(value);
    }
    
    int deleteHead() {
        if (!stk2.empty())
        {
           int stack_top = stk2.top();
           stk2.pop();
           return stack_top; 
        }

        if (stk1.empty())
            return -1;
        
        while (!stk1.empty())
        {
            int stack_top = stk1.top();
            stk1.pop();
            stk2.push(stack_top);
        }
        int stack_top = stk2.top();
        stk2.pop();
        return stack_top;
    }
};

​ GCC是由GNU开发的编程语言编译器，GNU编译器套件包括C、C++、Objective-C、Java、Ada 和 Go 语言前端，也包括了这些语言的库（如 libstdc++，libgcj等）,它可以完成上述编程语言从源文件向运行在特定CPU硬件上的目标代码的转换，GCC不仅功能非常强大，而且结构也很灵活，具有良好的便携性和跨平台支持。

二、GCC/G++安装命令

1

sudo apt install gcc g++ 

安装好后可以通过以下命令来查看gcc/g++版本，确定是否安装成功

1
2

gcc -v# 查看gcc版本
g++ -v# 查看g++版本

三、GCC编译工具支持的文件类型

四、GCC使用方法

gcc是基于Linux平台下的C语言编译器，其基本的使用语法如下。

1

gcc [option | fileName] [fileName] [destination fileName]

g++是基于Linux平台下的C++语言编译器，其基本的使用语法如下。

1

g++ [option | fileName] [fileName] [destination fileName]

五、GCC编译工具工作流程

​ gcc由C源代码文件生成可执行文件的过程不仅仅是编译的过程，而是要经历以下步骤。

这里我们以helloworld.c文件为例来阐述gcc的工作流程。

源文件代码如下：

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
#define NUM 20

int main() 
{
    char s[NUM]="\0";
    printf("Please enter the content.\n");
    fgets(s, NUM, stdin);
    printf("%s", s);
    return 0;
}

（1）预处理阶段

​ 预处理过程中，将源代码文件中包含的各种头文件以及预编译语句等展开生成后缀以.i结尾的文件。

1

gcc -E helloworld.c -o helloworld.i

编译生成的helloworld.i文件内容如图所示：

（2）编译阶段

​ 将预处理后以.i结尾的文件编译生成后缀以.s结尾的汇编语言代码文件。

1

gcc -S helloworld.i -o helloworld.s

编译生成的helloworld.s文件内容如图所示：

（3）汇编阶段

​ 将以.s为后缀的汇编语言文件经过汇编后生成后缀以.o结尾的目标文件。

1

gcc -c helloworld.s -o helloworld.o

编译生成的helloworld.o文件内容如图所示：

​ 打开文件我们看到其中的的内容是由各种特殊字符组成，汇编阶段的工作是将汇编语言的代码转换为机器码，这部分代码是可以直接被计算机所执行的，我们通过file helloworld.o指令查看一下该文件的类型。

1

helloworld.o: ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped

我们可以得知该文件的文件格式是elf格式，elf格式的文件我们可以使用readelf工具查看其中内容。

1

readelf -a helloworld.o

（4）链接阶段

​ 将所有源文件对应的目标文件链接起来安排在可执行程序中恰当的位置，将程序中所调用的库函数链接起来，最终生成一个可执行的程序。

1

gcc helloworld.o -o helloworld

​ 在实际开发过程中，我们在编译生成可执行文件时不会一步一步执行上述命令，而是直接使用下面的命令完成预处理、编译、汇编和链接生成可执行文件。

1

gcc helloworld.c -o helloworld

运行结果

​ 在上述的执行过程中，我们还需要知道的是，在链接阶段，链接的方式有两种，一种是静态链接，另一种是动态链接。

​ 其中静态链接是在gcc链接执行代码后面加上 --static选项，静态链接在gcc链接时就会将程序所用到的库打包到自己的可执行程序中，无需依赖外部环境，程序兼容性比较好，但是生成的程序比较大。

​ 动态链接是在程序运行时将外部的代码库动态加载到内存中，在gcc链接时不会将代码打包到可执行程序中，生成的程序比较小。gcc的编译链接时候默认是以动态链接的方式加载的。我们可以使用ldd工具去查看动态文件的库依赖。

​ 我们由此可以得知通过动态链接生成的helloworld依赖于库文件linux-vdso.so.1、libc.so.6 以及ld-linux-x86-64.so.2。

​ 我们可以分别以静态链接和动态链接的方式去编译链接上面的程序，并去查看一下两种方式生成的可执行文件的大小。

​ 动态链接生成的可执行文件大小为17k，静态链接生成的可执行文件大小为852k。

六、GCC常用参数选项

一、简介

​ pcap文件是一种常用的数据报存储格式，里面的数据按照特定的规格存储和解析。

​ 一般来说使用普通的笔记本打开的pcap文件显示的是乱码，所以我们需要使用支持16进制格式的工具去查看该文件，这里使用https://hexed.it/ 这个在线网站去查看。

二、文件格式

​ pcag文件格式主要是由文件头-数据包头1-数据包1-数据包头2-数据包2这类格式组成。其中文件头只有一个，数据包头和数据包可以有多个，如下图所示。

​ 每个pcap文件只有一个文件头，里面包含7个字段，总共占24(B)字节。

1.Pcap Header

2.Packet Header

3.Packet Data

​ Packet是链路层的数据帧，其长度是Packet Header中定义的Caplen值，所以Packet Data的长度为Caplen。

4.案例

​ 打开文件后如图所示（这里截取前面的部分）

Pcap Header

Packet Header

Packet Data

​ 数据包大小为0X00000042 = 66B

1.下载owasp

2.将owasp添加到VMware中

3.启动owasp

4.使用ifconfig查看自己的owasp当前的ip地址，在kali中打开浏览器试的去访问一下该ip是否可以正常使用

5.可以正常使用

6.在kali中使用自带的medusa工具去破解owasp的密码

注意：在使用medusa之前需要先去生成一个密码字典，来方便我们对其进行破解，密码字典的生成可以使用Crunch工具或John工具。

6.1 输入以下指令开始破解

1

1 medusa -h [目标ip地址] -u [用户名] -P [密码字典] -M [目标使用的协议]

最终破解成功

注：该文章中使用到的方法只用于学习交流，切勿用于非法途径！！！

注：该文章中使用到的方法只用于学习交流，切勿用于非法途径！！！

1. 开启win7的3389端口（远程桌面端口）

3389端口是Windows的远程桌面的服务端口，可以通过这个端口，用”远程桌面”等连接工具来连接到远程的服务器，在连接成功后，输入系统管理员的用户名和密码后，就可以操作远程的电脑，因此远程服务器一般都将这个端口修改数值或者关闭。

1.1 打开控制面板

1.2 点击远程设置

1.3 选择运行任意版本远程桌面的计算机连接（默认是不允许连接到这台计算机）

2. 打开cmd输入Firewall.cpl指令打开防火墙设置

2.1 点击打开或关闭防火墙

2.2 两个选项都选择关闭防火墙

3.在kali中使用自带的nmap工具去扫描win7主机所在ip地址范围内的所有ip地址，查看同网段内的主机的3389端口是开放的

3.1 输入以下命令开启扫描

1

nmap -p 3389 [要扫描的ip地址范围，比如192.168.1.1-255]

3.2 看到主机ip为192.168.178.131的3389端口已启动

4. 使用Crunch或John等工具生成密码字典，为后面使用hydra工具去破解win7密码做准备工作

5.使用hydra工具去破解win7所登录账户的密码

5.1 输入以下命令去破解

1

hydra -l [windows的账户名] -P [密码字典] rdp://[win7的ip地址]

最终破解成功

注：该文章中使用到的方法只用于学习交流，切勿用于非法途径！！！

无论是什么程序设计语言，函数都是重要的一部分内容，在实际开发过程中有很多语法的表达和功能的实现都来源于函数。不过与其它语言不同的是，JavaScript是通过函数来实现面向对象的特性并非通过专门的面向对象语法去实现的，因为JavaScript没有属于自己的专门的面向对象语法，所以函数在JavaScript中更是重中之重。

一、函数的介绍

1.什么是函数？

函数是执行特定任务的代码块，之后通过调用函数实现特定任务功能的实现。

2.函数的组成部分

• 关键字function。
• 函数名称。
• 函数所需要的参数，参数可以是0个，也可以是多个，参数之间要用逗号分隔。
• 函数执行的代码块，即函数体。
• 返回值语句return，函数通常都会有返回值，如果某个函数没有显式的返回值，默认返回值为undefined。

1
2
3
4

1 function sum(number1,number2) {
2     var sum = number1 + number2;
3     return sum;
4 }

3.如何去调用函数？

在明白了函数的组成部分后，我们就可以成功创建函数了。不过这只是第一步，在我们创建函数之后要想去使用函数还需去调用函数，因为函数不调用的话是不会执行的。

调用函数的方法是在函数名加传递参数的括号即可。

1
2
3
4
5
6

function sum(number1,number2) {
    var sum = number1 + number2;
    return sum;
}
var result = sum(5,4);
console.log(result);        //9

4.关于函数中的参数

定义函数的时候我们可能会设置函数所需要的调用参数，这个参数的设定不是必须的，可以选择不设定。如果设定了调用参数，在调用函数的时候就必须要传递相关的参数值，程序才能正常执行。如果没有传递相关的参数值，未被传递参数值的地方就会默认为undefined。

1
2
3
4
5
6
7
8
9
10
11
12
13

//函数中设置了调用参数但是在调用函数的过程中并未去传递相关参数值导致的结果。
function sum1(number) {
    return number;
}
var result1 = sum1();
console.log(result1);    //undefined

//函数中漏传参数导致参数+undefined得到NaN。
function sum2(number1,number2) {
     return number1 + number2;
}
var result2 = sum2(1);
console.log(result2);    //NaN

参数分为形式参数和实际参数两种，其中形式参数是指定义函数时所用到的参数，实际参数是指在调用函数时所传递的参数。

1
2
3
4
5
6

function sum(number1,number2) {
    var sum = number1 + number2;
    return sum;
}
var result = sum(5,4,3,2,1);    //JavaScript只会解析5和4这两个值，最后输出结果9，其它会被忽略
console.log(result);

不过我们可以使用arguments变量在函数中去调用并返回接受的所有参数，arguments变量是内建变量，在每个函数中都能调用。

1
2
3
4
5
6

function args() {
    return arguments;
}
var result = args(5,4,3,2,1,true,"A",'b');
//Arguments(8) [5, 4, 3, 2, 1, true, "A", "b", callee: ƒ,Symbol(Symbol.iterator): ƒ]
console.log(result);

通过arguments可以对参数进行求和运算。

1
2
3
4
5
6
7
8
9

function sum() {
    var result = 0;
    for(var i = 0 ; i < arguments.length ; i++) {
        result += arguments[i];
    }
    return result;
}
var res = sum(5,4,3,2,1);
console.log(res);            //15

二、parseInt()

parseInt()会将接收到任何输入值转换为整数类型输出，通常都是输入字符串，转换失败则返回NaN。

1
2
3
4
5
6
7
8
9
10
11
12

 1 var a = parseInt("5a7b6");
 2 console.log(a);            //5
 3 var b = parseInt("1024");
 4 console.log(b);            //1024
 5 var c = parseInt("abc1024");
 6 console.log(c);            //NaN
 7 var d = parseInt("3.14");
 8 console.log(d);            //3
 9 var e = parseInt("0124");
10 console.log(e);            //124
11 var f = parseInt("0x1024");
12 console.log(f);            //4132

parseInt(string,radix)中可以传两个值，第一个值可以解析的是字符串，第二个值解析的是数字的基数，即设定函数所要被解析的数据类型，其中可以传递的进制值范围在2~36之间，如果以”0x”开头第二参数则默认指定为16进制数。

1
2

1 var a = parseInt("0x1024");
2 console.log(a);            //4132

注意：在这个函数的应用过程中我们会发现一个很有趣的现象，如果以“0x”开头的数字第二参数默认指定为16进制数，那么按道理以“0”开头的数字第二参数应该会被默认指定为8进制数，但是在现实中并不是这样的。如果我们使用parseInt()函数反而得不到这个结果，以“0”开头的数字最终会忽略0而被解析0后面的数字为10进制的数值。因为ECMAScript5移除了8进制的默认表示法，这种做法是避免了在8进制解析和10进制解析时候的混淆。

1
2

1 var a = parseInt("0124");
2 console.log(a);            //124

三、parseFloat()

上面我们学习了parseInt()的使用，parseFloat()的使用与parseInt()是基本相同的，区别在于parseFloat()只能将输入值转换为十进制数，所以这个函数只能传入一个参数。而且parseFloat()解析的字符串返回的是一个浮点数。

1
2
3
4
5
6
7
8

1 var a = parseFloat("3.14a");
2 console.log(a);            //3.14
3 var b = parseFloat("3.14");
4 console.log(b);            //3.14
5 var c = parseFloat("1.230800");
6 console.log(c);            //1.2308
7 var d = parseFloat("ab12c");
8 console.log(d);            //NaN

parseFloat()可以接受指数形式的数据。

1
2
3
4

1 var a = parseFloat("123e-2");
2 console.log(a);            //1.23
3 var b = parseFloat("1e5");
4 console.log(b);            //100000

四、isNaN()

　使用isNaN()函数可用于检查参数是否是非数字值。

1
2
3
4
5
6
7
8

1 console.log(isNaN(1024));            //false
2 console.log(isNaN(-1024));            //false
3 console.log(isNaN(1.024));            //false
4 console.log(isNaN(-1.024));            //false
5 console.log(isNaN(2024-2));            //false
6 console.log(isNaN(0));                //false
7 console.log(isNaN("JavaScript"));    //true
8 console.log(isNaN("2021/01/01"));    //true

使用isNaN()函数可以检测parseInt()和parseFloat()是否成功调用。

1
2
3
4
5
6
7
8
9
10

 1 var a = isNaN(parseInt("0x1024"));
 2 console.log(a);        //false
 3 var b = isNaN(parseFloat("1.1"));
 4 console.log(b);        //false
 5 var c = isNaN(parseInt("1.2"));
 6 console.log(c);        //false
 7 var d = isNaN(parseInt("ac1024"));
 8 console.log(d);        //true
 9 var e = isNaN(parseFloat("ac1024"));
10 console.log(e);        //true

值得一提的是，NaN自己不存在等值的概念，所以NaN == NaN返回的是false。

五、isFinite()

isFinite()可以检查输入的是否是一个非Infifnity非NaN的数字。

1
2
3
4
5
6
7

1 console.log(isFinite(Infinity));    //false
2 console.log(isFinite(-Infinity));    //false
3 console.log(isFinite(1024));        //true
4 console.log(isFinite(1e308));        //true
5 console.log(isFinite(-1e308));        //true
6 console.log(isFinite(1e309));        //false
7 console.log(isFinite(-1e309));        //false

六、eval()

eval()函数会将输入的字符串当做JavaScript代码执行。

1
2

eval('var a = 1;');
console.log(a);            //1

七、变量的作用域

　在JavaScript中，变量的作用域是以函数作为作用域的，即变量如果是在某个函数定义的，该变量在函数以外的地方是不可见的。如果该变量是定义在if或者for这样的代码块中，它在代码块之外是可见的。定义在所有函数之外的变量是全局变量，定义在函数中的变量是局部变量。

1
2
3
4
5
6
7
8
9
10
11

 1 var number1 = 1;
 2 function f() {
 3     var number2 = 4;
 4     number1++;
 5     console.log(number2);   //4
 6     return number1;
 7 }
 8 console.log(number1);   //1
 9 var result = f();
10 console.log(result);    //2
11 console.log(number2);   //Uncaught ReferenceError: number2 is not defined

　由以上示例可以看出函数f()可以访问number1，number1是全局变量，而在函数体外number2无法被访问，因为number2是局部变量，局部变量只能在本函数中被访问。
　但是，在JavaScript中总有一些令人比较惊讶的现象。如果在声明变量的时候没有去使用关键字变量去定义相关变量的话，该变量会被默认为全局变量。

1
2
3
4
5
6

1 var number1 = 1;
2 function f() {
3     number2 = 2;
4 }
5 f();
6 console.log(number2);        //2

八、匿名函数

没有名字的函数被称为匿名函数。

1
2
3
4
5
6

1 var a = function() {
2     return 2;
3 }
4 var b = function(x) {
5     return x;
6 }

　形如以上的示例就是匿名函数。当匿名函数不被赋值给变量去单独使用的时候，这类函数有两种用法：

• 可以将匿名函数作为参数传递给其它函数，这样接收方函数可以利用传递的函数完成某些事情。
• 可以去定义某个匿名函数执行某些一次性任务。
• 在后面的内容中我们会用到这些用法。

九、回调函数

1.回调函数与匿名回调函数

函数A传递给函数B，函数B来执行函数A的时候，A就是一个回调函数。

1
2
3
4
5
6
7
8
9

1 function sum(a) {
2     return a();
3 }
4 var result = sum( 
5     function() {
6         return 1;
7     }
8     );  
9     console.log(result);    //1

也可以使用回调函数进行进行加法运算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 1 function sum(a,b,c) {
 2     return a() + b() + c();
 3 }
 4 var result = sum(
 5     
 6     function() {
 7         return 1;
 8     },
 9     function() {
10         return 2.5;
11     },
12     function() {
13         return 3;
14     }
15     );  
16     console.log(result);    //6.5

我们看到这两个示例中在调用sum的时候都是使用了匿名函数，而且这些匿名函数也是一个回调函数，这样的函数我们称之为匿名回调函数。

2.什么情况下使用回调函数？

• 在未命名的情况下去传递函数，从而节省变量名的使用。
• 将一个函数调用给另一个函数去执行，可以节省一些代码编写工作。
• 在数据量很大的情况下使用回调函数是一个好的选择。

1
2
3
4
5
6
7
8
9
10
11
12
13

 1 function sum(a,b,c,returnValue) {
 2     var array = [];
 3     for(var i = 0;i < 3;i++) {
 4         array[i] = returnValue(arguments[i] * 2);
 5     }
 6     return array;
 7 }
 8 
 9 var result = sum(1,2,3,function(a) {
10     return a + 1;
11 });
12 
13 console.log(result);        //[3, 5, 7]

十、即时函数

可以在被定义后立即调用的函数是即时函数。

1
2
3
4
5

1 (
2     function() {
3         console.log('JavaScript');    //JavaScript
4     }
5 )();

括号也可以放在第二对括号之后。

1
2
3
4
5

1 (
2     function(message) {
3         console.log('Hello ' + message);        //Hello JavaScript
4     }
5 ('JavaScript'));

使用匿名函数的好处是不会产生任何全局变量。缺点是在于这样的函数是无法重复执行的，这也使即时函数非常适合于去执行一些一次性的或初始化的任务。

十一、内部函数

1.什么是内部函数？

在一个函数内部定义另一个函数，内部定义的函数就被称为内部函数，内部函数也叫做私有函数，只能在内部去访问。

1
2
3
4
5
6
7
8
9

1 function outer(param) {
2     
3     function inner(theinput) {
4         return theinput * 2;
5     }
6           return 'The result is ' + inner(param);
7 }
8 
9 console.log(outer(2));        //The result is 4

2.私有函数的特点

• 确保全局名字空间的唯一性，以免命名冲突。
• 确保一些函数的私有性，做到只将一部分必要的函数暴露在外，具有一定的安全性。

十二、返回函数的函数

返回函数的函数听起来有些奇怪，不过细细想一想的话就是在一个函数中的返回值也是一个函数，这就是返回函数的函数。

1
2
3
4
5
6
7
8
9
10
11
12

 1 function a() {
 2     console.log("Hello");
 3     return function() {
 4         console.log("JavaScript");
 5     }
 6 }
 7 var result = a();    //Hello
 8 result();    //JavaScript
 9 
10 //也可以这样去输出，结果是相同的
11 //a()();    //Hello
12             //JavaScript

十三、函数可以被重写

还是上面的例子，我们可以使用新的函数去覆盖旧的函数，我们在函数内部去重写函数覆盖外部的函数。

1
2
3
4
5
6
7
8

1 function a() {
2     alert("Hello");
3     b = function() {
4         alert("JavaScript");
5     }
6 }
7 a();    //Hello
8 b();    //JavaScript

十四、闭包

在看闭包之前先看一个示例：

1
2
3
4
5
6
7
8
9
10
11
12

 1 function sum(number) {
 2     var all = 0;
 3     return all += number;
 4 }
 5 
 6 console.log(sum(1));    //1
 7 console.log(sum(1));    //1
 8 console.log(sum(1));    //1
 9 console.log(sum(1));    //1
10 console.log(sum(2));    //2
11 console.log(sum(2));    //2
12 console.log(sum(3));    //3

　上面的示例中我们如果不改变传入函数的数值无论是调用多少次最终的结果就不会被改变，在某些应用场景下这是极其不方便的，这时候就引入了闭包。在使用闭包的时候，我们可以在反复调用的过程中去不停的进行值的改变。在实际中我们可以以日常多开网站去举例。
我们日常可能会多开好几个网站，每个网站我们可能会在同一个浏览器上打开好几个，在我们打开同一个浏览器好几个页面的时候会占用内存空间，几个页面运行的过程中可以看做是反复调用函数，这个过程中我们在同一个浏览器去打开多个页面的时候每次打开的页面都和我们上次打开的页面不同，这个过程细化过来我们可以将其看做是闭包，是调用函数且还占用内存去执行并变化的过程，变量会一直保留在内存中，所以我们在最小化浏览器页面后浏览器并未被关闭，内存依然会被占用。

1
2
3
4
5
6
7
8
9
10
11
12
13

 1 function sum(number) {
 2     var all = 0;
 3     return function() {
 4         all += 1;
 5         return all;
 6     }
 7 }
 8 
 9 var storage = sum();
10 console.log(storage());    //1
11 console.log(storage());    //2
12 console.log(storage());    //3
13 console.log(storage());    //4

　 从上面的示例可以明白闭包是创建一个函数，用一些变量包装起来，之后再保存起来去使用，而函数保留对其作用域访问的过程我们就称之为闭包。
当然，每次在定义函数的时候都会为函数创建闭包，所以我们可以说每个函数都有闭包。但是，只有我们在使用嵌套函数的时候闭包的功能才能真正发挥出来。

1
2
3
4
5
6
7
8
9
10

 1 var number = 1;
 2 function sum1() {
 3     var number = 4;        //覆盖了上面的number
 4     
 5     function sum2() {
 6         console.log("这个数字为：" + number);        //sum2()函数和其中的语法形成了一个闭包，引用的sum1()中局部声明的number变量。
 7     }
 8     return sum2();
 9 }
10 sum1();        //这个数字为：4

这部分内容主要介绍了JavaScript中基本数据类型、数组的基础知识、循环的常规应用以及表达式。

变量

1.什么是变量？

变量是用来存储数据的，是存放具体数值的容器。

2.变量的命名规范

变量名可以由字母、数字、下划线及美元符号组成，但是不能以数字开头。

3.变量的使用

• 先声明变量后初始化变量。
• 可以声明变量同时并初始化变量。

注意：变量名是区分大小写的。

操作符

1.什么是变量？

变量是用来存储数据的，是存放具体数值的容器。

2.基本的算术运算符

变量是用来存储数据的，是存放具体数值的容器。

3.复合操作运算符

操作符

JavaScript中包含以下几大基本数据类型：

数字型——包括整数和浮点数，例如：1、1.1、3.14。
字符串型——包括由任意字符组成的序列，例如：“a”、“one 2 two”。
布尔型——只有两种形式，true和false。
undefined——没有值的变量，当我们去访问这种并不存在的变量时，会得到这个特殊值undefined。
null——表示没有值或空值。在JavaScript中，null的数据类型是对象。

1.typeof操作符

使用typeof我们能够知道返回某个变量或值的类型是什么，该操作符的返回结果可能是：

1
2
3
4
5
6
7
8

1 console.log(typeof null);           //Object
2 console.log(typeof 10);             //number
3 console.log(typeof "a");            //string
4 console.log(typeof '10');           //string
5 console.log(typeof true);           //boolean
6 console.log(typeof function(){});   //function
7 console.log(typeof a);              //undefined
8 console.log(typeof undefined);      //undefined

所以在JavaScript中使用typeof操作符返回的结果是：

• “number”;
• “string”;
• “boolean”;
• “undefined”;
• “object”;
• “function”

注意：

当八进制和十六进制的数字使用typeof操作符时返回的结果是number类型。

1
2

1 console.log(typeof 0377);   //八进制返回"number"
2 console.log(typeof 0xff);   //十六进制返回"number"

当使用指数去表示的时候返回的是number类型

1
2
3

1 //2e1和2e+1是指数的两种表示方法
2 console.log(typeof 2e1);    //number
3 console.log(typeof 2e+1);    //number

使用typeof操作符返回Infinity和-Infinity的结果也是number

1
2

1 console.log(typeof Infinity);    //number
2 console.log(typeof -Infinity);    //number

使用typeof操作符返回NaN的结果也是number

1

1 console.log(typeof NaN);

2.数字型

1.Infinity

在JavaScript中，超出处理范围的数值用Infinity这个特殊值来表示。例如当我们向控制台输出1e308时，返回结果正常，而向控制台再输出1e309的时候就超出范围了，所以会返回Infinity，其中如果超出最大值就是返回Infinity，如果超出最小值就返回-infinity。

1
2
3

1 console.log(1e308);        //1e+308
2 console.log(1e309);        //Infinity
3 console.log(-1e309);    //-Infinity

Infinity和-Infinity相加得到的不是0而是NaN，Infinity-Infinity得到的也是NaN而并非0,实际上二者都一样。

1
2

1 console.log(-Infinity + Infinity);    //NaN
2 console.log(Infinity - Infinity);    //NaN

Infinity和数字执行除了取模以外的运算得到的结果都是Infinity，取模运算得到的是NaN。

1
2
3
4
5

1 console.log(Infinity + 10);        //Infinity
2 console.log(Infinity - 10);        //Infinity
3 console.log(Infinity * 10);        //Infinity
4 console.log(Infinity / 10);        //Infinity
5 console.log(Infinity % 10);        //NaN

2.NaN

虽然NaN代表的是不是数字，但是正如我们在上面typeof中使用typeof操作符的时候一样，返回的值的类型也是数字类型，所以NaN是一种特殊的数字。

注意：

• 如果我们计算1 + “a”得到的结果是1a这个拼接后的字符串，但是如果我们使用的是其它的几个算术运算符的话返回的结果是NaN，因为这是错误的运算方式，返回的结果不会是一个数字。
• 如果我们在算术运算中将NaN算进去的话，整个运算得到的结果也是NaN。

1
2
3
4
5
6

1 console.log(1 + "a");            //1a
2 console.log(1 - "a");            //NaN
3 console.log(1 * "a");            //NaN
4 console.log(1 / "a");            //NaN
5 console.log(1 % "a");            //NaN
6 console.log(1 + 2 + NaN + 3);    //NaN

3.字符串型

字符串通常表示的是某段表示文本的字符序列。和某些语言不同的是，JavaScript语言中一对单引号或双引号之间的任何值都是一个字符串，有些编程语言单引号只能是表示字符，双引号表示字符串。所以在JavaScript中，’1’和”1”表示的都是字符串。字符串使用typeof操作符会返回string这个结果。

1.字符串的表示

• 在JavaScript中字符串可以用单引号表示也可以用双引号表示。
• 字符串可以是引号中的零个或多个字符。
• 字符串可以是带单引号或双引号的任何值。
• 字符串之间可以使用加号运算符进行拼接，拼接后得到的新的字符串依然是字符串类型。

2.字符串类型和其它类型之间的相互转换

布尔型转字符串型
通过a布尔类型与字符串使用加号运算符拼接将a由布尔类型转换为字符串类型。

1
2
3
4
5

1 var a = true;
2 var b = "";
3 var c = a + b;
4 console.log(c);            //true
5 console.log(typeof c);    //string

字符串型转数字型
通过字符串类型和数字类型使用乘号运算符拼接得到的是数字类型。

1
2
3
4
5

1 var a = "";
2 var b = 1;
3 var c = a * b;
4 console.log(c);            //1
5 console.log(typeof c);    //number

通过Number()方法返回数字，将字符串类型值转换为数字类型值。

1
2
3

1 var a = Number("2021") + 1;
2 console.log(a);            //2022
3 console.log(typeof a);    //number

通过parseInt()方法解析一段字符串并返回数值。

1
2
3

1 var a = parseInt("5a7b6");
2 console.log(a);            //5
3 console.log(typeof a);    //number

注意：parseInt()方法允许空格且只返回首个数字，上面的示例开头数字是5，所以最后返回的数值结果就是5。

1
2
3

1 var a = parseInt("1024");
2 console.log(a);            //1024
3 console.log(typeof a);    //number

所以说如果parseInt()方法中解析的字符串首字母不是数字的话返回的值就是NaN。

1
2
3

1 var a = parseInt("3.14");
2 console.log(a);            //3
3 console.log(typeof a);    //number

通过parseFloat()方法解析一段字符串并返回数值。

1
2
3

1 var a = parseFloat("3.14a");
2 console.log(a);            //3.14
3 console.log(typeof a);    //number

注意：parseFloat()方法允许空格且只返回首个数字，上面的示例开头数字是3.14，所以最后返回的数值结果就是3.14。

1
2
3

1 var a = parseFloat("3.14");
2 console.log(a);            //3.14
3 console.log(typeof a);    //number

所以说如果parseFloat()方法中解析的字符串首字母不是数字的话返回的值就是NaN。

1
2
3

1 var a = parseFloat("ab12c");
2 console.log(a);            //NaN
3 console.log(typeof a);    //number

数字型转字符串型
通过字符串类型和数字类型进行拼接将数字类型的值转换为字符串类型值。

1
2
3
4
5

1 var a = '';
2 var b = 1;
3 var c = a + b;
4 console.log(c);            //1
5 console.log(typeof c);    //string

3.字符串拼接

字符串与字符串拼接得到的结果还是字符串类型。

1
2
3
4
5

1 var a = 'java';
2 var b = "script";
3 var c = a + b;
4 console.log(c);                //javascript
5 console.log(typeof c);        //string

4.常用特殊字符串

4.布尔型

布尔类型只有true和false两种值，一般作为判断语句去使用。

布尔类型在使用typeof操作符的时候返回的值类型是boolean类型。

在JavaScript中有三种布尔运算的运算符，分别是：

• !——逻辑非（取反）；
• &&——逻辑与；
• ||——逻辑或；

其中，逻辑非代表事物不是真的状态，逻辑与是代表当前事物和操作中所有的一切都是真最终结果才为真，只要有一个不满足就为假，即使是另外的条件满足。逻辑或则是多个条件中其中一个条件满足就为真，只有都为假的时候才能为假。

以下表列出相应情况

注意：在或、与、非三个布尔运算符之中优先级为!（非）>&&（或）>||（与）。
当然，在JavaScript中，还有另一组以布尔值为返回值类型的操作符，我们称之为比较运算符。

注意：NaN不等于任何东西，哪怕是自己，例如NaN == NaN;返回值也为false。

数组

1.什么是数组？

数组是一个用于存储数据的列表，这个列表可以存放任意数量的元素值。
示例：

1
2

1 var a = [1,2,3];
2 console.log(a);        //[1,2,3]

记住，元素在数组中的索引位置下标是从0开始的，所以数组元素的首个索引值是0，第二个元素索引值是1，以此类推。

1
2
3
4

1 var a = [1,2,3];
2 console.log(a[0]);        //1
3 console.log(a[1]);        //2
4 console.log(a[2]);        //3

2.数组的特点

• 数组是一种数据存储形式。
• 数组是可以被索引的。
• 数组中的元素索引值是从0开始，按照每个元素的位置去依次递增。
• 数组能存储任何类型的数据，包括另一个数组。
• 我们可以对数组进行增删改查。
• 我们可以通过数组访问的方式去获取字符串中特定位置上的字符。

3.关于数组元素的增加和更新

我们可以通过索引去直接增加或者更新数组中的元素，例如：

1
2
3
4
5

1 var a = [1,2,3];
2 a[1] = "two";        //修改元素索引值为1的数
3 a[3] = "four";        //增加元素索引值为3的地方
4 a[5] = "six";        //增加元素索引值为6的地方，索引值为5的地方在控制台上输出的时候是空值
5 console.log(a);        //[1, "two", 3, "four", empty, "six"]

4.关于数组元素的删除

删除数组中特定的元素我们需要使用delete操作符去实现操作。

1
2
3

1 var a = [1,2,3];
2 delete a[1];
3 console.log(a);        // [1, empty, 3]

5.利用数组访问字符串

我们可以通过数组访问的方式去获取字符串中特定位置上的字符。

1
2
3
4

1 var a = 'abc';
2 console.log(a[0]);        //a
3 console.log(a[1]);        //b
4 console.log(a[2]);        //c

条件与循环

条件与循环是实际开发过程中重要的一部分，通过使用条件我们可以控制一段代码的执行走向，通过循环我们可以重复去执行某段代码。

1.if条件表达式

if条件表达式主要由if语句、语句条件、执行的代码块以及代码块内部的执行语句组成。其中语句条件是指逻辑类或者是比较类并返回布尔值类型的操作语句组成。

2.else语句

else语句是if语句的可选项，运用于if语句表达式条件返回值为false的时候去执行该部分所包含的语句。

举个栗子：

1
2
3
4
5
6

1 var a = 2;
2 if(a > 2) {
3     console.log("a是一个大于2的数字");
4 } else {
5     console.log("a不是大于2的数字");
6 }

此外我们还有else if语句，也是if语句的可选项，是分支判断语句，例如：

1
2
3
4
5
6
7
8

1 var a = 2;
2 if(a == 1) {
3     console.log("a = 1");
4 } else if(a == 2) {
5     console.log("a = 2");
6 } else {
7     console.log("a不满足上述条件");
8 }

3.switch语句

当if语句中出现过多的else if语句的时候，最好使用switch语句进行条件的判断。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 1 var a = 1;
 2 var result = '';
 3 switch(a) {
 4     case 1:
 5         result = 'Number 1';
 6         break;
 7     case 2:
 8         result = 'Number 2';
 9         break;
10     default:
11         result = 'Number X';
12         break;
13 }
14 console.log(result);
15 //输出结果：Number 1

switch语句的组成部分及其作用

• switch子句。
• 括号表达式。表达式通常是一个变量，有时候也可以是其它能够提供返回值的东西。
• 包含在switch语句大括号中的case序列块。
• 每个case语句下的表达式，如果表达式结果与switch语句表达式对比结果为true则case语句冒号之后的代码会被执行。
• break语句是可选的，当代码执行到break语句时，就跳出当前循环结束整个过程的执行。
• default关键字是默认条件代码块，当case条件的语句都不为true的时候，就执行default条件里的语句。

4.循环

通过循环语句我们可以使某段代码可以反复执行，便于操作。

在JavaScript中，循环分为四种类型：

• while循环；
• do-while循环；
• for循环；
• for-in循环。

1.while循环

while循环语句分为小括号中的条件和大括号中的代码块,当小括号中的条件为true的时候会执行。

1
2
3
4
5

1 var a = 0;
2 while(a < 10) {
3     a++;
4 }
5 console.log(a);

2.do-while循环

do-while循环和while循环没有多大的区别，只不过是do-while循环里的代码块会至少执行一次，先执行，后判断。

1
2
3
4
5

1 var a = 0;
2 do {
3     a++;
4 } while(a < 10);
5 console.log(a);

3.for循环

for循环主要包括以下内容：

• 初始化部分定义一个循环变量，例如var i = 0;
• 条件部分将i与循环边界值进行对比。例如i < 10;
• 自增部分将循环变量i自增1，例如i++。

举个栗子：

1
2
3
4
5

1 var a = '';
2 for(var i = 0;i < 10;i++) {
3     a = 'Hello World';
4 }
5 console.log("输出" + a);

可以这样去表示：

1
2
3
4

1 for(var i = 0,a = '';i < 10;i++) {
2     a = 'Hello World';
3 }
4 console.log("输出" + a);

不过这样写的话可读性会变得很差，所以并不建议这样写。
for循环彼此之间可以进行嵌套。

1
2
3
4
5

1 for(var i = 0;i < 10;i++) {
2     for(var j = 0;j < 10;j++) {
3         
4     }
5 }

4.for-in循环

for-in循环往往被用来遍历某个数组中的元素。

示例：

1
2
3
4
5
6

1 var a = ['a','b','c','d','e'];
2 var result = '\n';
3 for(var i in a) {
4     result = 'index:' + i +',value:' + a[i] + '\n';
5     console.log(result);
6 }

总结

这部分内容主要介绍了JavaScript中的基本数据类型、数组、循环以及条件表达式的常规应用，尤其在数组方面并没有介绍全面，在后面的学习中再学到更多的应用时再做补充。

JavaScript是一门面向对象的解释型脚本语言，通过利用面向对象的这种特性，实现了代码重用，并构建起了可伸缩的代码框架。作为JavaScript的初学者，因为面向对象是JavaScript的核心部分，所以在开始就略微的去学习了JavaScript的面向对象的基础概念部分，能够对于JavaScript的面向对象积累一些初始概念，并将自己对这些的感悟分享出来与大家交流。 作为初学者，可能有些地方理解不够正确，希望大家能提出自己的见解，欢迎批评指正。

面向对象程序设计最常用到的概念

面向对象程序设计最常用到的概念如下：

• 对象、方法、属性；
• 类；
• 封装；
• 聚合;
• 重用与继承；
• 多态。

1.对象

JavaScript是面向对象的解释型脚本语言，所以面向对象是该编程语言的核心所在。那么什么是对象？对象我们有时候也叫“实例”，实际上就是指事物在程序语言中的表现形式，这类事物可以是人也可以是物，可以是客观存在的具体化对象，也可以是抽象的概念对象。这类事物往往具有其特定的称呼和特征，以及行为等。

例如：有一只黑色的猫在床上睡觉。其中，猫代表的是对象，黑色是颜色，代表属性，睡觉是一种动作行为，代表方法，在床上是睡觉的限定条件，限定动作的条件，也可以看做是传递给睡觉这个方法的参数。

2.类

我们知道在现实生活中，相似对象之间往往具有一些共同的组成特征。比如阿拉斯加犬和哈士奇都属于狗类并具有狗类的特征，因此它们属于同一个类。所以类实际上就是一群具有相同特征的对象并同属一个类组成的集合。阿拉斯加犬是一个实例化对象，哈士奇是一个实例化对象，它们都是由同一个类创造出来的，而这个类还可以创造出其它具有相同特征的实例化对象，所以类也可以当做是一种模板，对象就是在模板上创建出来的实体。

当然，JavaScript并不存在类这一说法，它的一切都是基于对象，依靠着一套原型系统。在传统的面向对象语言中我们可以这样描述：我基于Cat类创建了一个叫做BlackCat的对象，而在基于原型的面向对象的语言中则是这样说道：我将现有的Cat对象扩展成一个叫做BlackCat的对象。

3.封装

封装是用来封装对象中的内容，因此封装实际上就是去阐述对象中包含的内容。这些内容可以是属性，也可以是方法。

例如：一部手机是一个对象，手机里的处理器、电池、电路板等部件就是属性，我们作为用户通常通过手机的按钮、显示屏一类的接口去使用对应的方法，这等价于OOP(面向对象的程序设计)中的调用方法。但是这些接口的实现过程和手机所具有的属性等都是不可见的，我们并不清楚它们内部是如何工作的，只需要通过接口去使用功能即可。在编译类型的语言中我们也是直接去调用方法实现相应的功能即可，而不是去关心它的实现过程。

能够达到以上事例中的内容的封闭性就是封装。而封装的意义就是方便用户操作，优化用户体验。

在某些编程语言中我们可以使用public、private、project、default这些关键字来限定方法和属性的可见性，通过限定分类定义了用户所能访问的层次。但是在JavaScript中，所有的方法和属性都是public，话是这样说，其实JavaScript中也是提供了一些隐藏数据的方法来保护程序的隐私性。

4.聚合

聚合也被称为组合，就是将几个现有对象合并为一个新对象的过程。这个过程实际上是一种思想，在实际解决问题的过程中我们可以采用这种思想将一个问题分解成多个小的问题，这些多个小的问题相对而言更加容易思考，提高解决问题的效率。

例如：在图书管理系统中我们要找《JavaScript高级程序设计》这本书，假若我们不使用检索功能去直接搜寻书，从一个系统包含的成千上万本书中去查找一本书也是一个很费劲的工作。因此我们可以将图书管理系统的功能模块细化，分门别类并有选择有目的的去寻找。《JavaScript高级程序设计》是一本关于前端的书籍，而前端书籍是属于技术类书籍，前端技术类书籍是包含在IT互联网类型中，而IT互联网类型可以在整个管理系统的图书分类中找到，而图书分类这个模块是在进入图书管理系统后比较显眼的功能分类中可以找到。通过将寻找这本书的流程分化成一个个的具体模块的过程再去逐一解决这个问题就是聚合。

注意：以上事例要想实现是需要图书管理系统对于图书的分类比较明确而不是单单的将一堆图书直接聚集在一起，所以可以看出并不是在所有复杂情况下都可以使用聚合去解决问题，但是使用聚合可以解决大多数问题。

如果以上的示例还是令人感到迷惑的话我们再举一个例子。

例如：一个Web开发团队由许多人员组成，这是一个比较复杂的集体，我们如何才能清晰的知道这个集体中包含哪些人，每个人在做什么工作呢？我们需要将这个团队中包含的岗位罗列出来并将我们的对象，也就是开发人员和产品经理一一对应在相应的岗位，其中每一个开发人员或产品经理只是这个Web开发团队对象的一部分，这样划分下来我们就可以解决了这些问题。

总的来说聚合在开发过程中的作用是将分开编辑的代码聚合在一起方便调用。

5.继承

继承是实际开发过程一种比较便捷的方式，通过继承这种方式可以实现代码的重复利用。

例如：人这个对象的名称我们可以将其命名为Person，这个对象中应该包含姓名、年龄、出生日期等属性以及走路、跑步、谈话、吃饭、睡觉等方法。这时候我们想要编写一个Student对象，这个对象拥有和Person对象一样的特征，因此我们可以直接继承Person对象，这样我们只需要通过去重用Person对象去编写Student对象的实现代码部分即可。接着我们还想编写一个Teacher对象依然可以这样做。

通过以上示例就可以实现了代码的复用避免了不停地重写相同的方法和属性，做到高效利用。

在传统的面向对象的程序设计中，继承通常都是指类与类之间的关系，但是JavaScript中并不存在类这样的说法，所以它的继承是发生在对象与对象之间。

当一个对象继承另一个对象的时候，可能会继承的基础上在里面加入新的方法，这个过程被称为“继承对象扩展自被继承对象”或者“继承对象继承自被继承对象”。比如A对象继承B对象，那么就是“A扩展自B”或“A继承自B”。此外我们也可以重新定义被继承的对象中的方法，被重新定义后的方法只是改变了当前继承在该对象中的方法，并不会真正改变被继承对象中的方法，而这种重新定义继承过来的方法的过程叫做方法的覆写。

6.多态

还是上面的例子，Student对象继承了Person对象中所有的方法，Teacher对象也继承了Person对象中所有的方法，拿方法中的跑步举例，跑步是“run”方法，这时候代码中有一个叫做Jack的变量，我们并不知道Jack是属于Person对象还是属于Student对象还是属于Teachar，在这种情况下我们还是可以去调用对象的“run”方法，实现跑步这一方法，形如这种通过相同的方法调用来实现各自行为的能力的就是多态。如果再通俗来讲，就是同一个操作作用在不同的对象上产生不同的解释或者是不同的结果就是多态。

举个栗子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 1 function Person() {}
 2 Person.prototype.age = function(age) {
 3     return age;
 4 }
 5 
 6 function Student() {}
 7 Object.setPrototypeOf(Student.prototype,Person.prototype);
 8 
 9 function Teacher() {}
10 Object.setPrototypeOf(Teacher.prototype,Person.prototype);
11 
12 var stu = new Student();
13 console.log(stu.age(18));
14 
15 var tea = new Teacher();
16 console.log(tea.age(28));

即使后面再加上一个Master对象，依然可以继续调用，不影响其它代码的调用实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

 1 function Person() {}
 2 Person.prototype.age = function(age) {
 3     return age;
 4 }
 5 
 6 function Student() {}
 7 Object.setPrototypeOf(Student.prototype,Person.prototype);
 8 
 9 function Teacher() {}
10 Object.setPrototypeOf(Teacher.prototype,Person.prototype);
11 
12 function Master() {}
13 Object.setPrototypeOf(Master.prototype,Person.prototype);
14 
15 let stu = new Student();
16 console.log(stu.age(18));
17 
18 let tea = new Teacher();
19 console.log(tea.age(28));
20 
21 let mas = new Master();
22 console.log(mas.age(38));