一种脚本封装方法和装置以及脚本运行方法和装置与流程

本发明涉及计算机技术领域，特别涉及一种脚本封装方法和装置以及脚本运行方法和装置。

背景技术：

随着浏览器技术的发展，JavaScript解析速度得到大幅提升，基于JavaScript技术开发的脚本越来越流行。在实际应用场景中，随着脚本中代码量的增加，脚本封装对于脚本运行至关重要。

现有技术中，在脚本封装中，脚本中的代码以类的形式存在。例如，脚本M以3个类的形式进行封装。

但是，当脚本的代码量较高时，一般需要通过多个类的形式进行封装，各个类之间存在耦合，导致脚本结构不清晰。

技术实现要素：

本发明实施例提供了一种脚本封装方法和装置以及脚本运行方法和装置，能够使脚本结构更加清晰。

第一方面，本发明实施例提供了一种脚本封装方法，包括：

接收外部发送的至少一个模块参数，每一个所述模块参数中包括：模块的名称、至少一个所述模块所依赖的模块的名称；

针对每一个所述模块参数，根据当前模块参数，创建当前模块对象，所述当前模块对象中包括：所述当前模块对象的名称、至少一个所述当前模块对象所依赖的模块对象的名称；

在每一个所述模块对象中，定义至少一个类；

根据至少一个所述模块对象和每一个所述模块对象中所述至少一个类，生成目标脚本。

优选地，

所述在每一个所述模块对象中，定义至少一个类，包括：

在目标模块对象中，接收外部发送的针对所述目标模块对象的至少一个目标类参数，每一个所述目标类参数中包括：目标基类、目标类的名称、所述目标类的继承关系和所述目标类的依赖关系；

针对每一个所述目标类参数，根据当前目标类参数中的所述目标基类、所述目标类的名称、所述目标类的继承关系和所述目标类的依赖关系，在所述目标模块对象中，定义当前目标类。

第二方面，本发明实施例提供了一种脚本封装装置，包括：

模块定义接口，用于接收外部发送的至少一个模块参数，每一个所述模块参数中包括：模块的名称、至少一个所述模块所依赖的模块的名称；针对每一个所述模块参数，根据当前模块参数，创建当前模块对象，所述当前模块对象中包括：所述当前模块对象的名称、至少一个所述当前模块对象所依赖的模块对象的名称；

类定义接口，用于在所述模块定义接口创建的每一个所述模块对象中，定义至少一个类；

生成接口，用于根据所述模块定义接口创建的所述至少一个模块对象和每一个所述模块对象中所述类定义接口定义的所述至少一个类，生成目标脚本。

优选地，

所述类定义接口，用于在目标模块对象中，接收外部发送的针对所述目标模块对象的至少一个目标类参数，每一个所述目标类参数中包括：目标基类、目标类的名称、所述目标类的继承关系、所述目标类的依赖关系；针对每一个所述目标类参数，根据当前目标类参数中的所述目标基类、所述目标类的名称和所述目标类的继承关系和所述目标类的依赖关系，在所述目标模块对象中，定义当前目标类。

第三方面，本发明实施例提供了一种脚本运行方法，预先创建至少一个模块对象，每一个所述模块对象中包括：当前模块对象的名称、至少一个所述当前模块对象所依赖的模块对象的名称；预先在每一个所述模块对象中，定义至少一个类；根据所述至少一个模块对象和每一个所述模块对象中所述至少一个类，生成目标脚本，还包括：

接收外部发送的针对所述目标脚本的目标模块对象的名称；

根据所述目标模块对象的名称，在所述至少一个模块对象中确定所述目标模块对象；

根据所述目标模块对象和至少一个所述目标模块对象所依赖的模块对象的名称，确定待处理的模块对象；

对每一个所述待处理的模块对象中的每一个类进行实例化。

优选地，

所述根据所述目标模块对象和至少一个所述目标模块对象所依赖的模块对象的名称，确定待处理的模块对象，包括：

S1：建立模块加载栈；

S2：将所述目标模块对象作为当前待处理的模块对象；

S3：将所述当前待处理的模块对象添加到所述模块加载栈，将所述模块加载栈中的模块对象作为待处理的模块对象；

S4：确定所述当前待处理的模块对象所依赖的模块对象的名称；

S5：根据所述当前待处理的模块对象所依赖的模块对象的名称，判断所述当前待处理的模块对象所依赖的模块对象是否均在所述模块加载栈中，如果是，则结束当前流程，否则，执行S6；

S6：将所述当前待处理的模块对象所依赖的模块对象中不在所述模块加载栈中的模块对象作为所述当前待处理的模块对象，返回S3。

优选地，

所述对每一个所述待处理的模块对象中的每一个类进行实例化，包括：

从所述模块加载栈的栈顶开始，依次对每一个所述待处理的模块对象中的每一个类进行实例化。

第四方面，本发明实施例提供了一种脚本运行装置，包括：模块定义接口、类定义接口、生成接口和应用程序启动接口；

所述模块定义接口，用于创建至少一个模块对象，每一个所述模块对象中包括：当前模块对象的名称、至少一个所述当前模块对象所依赖的模块对象的名称；

所述类定义接口，用于在所述模块定义接口创建的每一个所述模块对象中，定义至少一个类；

所述生成接口，用于根据所述模块定义接口创建的所述至少一个模块对象和每一个所述模块对象中所述类定义接口定义的所述至少一个类，生成目标脚本；

所述应用程序启动接口，包括：

接收单元，用于接收外部发送的针对所述生成接口生成的所述目标脚本的目标模块对象的名称；

确定单元，用于根据所述接收单元接收的所述目标模块对象的名称，在所述至少一个模块对象中确定所述目标模块对象；

处理单元，用于根据所述确定单元确定的所述目标模块对象和至少一个所述目标模块对象所依赖的模块对象的名称，确定待处理的模块对象；

实例化单元，用于对所述处理单元确定的每一个所述待处理的模块对象中的每一个类进行实例化。

优选地，

所述处理单元，包括：

建立子单元，用于建立模块加载栈；

执行子单元，用于将所述目标模块对象作为当前待处理的模块对象；

添加子单元，用于将所述执行子单元确定的所述当前待处理的模块对象添加到所述建立子单元建立的所述模块加载栈，将所述模块加载栈中的模块对象作为待处理的模块对象；

确定子单元，用于确定所述添加子单元中所述当前待处理的模块对象所依赖的模块对象的名称；

判断子单元，用于根据所述确定子单元确定的所述当前待处理的模块对象所依赖的模块对象的名称，判断所述当前待处理的模块对象所依赖的模块对象是否均在所述模块加载栈中，如果是，则结束当前流程，否则，触发处理子单元；

所述处理子单元，用于将所述当前待处理的模块对象所依赖的模块对象中不在所述模块加载栈中的模块对象作为所述当前待处理的模块对象，触发所述添加子单元。

优选地，

所述实例化单元，用于从所述模块加载栈的栈顶开始，依次对每一个所述待处理的模块对象中的每一个类进行实例化。

第五方面，本发明实施例提供了一种可读介质，包括执行指令，当存储控制器的处理器执行所述执行指令时，所述存储控制器执行上述任一项所述的方法。

第六方面，本发明实施例提供了一种存储控制器，包括：处理器、存储器和总线；所述存储器用于存储执行指令，所述处理器与所述存储器通过所述总线连接，当所述存储控制器运行时，所述处理器执行所述存储器存储的所述执行指令，以使所述存储控制器执行上述任一项所述的方法。

本发明实施例提供了一种脚本封装方法和装置以及脚本运行方法和装置，其中，在脚本封装方法中，根据外部发送的至少一个模块参数，创建至少一个模块对象，并在每一个模块对象中，定义至少一个类。该方法对脚本进行模块化封装，形成目标脚本。当脚本的代码量较高时，可以通过创建模块对象对脚本进行封装，减少各个类之间存在的耦合，使脚本结构更加清晰。

附图说明

为了更清楚地说明本发明实施例或现有技术中的技术方案，下面将对实施例或现有技术描述中所需要使用的附图作简单地介绍，显而易见地，下面描述中的附图是本发明的一些实施例，对于本领域普通技术人员来讲，在不付出创造性劳动的前提下，还可以根据这些附图获得其他的附图。

图1是本发明一个实施例提供的一种脚本封装方法流程图；

图2是本发明一个实施例提供的一种脚本封装装置结构示意图；

图3是本发明一个实施例提供的一种脚本运行方法流程图；

图4是本发明一个实施例提供的一种脚本运行装置结构示意图；

图5是本发明一个实施例提供的另一种脚本运行方法流程图。

具体实施方式

为使本发明实施例的目的、技术方案和优点更加清楚，下面将结合本发明实施例中的附图，对本发明实施例中的技术方案进行清楚、完整地描述，显然，所描述的实施例是本发明一部分实施例，而不是全部的实施例，基于本发明中的实施例，本领域普通技术人员在没有做出创造性劳动的前提下所获得的所有其他实施例，都属于本发明保护的范围。

如图1所示，本发明实施例提供了一种脚本封装方法，该方法可以包括以下步骤：

步骤101：接收外部发送的至少一个模块参数，每一个模块参数中包括：模块的名称、至少一个模块所依赖的模块的名称；

步骤102：针对每一个模块参数，根据当前模块参数，创建当前模块对象，当前模块对象中包括：当前模块对象的名称、至少一个当前模块对象所依赖的模块对象的名称；

步骤103：在每一个模块对象中，定义至少一个类；

步骤104：根据至少一个模块对象和每一个模块对象中至少一个类，生成目标脚本。

在图1所示的实施例中，该方法根据外部发送的至少一个模块参数，创建至少一个模块对象，并在每一个模块对象中，定义至少一个类。该方法对脚本进行模块化封装，形成目标脚本。当脚本的代码量较高时，可以通过创建模块对象对脚本进行封装，减少各个类之间存在的耦合，使脚本结构更加清晰。

在本发明的一个实施例中，为了使模块对象执行相应的功能，需要在每一个模块对象中，定义不同的类，步骤103包括：在目标模块对象中，接收外部发送的针对目标模块对象的至少一个目标类参数，每一个目标类参数中包括：目标基类、目标类的名称、目标类的继承关系、目标类的依赖关系；针对每一个目标类参数，根据当前目标类参数中的目标基类、目标类的名称、目标类的继承关系和目标类的依赖关系，在目标模块对象中，定义当前目标类。

在模块对象中，如果缺省基类参数，则新定义的类从基类派生。在本实施例中，JavaScript使用原型链的方式实现类继承，当子类与原型链上的父对象存在同名方法时，原型链上的父对象的方法将被屏蔽，通过此方法名访问的是子类上的方法。本发明实现了一套在子类方法中访问原型链上父对象同名方法的机制。

该机制原理如下：

(1)在接收到类原型对象后，对原型对象上的每一个方法进行包装，并创建一个新对象，在新对象上创建原型对象同名的方法，此方法在内存中指向包装后的原型对象方法。新创建的对象作为类原型继承的原型对象。

(2)对原型对象方法的包装采用闭包原理，通过闭包在内存中保持原型链上父对象方法的引用，从而达到访问原型链父对象方法的目的。

以下是该机制的伪代码：

通过上面的包装，可以在自己方法中通过“this.当前父方法”访问原型链父对象上的同名方法。

如图2所示，本发明实施例提供了一种脚本封装装置，包括：

模块定义接口201，用于接收外部发送的至少一个模块参数，每一个模块参数中包括：模块的名称、至少一个模块所依赖的模块的名称；针对每一个模块参数，根据当前模块参数，创建当前模块对象，当前模块对象中包括：当前模块对象的名称、至少一个当前模块对象所依赖的模块对象的名称；

类定义接口202，用于在模块定义接口201创建的每一个模块对象中，定义至少一个类；

生成接口203，用于根据模块定义接口201创建的至少一个模块对象和每一个模块对象中类定义接口202定义的至少一个类，生成目标脚本。

在本发明的一个实施例中，类定义接口202，用于在目标模块对象中，接收外部发送的针对目标模块对象的至少一个目标类参数，每一个目标类参数中包括：目标基类、目标类的名称、目标类的继承关系、目标类的依赖关系；针对每一个目标类参数，根据当前目标类参数中的目标基类、目标类的名称、目标类的继承关系和目标类的依赖关系，在目标模块对象中，定义当前目标类。

在本实施例中，表1所示的是模块定义接口的描述，

表1：

在本实施例中，表2所示的是类定义接口的描述，

表2：

如图3所示，本发明实施例提供了一种脚本运行方法，该方法包括以下步骤：

步骤301：创建至少一个模块对象，每一个模块对象中包括：当前模块对象的名称、至少一个当前模块对象所依赖的模块对象的名称；

步骤302：在每一个模块对象中，定义至少一个类；

步骤303：根据至少一个模块对象和每一个模块对象中至少一个类，生成目标脚本；

步骤304：接收外部发送的针对目标脚本的目标模块对象的名称；

步骤305：根据目标模块对象的名称，在至少一个模块对象中确定目标模块对象；

步骤306：根据目标模块对象和至少一个目标模块对象所依赖的模块对象的名称，确定待处理的模块对象；

步骤307：对每一个待处理的模块对象中的每一个类进行实例化。

在图3所示的实施例中，该脚本运行方法基于脚本的模块化封装，当目标脚本运行时，先根据目标模块对象的名称确定目标模块对象，再对目标模块对象中的每一个类进行加载并实例化。当需要实例化的类较多时，可以直接对这些类对应的模块对象进行操作，不需要对每一个类逐一进行操作。

在本发明的一个实施例中，为了对模块对象中的每一个类进行加载并实例化，步骤306包括：

S1：建立模块加载栈；

S2：将目标模块对象作为当前待处理的模块对象；

S3：将当前待处理的模块对象添加到模块加载栈，将模块加载栈中的模块对象作为待处理的模块对象；

S4：确定当前待处理的模块对象所依赖的模块对象的名称；

S5：根据当前待处理的模块对象所依赖的模块对象的名称，判断当前待处理的模块对象所依赖的模块对象是否均在模块加载栈中，如果是，则结束当前流程，否则，执行S6；

S6：将当前待处理的模块对象所依赖的模块对象中不在模块加载栈中的模块对象作为当前待处理的模块对象，返回S3。

在本实施例中，目标模块对象为脚本入口模块。模块对象按照先进后出的原则通过模块加载栈。

在本发明的一个实施例中，为了实现对模块对象中的每一个类的有序加载，步骤307包括：从模块加载栈的栈顶开始，依次对每一个待处理的模块对象中的每一个类进行实例化。

以下以手机费报销单向服务器端提交数据的场景为例，对脚本运行方法进行简单说明，在该场景中先定义了“报销”模块，在“报销”模块下定义了“手机费报销单”模型、数据提交服务，并演示了如何在“手机费报销单”模型中使用数据提交服务提交数据。

1、文件名：app.js

文件伪代码：

2、文件名：model.js

文件伪代码：

3、文件名：service.js

文件伪代码：

如图4所示，本发明实施例提供了一种脚本运行装置，包括：模块定义接口401、类定义接口402、生成接口403和应用程序启动接口404；

模块定义接口401，用于创建至少一个模块对象，每一个模块对象中包括：当前模块对象的名称、至少一个当前模块对象所依赖的模块对象的名称；根据至少一个模块对象和每一个模块对象中至少一个类，生成目标脚本；

类定义接口402，用于在模块定义接口401创建的每一个模块对象中，定义至少一个类；

生成接口403，用于根据模块定义接口401创建的至少一个模块对象和每一个模块对象中类定义接口402定义的至少一个类，生成目标脚本；

应用程序启动接口404，包括：

接收单元4041，用于接收外部发送的针对生成接口40 3生成的目标脚本的目标模块对象的名称；

确定单元4042，用于根据目标模块对象的名称，在至少一个模块对象中确定目标模块对象；

处理单元4043，用于根据确定单元4042确定的目标模块对象和至少一个目标模块对象所依赖的模块对象的名称，确定待处理的模块对象；

实例化单元4044，用于对处理单元4043确定的每一个待处理的模块对象中的每一个类进行实例化。

类定义接口用来加载应用程序需要使用的类，传递给应用程序接口的模块称为应用程序入口模块。本实施例以应用程序入口模块为根，以树型接口存储模块间依赖关系。依赖模块名称集合属性用来存储叶子节点。应用程序启动接口在实例化入口模块对象所包含的类时，将追溯模块对象的依赖关系，逐个加载依赖模块对象，并实例化模块对象内的类。

在本发明的一个实施例中，处理单元4043，包括：

建立子单元，用于建立模块加载栈；

执行子单元，用于将目标模块对象作为当前待处理的模块对象；

添加子单元，用于将执行子单元确定的当前待处理的模块对象添加到建立子单元建立的模块加载栈，将模块加载栈中的模块对象作为待处理的模块对象；

确定子单元，用于确定添加子单元中当前待处理的模块对象所依赖的模块对象的名称；

判断子单元，用于根据确定子单元确定的当前待处理的模块对象所依赖的模块对象的名称，判断当前待处理的模块对象所依赖的模块对象是否均在模块加载栈中，如果是，则结束当前流程，否则，触发处理子单元；

处理子单元，用于将当前待处理的模块对象所依赖的模块对象中不在模块加载栈中的模块对象作为当前待处理的模块对象，触发添加子单元。

在本发明的一个实施例中，实例化单元4044，用于从模块加载栈的栈顶开始，依次对每一个待处理的模块对象中的每一个类进行实例化。

如图5所示，本发明实施例以模块化封装目标脚本M为例，对目标脚本运行方法进行详细地说明，该方法包括以下步骤：

步骤501：脚本封装装置接收外部发送的至少一个模块参数，每一个模块参数中包括：模块的名称、至少一个模块所依赖的模块的名称。

在本实施例中，脚本封装装置接收外部发送的四个模块参数，每一个模块参数中包括：模块的名称、至少一个模块所依赖的模块的名称。例如，四个模块参数分别为(A，B、C)、(B，A、D)、(C，A)、(D，B)。

步骤502：脚本封装装置针对每一个模块参数，根据当前模块参数，创建当前模块对象，当前模块对象中包括：当前模块对象的名称、至少一个当前模块对象所依赖的模块对象的名称。

脚本封装装置根据四个模块参数，创建四个模块对象，A、B、C、D，每一个模块对象中包括：当前模块对象的名称、至少一个当前模块对象所依赖的模块对象的名称。例如，模块对象A中包括：模块对象的名称A、两个模块对象A所依赖的模块对象的名称B、C。

步骤503：在目标模块对象中，脚本封装装置接收外部发送的针对目标模块对象的至少一个目标类参数，每一个目标类参数中包括：目标基类、目标类的名称、目标类的继承关系和目标类的依赖关系。

接收外部发送的针对模块对象A、B、C、D的类参数，以模块对象A为例，接收外部发送的针对模块对象A的两个类参数，其中，一个类参数中包括：基类A1、类的名称B1、类B1继承于基类A1、类B1依赖于基类A1；另一个类参数中包括：基类A1、类的名称B2、类B2继承于基类A1、类B2依赖于基类A1。

步骤504：脚本封装装置针对每一个目标类参数，根据当前目标类参数中的目标基类、目标类的名称、目标类的继承关系和目标类的依赖关系，在目标模块对象中，定义当前目标类。

脚本封装装置根据步骤503中的类参数，为每一个模块对象定义至少一个类，以模块对象A为例，在模块对象A中定义两个类，类B1和类B2。按照此方法分别在模块对象B、C、D中定义类，这里不再赘述。

步骤505：脚本封装装置根据至少一个模块对象和每一个模块对象中至少一个类，生成目标脚本M。

脚本封装装置根据模块对象A、B、C、D和每一个模块对象中至少一个类，生成目标脚本M。

步骤506：脚本运行装置接收外部发送的针对目标脚本M的目标模块对象的名称，根据目标模块对象的名称，在至少一个模块对象中确定目标模块对象。

脚本运行装置接收外部发送的针对目标脚本M的目标模块对象的名称A，在模块对象A、B、C、D中确定目标模块对象A。

步骤507：脚本运行装置建立模块加载栈。

该加载栈用于加载模块对象。

步骤508：脚本运行装置将目标模块对象作为当前待处理的模块对象。

将目标模块对象A作为当前待处理的模块对象。

步骤509：脚本运行装置将当前待处理的模块对象添加到模块加载栈，将模块加载栈中的模块对象作为待处理的模块对象。

将当前待处理的模块对象A添加到模块加载栈，并将A作为待处理的模块对象。

步骤510：脚本运行装置确定当前待处理的模块对象所依赖的模块对象的名称。

确定当前待处理的模块对象A所依赖的模块对象的名称为B、C。

步骤511：脚本运行装置根据当前待处理的模块对象所依赖的模块对象的名称，判断当前待处理的模块对象所依赖的模块对象是否均在模块加载栈中，如果是，执行步骤512，否则，执行步骤513。

当前待处理的模块对象所依赖的模块对象B、C不在模块加载栈中，执行步骤513。需要说明的是，当步骤513需要依次将模块对象B、C作为当前待处理的模块对象进行处理时，相应的，应该分别进行本步骤的判断过程，在这里，执行步骤512只针对当前模块对象。例如，模块对象B作为当前待处理的模块对象执行本步骤，若判断结果为是，只终止模块对象B相应的流程，而不影响模块对象C作为当前待处理的模块对象执行本步骤。

步骤512：脚本运行装置结束当前流程。

步骤513：脚本运行装置将当前待处理的模块对象所依赖的模块对象中不在模块加载栈中的模块对象作为当前待处理的模块对象。

将模块对象B、C作为当前待处理的模块对象，返回步骤509。模块对象B、C的处理过程与模块对象A类似，这里不再赘述。最终，将模块对象A、B、C、D依次添加到模块加载栈。

步骤514：脚本运行装置从模块加载栈的栈顶开始，依次对每一个待处理的模块对象中的每一个类进行实例化。

从模块加载栈的栈顶开始，依次对模块对象A、B、C、D中的每一个类进行实例化。例如，对模块对象A中的类B1和类B2分别进行实例化。该模块加载栈遵循先进后出的原则。

综上，本发明各个实施例至少具有如下效果：

1、在本发明实施例中，在脚本封装过程中，根据外部发送的至少一个模块参数，创建至少一个模块对象，并在每一个模块对象中，定义至少一个类。该方法对脚本进行模块化封装，形成目标脚本。当脚本的代码量较高时，可以通过创建模块对象对脚本进行封装，减少各个类之间存在的耦合，使脚本结构更加清晰。

2、在本发明实施例中，脚本运行基于脚本的模块化封装，当目标脚本运行时，先根据目标模块对象的名称确定目标模块对象，再对目标模块对象中的每一个类进行加载并实例化。当需要实例化的类较多时，可以直接对这些类对应的模块对象进行操作，不需要对每一个类逐一进行操作。

3、在本发明实施例中，提供了一种模块对象中类的加载和实例化方法，通过建立模块加载栈，并根据当前待处理的模块对象所依赖的模块对象的名称，确定模块加载栈中的待处理的模块对象，按照先进后出的顺序使待处理的模块对象出栈，并对出栈的待处理的模块对象依次进行实例化。

上述装置内的各单元之间的信息交互、执行过程等内容，由于与本发明方法实施例基于同一构思，具体内容可参见本发明方法实施例中的叙述，此处不再赘述。

需要说明的是，在本文中，诸如第一和第二之类的关系术语仅仅用来将一个实体或者操作与另一个实体或操作区分开来，而不一定要求或者暗示这些实体或操作之间存在任何这种实际的关系或者顺序。而且，术语“包括”、“包含”或者其任何其他变体意在涵盖非排他性的包含，从而使得包括一系列要素的过程、方法、物品或者设备不仅包括那些要素，而且还包括没有明确列出的其他要素，或者是还包括为这种过程、方法、物品或者设备所固有的要素。在没有更多限制的情况下，由语句“包括一个〃·····”限定的要素，并不排除在包括所述要素的过程、方法、物品或者设备中还存在另外的相同因素。

本领域普通技术人员可以理解：实现上述方法实施例的全部或部分步骤可以通过程序指令相关的硬件来完成，前述的程序可以存储在计算机可读取的存储介质中，该程序在执行时，执行包括上述方法实施例的步骤；而前述的存储介质包括：ROM、RAM、磁碟或者光盘等各种可以存储程序代码的介质中。

最后需要说明的是：以上所述仅为本发明的较佳实施例，仅用于说明本发明的技术方案，并非用于限定本发明的保护范围。凡在本发明的精神和原则之内所做的任何修改、等同替换、改进等，均包含在本发明的保护范围内。