应用程序生命周期和开发模型- 使用软件包开发获得更灵活的版本

学习目标

完成本单元后,您将能够:

  • 确定包开发和变更集开发之间的主要区别。
  • 描述什么是软件包版本,以及它如何帮助您管理组织中的更改。
  • 总结一下为什么在使用软件包开发模型时不必手动跟踪安装程序更改。

本单元描述了Calvin和他的同事为何决定从变更集开发模型转向软件包开发的原因。其他团队可能会发现软件包开发的不同方面。当您通读本单元时,请考虑为团队做出哪些选择,以及包装开发的哪个方面最引人注目。通过阅读本模块末尾列出的模块来进行动手操作,以学习该过程并就最适合您的情况做出最明智的决定。

变更集的变更管理挑战

随着时间的推移,Zephyrus的每个版本及其生产组织的项目和贡献者数量都在不断增长。这对用户来说很棒。公司对ALM步骤的一致应用为增强请求提供了良好的周转时间,同时将中断降到最低。

但是,协调这些更改,尤其是来自多个团队的许多无关的更改,对于Calvin来说确实是头疼的事。这些发行版的大小和复杂性继续增加。他担心,鉴于很难在一个版本中汇总和测试所有项目的变更,因此Zephyrus员工所依赖的功能将无法使用。

Calvin每次发布中都会进行大量更改以进行协调和跟踪,因此Calvin意识到他宁愿花时间进行更改。他还认为,在Zephyrus定制Salesforce的团队如果花更少的时间与其他项目中的变更进行协调,可能会提高生产力。

一个容器还是多个容器?

在Salesforce Trailblazer社区上,Calvin要求其他成员提供有关如何在每个版本中管理这么多项目的建议。他们告诉他一个新的Salesforce开发模型,该模型为发布管理提供了更大的灵活性。这就是所谓的包开发。

在程序包开发中,您将不同的自定义项作为单独的程序包进行管理,而不是作为对组织所做的一项重大更改来管理。还记得在变更集开发中,如何将多个项目中的一组变更管理到一个容器中吗?当发布变得如此复杂以至于需要将组织作为多个容器进行管理时,就该转向软件包开发模型了。如果您的团队已经在其他平台上构建模块化发行工件,那么他们会在软件包开发中发现一些相似之处。

例如,Zephyrus的软件包可能包含以下任何自定义项。

  • 他们内部构建的自定义Force.com应用
  • Sales Cloud,Service Cloud等的扩展
  • AppExchange应用程序的扩展
  • 更新共享库和功能

当您在程序包开发模型中工作时,您将构建一个发布工件,可以独立于其他项目的工件进行测试和发布。您的团队将创建一个包含所有相关元数据的包,而不是相对于生产进行一系列更改。程序包中的元数据包括已更改和未更改的组件。

通过软件包组织元数据更新还可以帮助您更好地构建组织中元数据结构的思维模型。如果要将组织作为多个容器管理,则每个软件包都代表这些容器之一。

包版本是包的内容和相关元数据的固定快照。软件包版本使您可以管理每次发布或部署添加到软件包的一组特定更改时的区别。如果要对已部署的软件包引入元数据更改,请从当前软件包版本升级到较新的软件包版本。

加尔文被转向包装开发的潜在生产率提高所激怒。他向创建销售Salesforce定制的其他部门的首席执行官Ernesto,首席执行官和董事提出了要求。他专注于三个要点。

  • 创建清晰的审计线索,以了解组织元数据如何随时间变化
  • 通过腾出当前用于跟踪安装程序更改的时间来提高生产力
  • 获得更大的发布灵活性,因为每个软件包都可以独立于其他项目的软件包进行开发,测试和发布

您的真理之源是源中的元数据

在软件包开发中,真理的源头是软件包项目中的元数据。这样可以轻松集成到VCS,这可以帮助您的团队管理他们进行的项目更改。

在变更集开发中,真理的来源是环境中已经存在的元数据和变更集的最后构建的结合。单靠更改集无法呈现完整的画面,因为它仅包含更改的内容,例如差异。

告别手动跟踪设置更改

软件包开发中有一个称为“ scratch orgs”的开发环境。Scratch组织在大幅减少Calvin及其团队需要跟踪的每个版本的更改中扮演着关键角色。

临时组织是空组织(没有元数据或数据),可以根据需要轻松创建和处置。您可以将临时组织配置为具有不同功能和首选项的不同Salesforce版本。而且,您可以重新使用草稿组织定义文件并与其他团队成员共享,因为它是集成到VCS中的项目的一部分。这样,在所有人都有自己的开发环境时,所有人都可以在同一组织配置中工作要简单得多。

当使用草稿组织进行开发时,首先要在VCS中推送项目中的源,以将草稿组织与相同的元数据同步。如果您打算使用安装程序进行开发,则会自动跟踪您所做的更改。您可以下拉所做的修改,以将其包括在项目中,并使用VCS提交所有更改。

Calvin如何知道源跟踪中支持哪些组件?元数据覆盖率报告向您显示源跟踪,元数据API和其他元数据通道中是否支持元数据类型。该动态生成的报告是元数据覆盖信息的最佳来源。要访问“元数据覆盖率”报告,请访问https://developer.salesforce.com/docs/metadata-coverage。

每个包裹都有自己的比赛

在软件包开发中,您可以为每个软件包维护单独的发布计划。您使用包来分割组织元数据的所有权,因此每个项目都有其自己的包以及任何相关包。您可以通过每个后续软件包版本独立管理各个段的升级,从而可以维护单独的发布计划。

什么是包依赖关系?元数据组件一次只能位于一个包中。如果多个软件包需要相同的组件,则可以为该组件设计模块化的软件包策略。包含多个程序包共享的一个或多个元数据组件的程序包是程序包依赖项。

每个程序包(以及任何程序包依赖项)都可以与组织中的所有其他元数据隔离地进行测试。将这样的元数据隔离到程序包中,可以灵活地分别对这些元数据集(程序包)进行版本控制。这也使您可以灵活地独立发布软件包。

应用程序生命周期和开发模型-管理日益复杂的版本中的更改

学习目标

完成本单元后,您将能够:

  • 说明使用版本控制如何使变更集版本受益。
  • 描述变更集和组织开发模型之间的相似之处。

本单元描述了为什么Calvin和他的同事着手进行代码和版本控制系统的开发。在阅读本单元时,请考虑为团队做出哪些选择。通过完成本模块末尾列出的模块来进行动手操作,以学习该过程并就最适合您的情况做出最明智的决定。

为了应付日益增加的复杂性,转向组织发展模式

Zephyrus有一个伟大的四分之一。现在,Salesforce正在业务的其他部分中使用,而不仅仅是在Sales中。在咨询了Calvin和客户服务部门的负责人之后,COO同意迁移到企业版并购买Service Cloud Lightning。借助Service Cloud Lightning,公司可以为客户提供即时和个性化的支持。更好的是,客户服务部门拥有一些具有编码技能的团队成员,可以根据他们的团队需求开发Salesforce应用程序。

对于Calvin来说,很明显,组织的复杂性正在超出团队可以通过变更集开发流程管理的范围。公司现在需要更严格的变更管理流程和审核流程(例如版本控制系统)来帮助他们管理如此多的工作流。

团队还面临着使用变更集所能做的限制。例如,他们可以添加但不能删除字段(破坏性更改)。

在向Zephyrus的董事兼首席执行官的演讲中,卡尔文建议他们转向组织发展模式。

卡尔文建议转移到组织开发模型。

与变更集过程一样,他们正在创建的发布工件是相对于其生产组织的一组元数据变更。但是,在组织开发模型中,团队可以通过外部化所做的更改来获得重大的更改管理改进。他们可以使用Salesforce CLI从开发环境中提取元数据,以与版本控制系统(VCS)集成。

他们还可以使用Salesforce CLI编写日常任务的脚本,并提高贡献该版本的每个人的工作效率。卡尔文建议他们首先创建脚本以运行测试部署并运行Apex测试,这对他的董事和首席执行官很有意义。

得益于Calvin的业务驱动论点,他的董事和首席执行官批准了向组织开发的转变。为了表彰他对公司成功的贡献,Calvin被提升为业务分析师。此次晋升还使Calvin获得了跨部门管理发布所需的范围。

新优势和一些熟悉的主题

卡尔文(Calvin)和两个客户服务团队成员各自在具有单独开发环境的不同项目上工作。这三个项目都计划在同一发行版中进行。在组织开发过程中,他们会注意到一些熟悉的方面以及与变更集过程不同的地方。

就像他们在变更集开发中所做的一样,所有三个团队成员都将跟踪他们所做的变更。为什么?团队需要知道哪些组件发生了更改,他们是将这些组件添加到更改集中还是使用Salesforce CLI检索它们。此外,它们的某些自定义项无法部署到另一个组织,因为它们包含未在Metadata API中表示的已更改组件。此类更改必须在目标组织上手动重新创建,因此保持对它们的跟踪仍然很重要。

当团队成员完成各自的开发任务后,下一步就是将所做的更改移至构建环境进行集成。但是现在,他们使用Salesforce CLI从各自的开发环境中检索更改,而不是使用声明性工具创建更改集。他们将工作与VCS集成在一起,因此可以在VCS中提交和跟踪团队成员检索到的更改。

在VCS中提交和跟踪检索到的更改为团队提供了一个重要的好处。在使用变更集过程时,团队成员可以(有时确实)通过在先前的变更集上部署变更集来意外覆盖其他人的变更。通过使用向VCS提交更改的新过程,可以在更改被覆盖之前识别自定义冲突。

进入构建步骤,团队的自定义项已集成到源代码管理的项目中。这些更改将从VCS一起部署到构建环境中,以进行集成和测试。就像更改集过程一样,更改将在构建环境中一起进行测试。就像以前一样,结果是一个单一的发行工件,实际上是一组较大的合并变更。但是Calvin现在使用Salesforce CLI从构建环境中检索工件。并且随着组织开发过程的进行,发行工件不断从VCS转移到下一个环境。

尽管他们在组织开发过程中使用了其他工具,但基本的ALM步骤,变更集概念以及开发和测试环境是相同的。在新的开发模型下从事第一版工作的每个人至少都有一些熟悉的参考点。同样,加尔文很高兴使用Salesforce开发人员网站上的Trailhead和资源来发展他的技术技能和知识。

迁移到组织开发模型有助于使Zephyrus获得在整个公司范围内扩展使用Salesforce所需的控制权和效率。

应用程序生命周期和开发模型-了解发布管理的基础

学习目标

完成本单元后,您将能够:

  • 确定三个发行类别以及每个类别中进行的更改的种类。
  • 描述一个变更集。
  • 说明跟踪变更集发布的变更和依赖性的重要性。

在这个部门中,Calvin和他的同事开始应用ALM流程。在阅读时,请考虑为团队做出的选择。然后,完成本模块末尾列出的模块,以熟悉该过程,以便您确定适合自己的方法。

创建发布管理流程

Zephyrus团队将其定制实践调整为最佳实践ALM步骤。这个过程需要一点时间来适应,但是他们的努力是值得的。他们发现开发速度有所提高,而销售团队的中断却有所减少。这足以赢取团队,管理层对此感到高兴。

通过实施ALM周期,Zephyrus采用了基本的发布管理流程。但是,团队正在进行大型项目和小型项目,都处于ALM周期的不同步骤。为了帮助控制项目和期望,Calvin通过设置发布时间表和定义不同大小的发布标准来增加结构。

发布通常分为三类之一。补丁错误修复和简单更改。简单的更改包括报告,仪表板,列表视图和电子邮件模板。次要影响有限的更改,例如新的工作流程规则或触发影响单个业务流程的更改。这些发行版通常需要测试,但只需要有限的培训和变更管理。通常,团队会在几周内交付变更以进行次要发行。重大的具有重大影响的变更,包括具有一个或多个依赖性的变更。由于这些版本会极大地影响用户体验和数据质量,因此需要进行全面的测试,培训和仔细的变更管理。主要版本通常每季度交付一次(Salesforce一年交付3次)。

按一致的时间表发布。力求定期释放,并在一周的指定日期释放。例如,可能在每个月的第一个星期二东部时间晚上8点发布次要版本。计划一致性有助于整个公司范围内的计划,并为您的业务用户设定期望。还有一件事:尽量不要在假期或其他重大事件附近发布。

跟踪从生产到生产的一系列变更

在执行ALM步骤时,Zephyrus的团队将使用变更集开发模型。他们使用设置UI在开发环境中创建更改,并在完成ALM步骤时在环境之间迁移这些更改。

在变更集开发中,团队的发布工件是相对于生产组织中元数据的一组变更,例如diff或delta。发布的内容仅是已添加或更改的元数据-如果不更改,则不在发布中。

  • 每个开发人员都会跟踪对其发行版的自定义所做的任何更改。跟踪工具可以是从电子表格到工作跟踪系统的任何东西。
  • 某些更改的组件可能尚未在Metadata API中提供,因此必须在环境之间手动迁移。如果跟踪这些更改,您将不会忘记迁移它们。
  • 作为发行经理,Calvin致力于发现发行版中的相关组件并将其包括在内。例如,如果目标组织中不存在其所属的自定义对象,则无法将新的自定义字段迁移到下一个环境。变更集工具可帮助Calvin识别这些依赖性。
组件依赖项页面,按名称列出引用项以及引用它们的内容。

注意

迁移配置文件和权限集可能很棘手。在继续之前,请查看有关部署和检索配置文件和权限集的特殊注意事项。

跟踪每个发行版中的更改都可以进行,但是如果保留您的书,则在正式发布时会顺利进行。

现在都在一起了!

您的发行版可以包含多个项目,并且每个项目都可以在单独的环境中进行开发和测试。但是在构建步骤之前,您需要将所有更改从每个项目迁移到同一环境中以进行集成。从那时起,您在发行版中的更改和自定义将作为单个集成变更集一起行进,即将投入生产。在构建之后的测试发布步骤中,您将一起测试所有更改。

作为发行经理,Calvin跟踪所有发行贡献者的变更。他还跟踪生产中尚未在开发和测试环境中反映的任何更改。为什么?这是他们成功部署自定义项而不会无意间覆盖生产组织中的更改的唯一方法。

应用程序生命周期和开发模型-了解发布管理的基础

学习目标

完成本单元后,您将能够:

  • 确定三个发行类别以及每个类别中进行的更改的种类。
  • 描述一个变更集。
  • 说明跟踪变更集发布的变更和依赖性的重要性。

在这个部门中,Calvin和他的同事开始应用ALM流程。在阅读时,请考虑为团队做出的选择。然后,完成本模块末尾列出的模块,以熟悉该过程,以便您确定适合自己的方法。

创建发布管理流程

Zephyrus团队将其定制实践调整为最佳实践ALM步骤。这个过程需要一点时间来适应,但是他们的努力是值得的。他们发现开发速度有所提高,而销售团队的中断却有所减少。这足以赢取团队,管理层对此感到高兴。

通过实施ALM周期,Zephyrus采用了基本的发布管理流程。但是,团队正在进行大型项目和小型项目,都处于ALM周期的不同步骤。为了帮助控制项目和期望,Calvin通过设置发布时间表和定义不同大小的发布标准来增加结构。

发布通常分为三类之一。补丁错误修复和简单更改。简单的更改包括报告,仪表板,列表视图和电子邮件模板。次要影响有限的更改,例如新的工作流程规则或触发影响单个业务流程的更改。这些发行版通常需要测试,但只需要有限的培训和变更管理。通常,团队会在几周内交付变更以进行次要发行。重大的具有重大影响的变更,包括具有一个或多个依赖性的变更。由于这些版本会极大地影响用户体验和数据质量,因此需要进行全面的测试,培训和仔细的变更管理。主要版本通常每季度交付一次(Salesforce一年交付3次)。

按一致的时间表发布。力求定期释放,并在一周的指定日期释放。例如,可能在每个月的第一个星期二东部时间晚上8点发布次要版本。计划一致性有助于整个公司范围内的计划,并为您的业务用户设定期望。还有一件事:尽量不要在假期或其他重大事件附近发布。

跟踪从生产到生产的一系列变更

在执行ALM步骤时,Zephyrus的团队将使用变更集开发模型。他们使用设置UI在开发环境中创建更改,并在完成ALM步骤时在环境之间迁移这些更改。

在变更集开发中,团队的发布工件是相对于生产组织中元数据的一组变更,例如diff或delta。发布的内容仅是已添加或更改的元数据-如果不更改,则不在发布中。

  • 每个开发人员都会跟踪对其发行版的自定义所做的任何更改。跟踪工具可以是从电子表格到工作跟踪系统的任何东西。
  • 某些更改的组件可能尚未在Metadata API中提供,因此必须在环境之间手动迁移。如果跟踪这些更改,您将不会忘记迁移它们。
  • 作为发行经理,Calvin致力于发现发行版中的相关组件并将其包括在内。例如,如果目标组织中不存在其所属的自定义对象,则无法将新的自定义字段迁移到下一个环境。变更集工具可帮助Calvin识别这些依赖性。
组件依赖项页面,按名称列出引用项以及引用它们的内容。

注意

迁移配置文件和权限集可能很棘手。在继续之前,请查看有关部署和检索配置文件和权限集的特殊注意事项。

跟踪每个发行版中的更改都可以进行,但是如果保留您的书,则在正式发布时会顺利进行。

现在都在一起了!

您的发行版可以包含多个项目,并且每个项目都可以在单独的环境中进行开发和测试。但是在构建步骤之前,您需要将所有更改从每个项目迁移到同一环境中以进行集成。从那时起,您在发行版中的更改和自定义将作为单个集成变更集一起行进,即将投入生产。在构建之后的测试发布步骤中,您将一起测试所有更改。

作为发行经理,Calvin跟踪所有发行贡献者的变更。他还跟踪生产中尚未在开发和测试环境中反映的任何更改。为什么?这是他们成功部署自定义项而不会无意间覆盖生产组织中的更改的唯一方法。

应用程序生命周期和开发模型- 了解什么是应用程序生命周期管理

学习目标

完成本单元后,您将能够:

  • 确定可以直接在生产组织中安全进行的自定义。
  • 定义应用程序生命周期管理。
  • 解释为什么使用应用程序生命周期管理流程可以帮助团队更快地开发应用程序。

介绍

Salesforce提供了各种开发工具和流程来满足客户的需求。本模块介绍了应用程序生命周期管理(ALM)流程和三种开发模型。

  • 变更集开发
  • 组织发展
  • 包装开发

在较高级别上,所有三个开发模型都遵循相同的ALM流程。但是,这些模型的不同之处在于,它们允许您管理组织的更改。控制变更在软件开发中很重要,如果您了解自己的选择,则可以选择最适合您情况的开发模型。

让我们跟随Salesforce专业人员及其公司的发展历程,因为他们的发展挑战会随着时间而变化。在整个故事过程中,您将学习每种开发模型如何满足不同情况的需求。本教程的其他模块中涵盖了有关如何使用开发模型的详细信息。

注意

在类似的情况下,您和您的团队可能做出的选择与该模块中虚构的公司所做的选择不同。重要的是要了解您的选择。

与Zephyrus Relocation Services,Inc.的Salesforce管理员Calvin会面。

卡尔文·格林(Calvin Green)为弗吉尼亚州费尔法克斯的人才流动公司Zephyrus Relocation Services担任许多技术职务。卡尔文(Calvin)的职责之一是为公司规模虽小但不断壮大的销售团队定制Salesforce。使用生产组织中的Setup界面,他淘汰了各种令人印象深刻的新仪表板和报告。

卡尔文(Calvin)通过Vetforce开发了他作为Salesforce管理员的技能,该软件是针对军事服务人员,退伍军人和配偶的Salesforce工作培训和职业加速器计划。

加尔文在Zephyrus站着办公桌,拿着他的Vetforce咖啡杯。

什么是安全的生产变更?

您可以在生产组织中安全地开发某些新功能。在生产组织中可以安全地创建不影响数据的自定义设置,例如开发新的仪表板,报告和电子邮件模板。但是,某些直接在生产中进行的自定义设置可能会因删除数据而造成混乱,甚至更糟。

如果在将变更投入生产之前不测试变更,会发生什么?

  • 工作流规则意外地创建了无限的处理循环。
  • 字段类型的更改会以您无法撤消的方式修改数据。
  • 验证规则中的逻辑错误会阻止您保存记录。
  • 页面布局的更改会使人们感到困惑,而不是改善他们的体验。

定制组织的最安全方法是使用专用的开发环境进行和测试更改。实际上,必须在开发环境中进行一些更改。例如,您不能直接在生产组织中编写Apex代码。

移动到变更集以进行更安全的自定义

随着Zephyrus的不断增长,对Salesforce定制的需求也随之增长。该公司增加了另一名员工来提供帮助。越来越多的定制请求包括新的工作流程规则和页面布局,而Calvin明智地拒绝直接在生产组织中进行这些更改。

为了满足不断变化的业务需求,Zephyrus决定升级到专业版。在专业版中,Zephyrus可以在单独的开发环境中使用声明式(单击)开发工具来创建和测试其需求。

在变更集开发模型中,Calvin和他的同事Ella可以使用声明性工具来管理其应用程序。他们不需要使用命令行界面或版本控制系统来满足他们所支持的销售团队不断增长的定制需求。

借助声明性工具,Calvin和Ella可以创建许多精美的东西来提高销售团队的生产力。例如,加尔文使用Lightning App Builder创建一个过滤器,当金额至少为100万美元时,该过滤器会在机会页面上显示富文本格式的组件。

使用Lightning App Builder创建过滤器。

对混沌施加一点命令

现在,自定义是由多个人在多个环境中进行的,Calvin考虑了如何管理即使是很小的更改对下游的影响。

例如,“联系人”标准对象没有“联系人类型”字段。卡尔文(Calvin)可以轻松添加该自定义字段,并立即向所有用户发布新的联系人类型字段。但是他应该吗?

  • 新的“联系人类型”字段是否与其他人的自定义冲突?
  • 销售团队是否知道如何使用新领域或需要培训?
  • 如果需要该字段,是否需要更新任何集成或导入过程?
  • 该字段出现在哪里?在所有页面布局上?哪些列表视图?它会显示在任何报告或仪表板中吗?
  • 该字段也应该位于Lead对象上吗?如果是这样,潜在客户转换流程会改变吗?
  • 与其他系统集成是否需要该字段?如果是这样,您可能需要更改中间件,字段映射,端点等。

在Salesforce Trailblazer社区中,其他成员鼓励Calvin研究Salesforce建议的应用程序生命周期管理步骤,以开发新的和自定义的应用程序。

在Salesforce开发人员网站上,卡尔文了解到ALM定义了从设计到最终发布的管理应用程序开发的过程。ALM还建立了一个框架,用于随着时间的推移进行应用程序错误修复和功能增强。

等等,这不会增加流程速度吗?

在与IT部门主管ErnestoRondán的一次会议上,Calvin主张转向应用程序生命周期管理。ALM为他们提供了流程和策略,可帮助他们平稳且因此更快构建应用程序,而不会造成麻烦。应用程序和工具可能会有所不同,但是ALM周期中的步骤适用于任何Salesforce开发项目。

ALM周期:计划发布,开发,测试,构建版本,测试发布,发布
  • 步骤1:计划发布从计划开始定制或开发项目。收集需求并进行分析。让您的产品经理(或等效人员)创建设计规范,并与开发团队共享以执行。确定项目在ALM周期中进行时团队需要的各种开发和测试环境。
  • 步骤2:开发按照设计规范完成工作。在包含生产组织的元数据副本但没有生产数据的环境中执行工作。使用说明性工具(Process Builder,Custom Object向导以及UI中的其他工具)和编程工具(开发人员控制台,源代码编辑器或Visual Studio Code)的适当组合在Lightning Platform上进行开发。
  • 步骤3:测试在将其与其他人的工作集成之前,请练习您所做的更改以检查它们是否按预期工作。在与开发步骤中使用的环境类型相同的环境中进行测试,但将开发环境与集成测试环境分开。在这一点上,着重于自己测试更改,而不是了解更改如何影响发行版或整个应用程序的其他部分。
  • 步骤4:内部版本将您在开发阶段创建或修改的所有资产聚合到一个发布工件中:一个逻辑定制包,您将其部署到生产中。从这一点开始,专注于您要发布的内容,而不是个人的贡献。
  • 步骤5:测试发布测试您实际要部署的内容,但在尽可能模拟生产的临时环境中进行安全测试。使用大量实际的代表性生产数据。将您的测试环境与模拟生产系统集成点所需的所有外部系统连接起来。在此步骤中运行完整的回归和最终性能测试。与一小组提供反馈的有经验的人一起测试发行版(一种称为用户接受测试的技术)。
  • 步骤6:放行完成测试并达到质量基准后,可以将定制部署到生产中。培训您的员工和合作伙伴,使他们了解变化。如果发行版对用户有重大影响,请创建一个包含实际数据的单独环境以培训用户。

Salesforce开发人员的JavaScript技能-编写异步JavaScript

学习目标

完成本单元后,您将能够:

  • 识别JavaScript中重要的异步功能。
  • 使用setTimeout异步调用函数。
  • 编写和调用回调函数。
  • 编写和调用基于promise的函数。
  • 描述Aura组件中的异步功能。

回想起我们最初引入JavaScript引擎时的方式。引擎有一个单线程,它可以正常工作,完成工作,然后填充新的工作以重新开始。

当然,至关重要的是不要阻塞线程。 

让我们来看一个例子。

<html>
  <script>
    alert("Does JavaScript show first?");
  </script>
  <body>
    <p>
      Does HTML show first?
    </p>
  </body>
</html>

如果在浏览器中加载该HTML页面,则会发现先弹出警报,然后阻止HTML显示。这是因为该alert()函数会中止JavaScript线程的执行,直到用户将其关闭为止。简而言之,当JavaScript阻止您的浏览器时,就永远不会带来良好的用户体验。 

好消息是,除了一些alert()上面的功能仍然存在的遗留特性外,JavaScript是一种异步语言。 

异步JavaScript无处不在

为了开始异步之旅,让我们重新回顾事件和功能。以前我们看过这样的HTML和JavaScript。

<!-- HTML -->
<button id="clicker">
//JavaScript
let button = document.getElementById("clicker");
button.addEventListener("click", handleClick);

在此示例中,我们将handleClick事件控件添加到按钮发出的click事件中。 

在那里!我们已经编写了一些异步JavaScript。 

事件触发时,所有发生的事情是将新消息添加到队列中。没有事件可以接管线程。触发的每个事件都必须进入队列并等待轮流运行。 

一种说明方法是使用setTimeout函数。在此 示例 invoking中setTimeout,我们以毫秒为单位传递了事件处理程序和计时器。计时器到时,它将触发,将事件处理程序添加到队列中。 

setTimeout(function(){
  console.log("This comes first");
}, 0);
console.log("This comes second");
//output in console
// "This comes second"
// "This comes first"

在这里,我们将计时器设置为零。但这并不意味着“立即致电”。这仅表示“立即将其放入队列中”。但是,代码块本身的执行需要完成,从而清除了调用堆栈。只有这样,函数才能setTimeout 轮流使用。 

另一个常见的错误是认为计时器是事件处理程序何时触发的准确预测器,但不一定。事件处理程序仍然必须等待轮到队列。通过测量时间,我们可以看到这个 在行动。 

const timer  = function(){
  let start = Date.now();
  setTimeout(function(){
    let end = Date.now();
    console.log( "Duration: " + (end - start) )
  },1000);
};
timer();
// Console output when invoked several times:
// "Duration: 1007"
// "Duration: 1000"
// "Duration: 1002"
// "Duration: 1004"

时间设置为一秒,并且它接近于该时间。但是很明显,将函数添加到队列然后在每次调用时运行的速度有所不同。 

现在,我们已经看到了一些异步调用的示例,我们可以看看一些常见的异步模式和构造。 

回调模式

回调只是一个传递给另一个函数的函数,该函数会在将来的某个时刻调用它。 

因此,实际上,我们已经看到了很多回调。 

setTimeout(callback, timer)
Element.addEventListener(event, callback)
Array.map(function(item){...})

让我们将其应用于自行车 用例,以了解如何实现回调。当您换挡时,大多数情况下它都起作用。但是失败的可能性仍然很小。这是异步JavaScript的理想方案。让我们看一下回调的外观,该回调接收有关齿轮如何移动的数据,然后在完成时调用传入的函数。 

Bike.prototype.changeGearAsync = function(shiftObject, callback){
  let newIndex = shiftObject.currentIndex + shiftObject.changeBy;
  if (newIndex < 0 || newIndex > shiftObject.maxIndex) {
    callback(new Error("There is a problem"), null);
  } else {
    callback(null, newIndex);
  }
};

该参数callback实际上是一个函数。如果有错误,我们将调用它并为第一个参数设置要发送回的任何错误数据。成功后,我们将错误参数设为空并传回正确的数据。然后,我们可以看到如何调用新的换档功能。 

Bike.prototype.changeGear = function(frontOrRear, changeBy) {
  const shiftIndexName = frontOrRear + "GearIndex"
  const that = this;
  //contains state change for making the shift
  let shiftObject = {
    currentIndex: this[shiftIndexName],
    maxIndex: this.transmission[frontOrRear + "GearTeeth"].length,
    changeBy: changeBy
  }
  // invoke async function with anonymous callback
  this.changeGearAsync(shiftObject, function(err, newIndex){
    if (err) {
      console.log("No Change");
    } else {
      that[shiftIndexName] = newIndex;
    }
  });
};

回调模式已被广泛接受并广泛使用,但是它也有一些缺点。首先,当多个回调链接在一起时,它们被嵌套在另一个中。这会造成不必要的复杂性,可读性问题,并且在阅读别人的代码时很难推理。此缺陷称为回调地狱。回调也没有隐式错误状态(像try/catch这样)。由开发人员编写回调以明确查找带有if条件的错误,这取决于开发人员。这些障碍导致了诺言的创造。 

箭头功能

在前面的示例中,您可能已经注意到了这一行。

const that = this;

这是旧版JavaScript的遗物。我们仅介绍一种新的函数语法:箭头函数。回想一下调用函数时会发生什么。具体来说,它将绑定到新this上下文。与匿名函数关闭范围内的其他变量不同,JavaScript this实际上在实际上我们需要this包含函数时重新绑定。 

一个长期的解决方法是分配this一个新变量(按照惯例通常称为selfor that),然后将上下文引用保留在闭包中。

箭头函数通过不重新绑定来消除编码技巧的这一点this。箭头函数语法如下所示:

(arg1, arg2) => {...function body...}

使用箭头功能,我们可以删除该that = this位并将其调用更改changeGearsAsync为以下内容。

  // the anonymous function is now an arrow function
this.changeGearAsync(shiftObject, (err, newIndex)=>{
  if (err) {
    console.log("No Change");
  } else {
    // we reference this instead of that
    this[shiftIndexName] = newIndex;
  }
});

有前途的东西

开发为处理异步代码的库的承诺,使您可以更轻松地推断代码成功或失败的时间。它们还包含内置机制,可将一个呼叫链接到另一个呼叫。最终,竞争库在浏览器中被标准化为Promise对象。让我们变身bike一个多 的时间。 

Bike.prototype.changeGearAsync = function(shiftObject){
  return new Promise(
    (resolve, reject) => {
      let newIndex = shiftObject.currentIndex + shiftObject.changeBy;
      if (newIndex < 0 || newIndex > shiftObject.maxIndex) {
        reject("New Index is Invalid: " + newIndex);
      } else {
        resolve(newIndex);
      }
    }
  );
};

首先,更新后的changeGearAsync函数接收我们传递的数据,并返回一个新的Promise对象。我们传入一个参数:一个回调函数,它本身有两个函数传递给它,resolvereject。 

在实现promise时,您可以执行回调函数中所需的任何计算,请求等。完成后,如果一切顺利,您将resolve使用要传递回的数据进行调用。如果遇到问题,您可以通过调用reject任何相关错误作为参数来向函数调用者发出信号。 

让我们看看我们现在如何使用它。 

// invoke async function that returns a promise
this.changeGearAsync(shiftObject)
  .then(
    (newIndex) => {
      this[shiftIndexName] = newIndex;
      console.log(this.calculateGearRatio());
    }
  )
  .catch(
    (err) => {console.log("Error: " + err);}
  );

现在,我们有了一些更容易推理的东西。如果changeGearAsync可行,则将then函数与传递给其参数的函数一起调用。如果没有,catch则被调用。 

如果回调函数本身返回的实例Promise,那么事情就会变得令人兴奋。您可以简单地将这两个Promise函数链接在一起。举例来说,如果我们想改变 这两个前后齿轮。 

Bike.prototype.changeBothGears = function(frontChange, rearChange) {
  let shiftFront = {
    currentIndex: this.frontGearIndex,
    maxIndex: this.transmission.frontGearTeeth.length - 1,
    changeBy: frontChange
  };
  let shiftRear = {
    currentIndex: this.rearGearIndex,
    maxIndex: this.transmission.rearGearTeeth.length - 1,
    changeBy: rearChange
  };
  this.changeGearAsync(shiftFront)
    .then(
      (newIndex) => {
        this.frontGearIndex = newIndex;
        console.log(this.calculateGearRatio());
        return this.changeGearAsync(shiftRear);
      }
    )
    .then(
      (newIndex) => {
        this.rearGearIndex = newIndex;
        console.log(this.calculateGearRatio());
      }
    )
    .catch(
      (err) => {console.log("Error: " + err);}
    );
  };

changeBothGears上面的函数向我们显示了对的两个调用的链接changeGearsAsync,每个调用都与对应于前齿轮或后齿轮的对象相关。第一次调用之后,我们在第一次调用结束时再次调用它thenthen可以在上面加上另一个。从根本上讲,每当一个then承诺返回时,都可以跟随另一个承诺,then直到我们用尽了所有链式动作。  

异步/等待

在签字之前,值得一提的是异步武器库中的一些新功能:asyncawait运算符。这些基于promise,使它们的使用方式与同步JavaScript非常相似。

闪电Web组件和异步JavaScript

利用Lightning Web Components,开发人员可以同时使用基于承诺的异步功能和异步/等待功能。现在唯一的建议是,为开发人员在Internet Explorer 11上为用户创建功能,asyncawait 在该浏览器中未实现。不过,请放心,您的代码可以使用。但是,当在IE11中使用async / await运行任何内容时,LWC会自动使用polyfill,以便语法正确运行。因此,如果经常使用,IE11的性能可能会有所下降。 

与Salesforce互动

在Lightning Web Components中实现了使用异步JavaScript的若干功能。其中大多数围绕与服务器的交互。一个示例是可以在Lightning Web组件中强制调用Apex方法的方法。 

考虑以下Apex类和方法: 

public with sharing class ContactController {
    @AuraEnabled(cacheable=true)
    public static List<Contact> findContacts(String searchKey) {
        if (String.isBlank(searchKey)) {
            return new List<Contact>();
        }
    String key = '%' + searchKey + '%';
    return [SELECT Id, Name, Title, Phone, Email, Picture__c FROM Contact WHERE Name LIKE :key AND Picture__c != null LIMIT 10];
    }
...

Lightning Web Components使用基于Promise的API来展示此方法。您可以这样调用它: 

import { LightningElement, track } from 'lwc';
import findContacts from '@salesforce/apex/ContactController.findContacts';
export default class ApexImperativeMethodWithParams extends LightningElement {
    @track searchKey = '';
    @track contacts;
    @track error;
    handleSearch() {
        findContacts({ searchKey: this.searchKey })
        .then(result => {
            this.contacts = result;
            this.error = undefined;
        })
        .catch(error => {
            this.error = error;
            this.contacts = undefined;
        });
    }
}
注意

注意

这里有一些超出此模块范围的内容,最值得注意的是ES6中JavaScript模块的使用。要了解这些功能,这是考虑进入本教程“现代JavaScript开发”中的下一个模块的绝佳时机。但是在您这样做之前,请先了解一下此代码。 

当我们称其import findContacts…为标准模块语法时,该组件中将包含另一个模块的功能。我们在findContacts这里将Apex方法展示为同名的JS函数。 

当我们在handleSearch()函数中调用它时,Apex方法的参数作为文字对象传递,然后我们看到了then和catch函数的基于promise的语法。

Salesforce开发人员的JavaScript技能-了解上下文,范围和闭包

学习目标

完成本单元后,您将能够:

  • 确定变量在JavaScript中的范围。
  • 描述如何this根据调用函数的位置进行更改。
  • 使用闭包捕获对函数中变量的引用。

理解任何编程语言的关键在于理解变量的可用性,如何维护状态以及如何访问该状态。 

在JavaScript中,变量的可用性和可见性称为范围。范围由声明变量的位置确定。 

上下文是当前代码执行的状态。通过this指针访问它。 

可变范围

在JavaScript变量使用申报varletconst关键字。在何处调用关键字指示要创建的变量的范围。 

了解这三者之间的区别归结为两个因素:分配可变性和支持非功能块作用域。我们在本模块的第一个单元中介绍了分配可变性。现在该讨论范围了。 

范围的乐趣

声明变量或参数的代码块确定其范围。但var不能识别非功能代码块。这意味着调用var在一个if块或一个环块将变量分配给最近的封闭功能的范围。此功能称为提升。 

使用let或时const,参数或变量的范围始终是在其中声明参数的实际块。有一个经典的思维 练习可以证明这一点。

function countToThree() {
  // i is in the scope of the countToThree function
  for (var i = 0; i < 3; i++){
    console.log(i); // iteration 1: 0
    // iteration 2: 1
    // iteration 3: 2
  }
  console.log(i); // What is this?
}

所述console.log内部输出for回路不足为奇,输出的值i对于每次迭代。可能更令人惊讶的是最终console.log声明,它输出3。您可能已经预料到了错误,因为i在您认为是for循环范围之内声明了该错误。但是随着吊装,i实际上属于countToThree的范围。 

虽然不一定很糟糕,但是如果在代码块中重新声明了变量,则吊装通常会被误解,并可能导致变量泄漏或导致意外覆盖。为了解决这些误解let,将const其添加到语言中以创建具有块级作用域的变量。让我们重新思考一下。

for (let j = 0; j < 3; j++){
  console.log(j); // 0
  // 1
  // 2
}
console.log(j); // error

通过替换letvar,我们现在有了一个仅在for循环上下文中存在的变量。在循环关闭后尝试访问它会给我们一个错误。 

上下文和这个

正如我们探索的那样,JavaScript围绕对象。对象是跟踪状态的地方。调用一个函数时,该函数周围始终有一个对象容器。该对象容器是其上下文,this关键字指向该上下文。因此,在声明函数时不会设置上下文,而是在调用函数时设置上下文。 

因为功能可以在对象之间传递,所以this指向的内容可以更改。 

例如说这个JavaScript 对象。

var obj = {
  aValue: 0,
  increment: function(incrementBy) {
    this.aValue = this.aValue + incrementBy;
  }
}

如果然后访问增量功能,它将按预期工作。

obj.increment(2);
console.log(obj.aValue); // 2

但是,让我们将该函数分配给另一个变量,看看它是如何工作的。 

//assign function to variable
var newIncrement = obj.increment;
//now invoke through the new pointer
newIncrement(2);
console.log(obj.aValue); // still 2 not 4

通过将变量分配给newIncrement,现在可以在其他上下文中执行该功能。具体而言,在这种情况下,在全局范围内。 

注意

注意

Function.apply()Function.call()Function.bind()函数提供的方式来调用函数,同时明确其绑定到不同的对象上下文。

全局对象

当执行JavaScript而没有以开发人员身份编写的任何包含对象时,它将在全局对象中运行。因此,据称在此调用的函数正在全局上下文中运行,这意味着访问this将指向该全局上下文。 

在浏览器中,全局上下文是window对象。您可以通过在浏览器开发人员工具中运行以下命令来轻松测试该功能。 

this === window; // true

在该increment示例中,将increment函数分配给newIncrement变量会将调用它的上下文移动到全局对象。这很容易证明。

console.log(this.aValue); // NaN
console.log(window.aValue); // NaN
console.log(typeof window.aValue); // number

当我们尝试this.aValue使用新的上下文进行分配时,JavaScript对象的可变性开始发挥作用。新的未初始化aValue属性已添加到中this。对未初始化的变量执行数学运算将失败,因此该NaN值也会失败。但是我们可以看到aValue存在于window,的确是一个数字。 

与对象的上下文

在此increment示例中,只要increment使用obj点符号来调用函数,就this指向obj。或者,通常来说,当调用函数作为object.function() 点左侧的事物时,始终是调用该函数的上下文。 

想想这个Bike例子。的Bike构造限定了与几个属性this参考。它还具有分配给其引用该原型的功能this。 

const Bike = function(frontIndex, rearIndex){
  this.frontGearIndex = frontIndex || 0;
  this.rearGearIndex = rearIndex || 0;
  ...
}
...
Bike.prototype.calculateGearRatio = function(){
  let front = this.transmission.frontGearTeeth[this.frontGearIndex],
  rear = this.transmission.rearGearTeeth[this.rearGearIndex];
  if (front && rear) {
    return (front / rear) ;
  } else {
    return 0;
  }
};

然后Bike,我们使用new关键字进行调用。 

const bike = new Bike(1,2);
console.log(bike.frontGearIndex); // 1
console.log(bike.rearGearIndex); // 2

看起来我们正在Bike全局上下文中调用构造函数。但是,new关键字将上下文(和this指针)移动到分配左侧的新对象。 

当我们调用任何函数时,它们现在是bike对象的成员,因此它们将其用作包含上下文。 

let gearRatio = bike.calculateGearRatio();
console.log(gearRatio); // 3

以错误的方式调用构造函数很容易。在这里事情会崩溃。

const badBike = Bike(1,2);
console.log(badBike.frontGearIndex); // error
console.log(window.frontGearIndex); // 1

当您忘记使用时newBike将像其他任何函数一样调用,并且thiswindow到新创建的对象的关键转换失败。frontGearIndex 引入对象可变性,并添加属性window。 

注意

classJavaScript中的语法会强制您使用new关键字调用构造函数,因此您不会误导上下文。

关闭

声明函数时,它将保留对其中声明的任何变量或参数的引用,以及对其所包含范围内引用的任何变量的引用。它的变量和自变量以及其包含范围中的局部变量和自变量的这种组合称为闭包。 

考虑此 函数及其返回的函数。 

const greetingMaker = function(greeting){
  return function(whoGreeting){
    return greeting + ", " + whoGreeting + "!";
  }
}
const greetingHello = greetingMaker("Hello");
const greetingBonjour = greetingMaker("Bonjour");
const greetingCiao = greetingMaker("Ciao");
console.log(greetingHello("Gemma")); // Hello, Gemma!
console.log(greetingBonjour("Fabien")); // Bonjour, Fabien!
console.log(greetingCiao("Emanuela")); // Ciao, Emanuela!

greetingMaker被调用时,我们通常可以想象它的greeting参数仅在被调用的整个生命周期内持续存在。 

但是返回的函数会greetinggreetingMaker的范围内保留对参数的引用。这样,最后通过greetingHelloBonjour/ 调用它时Ciao,它仍然可以访问。 

掌握闭包也是理解和使用该语言的重要组成部分。

Salesforce开发人员的JavaScript技能-对事件和功能采取行动

学习目标

完成本单元后,您将能够:

  • 定义功能
  • 区分函数声明和函数表达式
  • 调用功能
  • 传递和分配功能
  • 描述闪电网络组件中功能和事件的使用

当要使事情发生在JavaScript中时,一切都与事件和函数有关。

还记得我们的运行时模型吗?让我们扩展一下。 

使用浏览器中的JavaScript,事件无处不在。DOM的某些部分发出的事件与该DOM对象的行为相对应。按钮具有单击事件,输入和选择控件具有更改事件,并且可见DOM的几乎每个部分实际上都具有鼠标光标与其交互(例如,经过它)的事件。窗口对象甚至具有用于处理设备事件的事件处理程序(例如检测移动设备的运动)。 

为了使某件事发生在网页中,将函数分配给这些事件作为事件处理程序。 

重申一下,DOM事件和与浏览器环境相关的其他事件实际上并不是核心JavaScript语言的一部分,而是它们是在浏览器中为JavaScript实现的API。 

发出事件时,将在引擎中创建一条消息。这些消息被放置在我们前面讨论的事件队列中。 

队列中的消息和堆栈中的帧。

释放堆栈后,将调用事件处理程序。这将在调用堆栈上创建所谓的框架。每次一个函数调用另一个函数时,都会将一个新框架添加到堆栈中,完成后会从堆栈中弹出,直到最后弹出实际事件处理程序的框架,堆栈为空,然后我们重新开始。 

定义和分配功能

在JavaScript中,函数本质上是特殊的对象。作为对象,它们是JavaScript的一流成员。可以将它们分配为变量的值,将其作为参数传递给其他函数,然后从函数中返回。 

函数生命周期有两个基本阶段:定义和调用。  

声明函数时,其定义将加载到内存中。然后以变量名,参数名或对象属性的形式将指针分配给它。但是,有几种不同的语法可以做到这一点也就不足为奇了。

功能声明

声明是使用function关键字创建函数的语句。实际上,当我们查看对象构造函数时,我们已经看到了它。该构造函数是一个函数。但是构造函数有点特殊,所以让我们退一步,谈论普通的旧函数,看看它们是如何工作的: 

// declare function
function calculateGearRatio(driverGear, drivenGear){
  return (driverGear / drivenGear);
}
// call function
let gearRatio = calculateGearRatio(42, 30);
console.log(gearRatio); // 1.4

在此代码示例中,函数后跟函数名称,并在括号中包含参数。 

这可以正常工作,但是有一些隐式事件正在发生。首先,函数名称成为变量名称。它还将变量隐式分配给封闭的上下文。最后,您可以在声明此函数之前调用它,例如在声明下面calculateGearRatio的那一行调用下面。 

// call function
let gearRatio = calculateGearRatio(42, 30);
// function is declared after the line it is called
// this is allowed in function declaration
function calculateGearRatio(driverGear, drivenGear){
  return (driverGear / drivenGear);
}
console.log(gearRatio); // 1.4

函数表达式

函数表达式更明确地实现了与声明相同的功能。 

const calculateGearRatio = function(driverGear, drivenGear){
  return (driverGear / drivenGear);
}
// the rest works the same
let gearRatio = calculateGearRatio(42, 30);
console.log(gearRatio); // 1.4

在这种情况下,我们有一个明确分配的变量。由于我们已经命名了指针,因此可以将函数名称放在function关键字之后。这里唯一的陷阱是必须在调用函数之前声明该函数。 

值得注意的是,函数表达式还用于将函数分配为对象的成员。回想一下我们将changeGear功能分配给Bike.prototype什么时候?  

Bike.prototype.changeGear = function(direction, changeBy) {
  if (direction === 'up') {
    this.currentGear += changeBy;
  } else {
    this.currentGear -= changeBy;
  }
}

返回函数

由于函数是一类对象,因此声明函数的另一种方法是函数返回另一个函数。这种模式通常称为工厂功能。 

// when invoked, this function will assign a function
function gearFactory(){
  return function(driverGear, drivenGear){
    return (driverGear / drivenGear);
  }
}
// calculateGearRatio can now be invoked as a function
const calculateGearRatio = gearFactory();
// and all the rest

虽然上面的例子很简单,但是它是有效的。工厂函数对于一次性可重用函数很有用,尤其是在闭包中捕获变量引用时。我们将在以后的单元中讨论闭包。 

匿名函数

JavaScript中有许多API,要求您传递一个函数才能使它们起作用。例如,假设您有一个数组,并且想要创建一个从该数组的值派生的新数组。在这种情况下,您可能会使用该Array.map 功能。

let myArray = [1, 5, 11, 17];
let newArray = myArray.map( function(item){ return item / 2 } );
console.log(newArray); // [0.5, 2.5, 5.5, 8.5]

在此代码段中,myArray.map采用一个参数:该函数对中的每个项目执行一次myArray。 

此功能永远不会重用。它被声明为传递给函数的参数(没有名称…因此“匿名”),并在map函数实现的内部执行。匿名函数( 在某些语言中也称为lambda)在JavaScript中很常见。 

功能调用

声明函数后,您可能想遍历调用它。调用函数时,会发生一些事情。 

请记住,第一件事是将新框架推入堆栈。然后在内存中创建一个包含其变量和参数的对象。this然后,将指针与其他一些特殊对象绑定到该对象。然后,将传递给参数的值赋值,最后运行时开始执行函数体内的语句。 

的绑定this有一个重要的例外,我们将在异步JavaScript的单元中重新进行讨论。 

调用与分配

使用函数时,与JavaScript新手混淆的一个潜在原因是您是分配/传递函数还是调用它。这一切都取决于您是否使用()。 

考虑我们的自行车对象的calculateGearRatio功能。 

let bike = {
  ...,
  calculateGearRatio: function() {
    let front = this.transmission.frontGearTeeth[this.frontGearIndex],
    rear = this.transmission.rearGearTeeth[this.rearGearIndex];
    return (front / rear);
  },
  ...
}

现在考虑这两种访问calculateGearRatio函数的不同方式。  

// invoke function and assign value to ratioResult
let ratioResult = bike.calculateGearRatio();
// assign calculateGearRatio function to a new pointer
const ratioFunction = bike.calculateGearRatio;

在第一种情况下,calculateGearRatio将调用,并将从函数返回的结果分配给该ratioResult变量(在这种情况下作为原始值)。另一方面ratioFunction ,仅已分配或指向该calculateGearRatio功能。然后,您可以掉头并以方式调用它ratioFunction。 

有理由将一个函数分配给另一个指针,特别是作为另一个函数的参数,就像该Array.map()函数一样。但是使用this参考的任何功能都有可能会被破坏,因为它this可以在不同的时间指向不同的事物。以后再说。 

充当事件处理程序

如果您希望某个函数作为事件的结果而触发,则需要将其连接到该事件。这样做会使该函数成为事件处理程序。函数定义需要包含一个参数:指向触发它的事件的指针。 

var handleClick = function(event) {
}

每个事件都具有告诉您处理该事件所需了解的属性。例如,click您可以检测到有关点击的数据(事件类型,触发该事件的元素,点击的坐标等)。  

var handleClick = function(event) {
  console.log(event.type);  // click
  console.log(event.currentTarget); // the thing you clicked
  console.log(event.screenX); // screen X coordinate
  console.log(event.screenY); // screen Y coordinate
}

通过DOM API分配事件处理程序

在简单的网页中,您有时可能会在HTML中看到显式分配的事件处理程序。 

<button onclick="handleClick(event)">
  Click to Go
</button>

但是,现代Web应用程序很少在HTML中使用事件绑定。相反,首选DOM API,特别是JavaScript Element.addEventListener()函数。 

首先,您需要对HTML元素的引用。下面,我们在id按钮中添加了一个属性,并删除了onclick属性。 

<button id=”clicker”>

现在我们进入DOM,获取对按钮的引用,并通过将事件侦听器handleClick作为值(注意,不带括号)传递给事件侦听器。 

let button = document.getElementById("clicker");
button.addEventListener("click", handleClick);

使用DOM API可使开发人员灵活地使UI高度交互并响应用户的操作。如果需要关闭功能,开发人员还可以删除事件侦听器。 

button.removeEventListener("click", handleClick);

您还将看到匿名函数添加为事件侦听器。 

button.addEventListener("click", function(event){
  //...anonymous function body...
});

请记住,不能使用来删除匿名函数removeEventListener,因为没有指针可以传入以识别该函数。 

Lightning Web Components中的事件和功能

Lightning Web组件的关键代码工件是JavaScript模块,HTML模板和CSS文件。其中唯一需要的是JavaScript模块(注意,.xml还需要的文件不是代码,而是有关组件的元数据)。 

Lightning Web组件中的功能通常以方法的形式出现,这些方法是该组件的JavaScript模块导出的类的成员。这些函数可以是事件处理程序,也可以是从下游向下游调用的其他函数。 

HTML模板以类似于静态HTML绑定的方式引用处理程序函数,但实际上是不同的。由于模板已编译为JavaScript工件,因此看起来静态的绑定实际上只是框架addEventListener在组件生命周期中某个时间调用的语法约定。 

模板中的此标记显示事件处理程序绑定。

<lightning-input onchange={handleChange} label="Input Text" value={text}>
</lightning-input>

这是事件处理程序。 

    handleChange(event){
        this.text = event.target.value;
    }
注意

注意

Lightning Web Components中有许多事件的更高级的功能。要探索这些功能,请完成Lightning Web Components基础知识模块,或深入研究其中一个示例 应用程序。

Salesforce开发人员的JavaScript技能-对事件和功能采取行动

学习目标

完成本单元后,您将能够:

  • 定义功能
  • 区分函数声明和函数表达式
  • 调用功能
  • 传递和分配功能
  • 描述闪电网络组件中功能和事件的使用

当要使事情发生在JavaScript中时,一切都与事件和函数有关。

还记得我们的运行时模型吗?让我们扩展一下。 

使用浏览器中的JavaScript,事件无处不在。DOM的某些部分发出的事件与该DOM对象的行为相对应。按钮具有单击事件,输入和选择控件具有更改事件,并且可见DOM的几乎每个部分实际上都具有鼠标光标与其交互(例如,经过它)的事件。窗口对象甚至具有用于处理设备事件的事件处理程序(例如检测移动设备的运动)。 

为了使某件事发生在网页中,将函数分配给这些事件作为事件处理程序。 

重申一下,DOM事件和与浏览器环境相关的其他事件实际上并不是核心JavaScript语言的一部分,而是它们是在浏览器中为JavaScript实现的API。 

发出事件时,将在引擎中创建一条消息。这些消息被放置在我们前面讨论的事件队列中。 

队列中的消息和堆栈中的帧。

释放堆栈后,将调用事件处理程序。这将在调用堆栈上创建所谓的框架。每次一个函数调用另一个函数时,都会将一个新框架添加到堆栈中,完成后会从堆栈中弹出,直到最后弹出实际事件处理程序的框架,堆栈为空,然后我们重新开始。 

定义和分配功能

在JavaScript中,函数本质上是特殊的对象。作为对象,它们是JavaScript的一流成员。可以将它们分配为变量的值,将其作为参数传递给其他函数,然后从函数中返回。 

函数生命周期有两个基本阶段:定义和调用。  

声明函数时,其定义将加载到内存中。然后以变量名,参数名或对象属性的形式将指针分配给它。但是,有几种不同的语法可以做到这一点也就不足为奇了。

功能声明

声明是使用function关键字创建函数的语句。实际上,当我们查看对象构造函数时,我们已经看到了它。该构造函数是一个函数。但是构造函数有点特殊,所以让我们退一步,谈论普通的旧函数,看看它们是如何工作的: 

// declare function
function calculateGearRatio(driverGear, drivenGear){
  return (driverGear / drivenGear);
}
// call function
let gearRatio = calculateGearRatio(42, 30);
console.log(gearRatio); // 1.4

在此代码示例中,函数后跟函数名称,并在括号中包含参数。 

这可以正常工作,但是有一些隐式事件正在发生。首先,函数名称成为变量名称。它还将变量隐式分配给封闭的上下文。最后,您可以在声明此函数之前调用它,例如在声明下面calculateGearRatio的那一行调用下面。 

// call function
let gearRatio = calculateGearRatio(42, 30);
// function is declared after the line it is called
// this is allowed in function declaration
function calculateGearRatio(driverGear, drivenGear){
  return (driverGear / drivenGear);
}
console.log(gearRatio); // 1.4

函数表达式

函数表达式更明确地实现了与声明相同的功能。 

const calculateGearRatio = function(driverGear, drivenGear){
  return (driverGear / drivenGear);
}
// the rest works the same
let gearRatio = calculateGearRatio(42, 30);
console.log(gearRatio); // 1.4

在这种情况下,我们有一个明确分配的变量。由于我们已经命名了指针,因此可以将函数名称放在function关键字之后。这里唯一的陷阱是必须在调用函数之前声明该函数。 

值得注意的是,函数表达式还用于将函数分配为对象的成员。回想一下我们将changeGear功能分配给Bike.prototype什么时候?  

Bike.prototype.changeGear = function(direction, changeBy) {
  if (direction === 'up') {
    this.currentGear += changeBy;
  } else {
    this.currentGear -= changeBy;
  }
}

返回函数

由于函数是一类对象,因此声明函数的另一种方法是函数返回另一个函数。这种模式通常称为工厂功能。 

// when invoked, this function will assign a function
function gearFactory(){
  return function(driverGear, drivenGear){
    return (driverGear / drivenGear);
  }
}
// calculateGearRatio can now be invoked as a function
const calculateGearRatio = gearFactory();
// and all the rest

虽然上面的例子很简单,但是它是有效的。工厂函数对于一次性可重用函数很有用,尤其是在闭包中捕获变量引用时。我们将在以后的单元中讨论闭包。 

匿名函数

JavaScript中有许多API,要求您传递一个函数才能使它们起作用。例如,假设您有一个数组,并且想要创建一个从该数组的值派生的新数组。在这种情况下,您可能会使用该Array.map 功能。

let myArray = [1, 5, 11, 17];
let newArray = myArray.map( function(item){ return item / 2 } );
console.log(newArray); // [0.5, 2.5, 5.5, 8.5]

在此代码段中,myArray.map采用一个参数:该函数对中的每个项目执行一次myArray。 

此功能永远不会重用。它被声明为传递给函数的参数(没有名称…因此“匿名”),并在map函数实现的内部执行。匿名函数( 在某些语言中也称为lambda)在JavaScript中很常见。 

功能调用

声明函数后,您可能想遍历调用它。调用函数时,会发生一些事情。 

请记住,第一件事是将新框架推入堆栈。然后在内存中创建一个包含其变量和参数的对象。this然后,将指针与其他一些特殊对象绑定到该对象。然后,将传递给参数的值赋值,最后运行时开始执行函数体内的语句。 

的绑定this有一个重要的例外,我们将在异步JavaScript的单元中重新进行讨论。 

调用与分配

使用函数时,与JavaScript新手混淆的一个潜在原因是您是分配/传递函数还是调用它。这一切都取决于您是否使用()。 

考虑我们的自行车对象的calculateGearRatio功能。 

let bike = {
  ...,
  calculateGearRatio: function() {
    let front = this.transmission.frontGearTeeth[this.frontGearIndex],
    rear = this.transmission.rearGearTeeth[this.rearGearIndex];
    return (front / rear);
  },
  ...
}

现在考虑这两种访问calculateGearRatio函数的不同方式。  

// invoke function and assign value to ratioResult
let ratioResult = bike.calculateGearRatio();
// assign calculateGearRatio function to a new pointer
const ratioFunction = bike.calculateGearRatio;

在第一种情况下,calculateGearRatio将调用,并将从函数返回的结果分配给该ratioResult变量(在这种情况下作为原始值)。另一方面ratioFunction ,仅已分配或指向该calculateGearRatio功能。然后,您可以掉头并以方式调用它ratioFunction。 

有理由将一个函数分配给另一个指针,特别是作为另一个函数的参数,就像该Array.map()函数一样。但是使用this参考的任何功能都有可能会被破坏,因为它this可以在不同的时间指向不同的事物。以后再说。 

充当事件处理程序

如果您希望某个函数作为事件的结果而触发,则需要将其连接到该事件。这样做会使该函数成为事件处理程序。函数定义需要包含一个参数:指向触发它的事件的指针。 

var handleClick = function(event) {
}

每个事件都具有告诉您处理该事件所需了解的属性。例如,click您可以检测到有关点击的数据(事件类型,触发该事件的元素,点击的坐标等)。  

var handleClick = function(event) {
  console.log(event.type);  // click
  console.log(event.currentTarget); // the thing you clicked
  console.log(event.screenX); // screen X coordinate
  console.log(event.screenY); // screen Y coordinate
}

通过DOM API分配事件处理程序

在简单的网页中,您有时可能会在HTML中看到显式分配的事件处理程序。 

<button onclick="handleClick(event)">
  Click to Go
</button>

但是,现代Web应用程序很少在HTML中使用事件绑定。相反,首选DOM API,特别是JavaScript Element.addEventListener()函数。 

首先,您需要对HTML元素的引用。下面,我们在id按钮中添加了一个属性,并删除了onclick属性。 

<button id=”clicker”>

现在我们进入DOM,获取对按钮的引用,并通过将事件侦听器handleClick作为值(注意,不带括号)传递给事件侦听器。 

let button = document.getElementById("clicker");
button.addEventListener("click", handleClick);

使用DOM API可使开发人员灵活地使UI高度交互并响应用户的操作。如果需要关闭功能,开发人员还可以删除事件侦听器。 

button.removeEventListener("click", handleClick);

您还将看到匿名函数添加为事件侦听器。 

button.addEventListener("click", function(event){
  //...anonymous function body...
});

请记住,不能使用来删除匿名函数removeEventListener,因为没有指针可以传入以识别该函数。 

Lightning Web Components中的事件和功能

Lightning Web组件的关键代码工件是JavaScript模块,HTML模板和CSS文件。其中唯一需要的是JavaScript模块(注意,.xml还需要的文件不是代码,而是有关组件的元数据)。 

Lightning Web组件中的功能通常以方法的形式出现,这些方法是该组件的JavaScript模块导出的类的成员。这些函数可以是事件处理程序,也可以是从下游向下游调用的其他函数。 

HTML模板以类似于静态HTML绑定的方式引用处理程序函数,但实际上是不同的。由于模板已编译为JavaScript工件,因此看起来静态的绑定实际上只是框架addEventListener在组件生命周期中某个时间调用的语法约定。 

模板中的此标记显示事件处理程序绑定。

<lightning-input onchange={handleChange} label="Input Text" value={text}>
</lightning-input>

这是事件处理程序。 

    handleChange(event){
        this.text = event.target.value;
    }
注意

注意

Lightning Web Components中有许多事件的更高级的功能。要探索这些功能,请完成Lightning Web Components基础知识模块,或深入研究其中一个示例 应用程序。

Salesforce开发人员的JavaScript技能-处理对象,类和原型继承

学习目标

完成本单元后,您将能够:

  • 使用对象文字符号和构造函数创建对象。
  • 将属性和功能分配给对象。
  • 确定原型在JavaScript对象继承中的作用。
  • 描述JavaScript类语法。
  • 描述闪电网络组件中继承的作用和对象文字表示法。

有很多方法可以将JavaScript描述为一种语言。无论您选择哪种定义,每个人都可以同意对象的JavaScript概念的重要性。您越了解JavaScript对象以及它们如何工作,就越能编写有效的JavaScript。

在开始之前,请先对对象进行一些说明。 

  • 对象没有Apex,Java或C#开发人员可能会想到的类。
  • 每个对象都继承自另一个对象。
  • 对象是可变的。
  • 对象在创建时会获得自己的变量上下文。

创建对象

从语法上讲,有几种方法可以用JavaScript创建对象。但是,无论您如何创建对象,它实际上都是在抽象一个称为的底层API Object.create()。  

在某些情况下,有充分的理由Object.create()直接使用,但我们不在此介绍。相反,让我们看一下创建对象的更常见方法。 

对象文字表示法

第一个对象创建语法称为对象文字表示法。这是一次同时声明和分配对象的简单声明方式。然后立即将对象分配为同一语句的一部分。 

const bike = {
  gears: 10,
  currentGear: 3,
  changeGear: function(direction, changeBy) {
    if (direction === 'up') {
      this.currentGear += changeBy;
    } else {
      this.currentGear -= changeBy;
    }
  }
}
console.log(bike.gears); // 10
console.log(bike.currentGear); //3
bike.changeGear('up', 1);
console.log(bike.currentGear); //4

对象文字符号本质上是声明性的。bike此 示例中的对象具有三个成员:gearscurrentGear属性以及changeGear函数。若要在创建对象后引用这些成员,请使用点表示法。 

注意

您可能会注意到JSON和对象文字表示法彼此相似,但是它们并不相同。JSON是一种数据交换格式。对象文字符号是一种编程语法。但是,JSON规范基于对象文字表示法,因此很容易将两者混为一谈。

文字对象非常适合一次性对象。但是,如果要创建两个或更多个相同类型的对象,则它们是不实际的。为此,您需要可重复的逻辑来创建新对象。 

构造函数的新对象

创建对象的另一种方法是使用构造函数。构造函数是一种函数,其中包含用于在创建和分配对象时建立对象属性的指令。与对象文字相比,这具有优势,因为您可以创建具有相同属性的对象的许多实例。 

function Bike(gears, startGear) {
  this.gears = gears;
  this.currentGear = startGear;
}
Bike.prototype.changeGear = function(direction,changeBy){
  if(direction === 'up') {
    this.currentGear += changeBy;
  } else {
    this.currentGear -= changeBy;
  }
}
const bike = new Bike(10, 3);
console.log(bike.gears); // 10
console.log(bike.currentGear); //3
bike.changeGear('up', 1);
console.log(bike.currentGear); //4

在此 示例中, Bike是定义对象的普通JavaScript函数。我们遵循JavaScript约定并大写第一个单词来表示此函数是构造函数。该new关键字是至关重要的。如果不使用new,则this指针将不会指向您期望的对象,并且会导致意外的行为。this当我们在以后的单元中介绍上下文时,我们会重新进行讨论。 

请注意,该changeGear函数的分配是通过使用来完成的prototype。这样可以确保函数定义一次,并由该构造函数创建的所有实例共享。我们将在本单元后面介绍原型的使用和继承。 

在语法方面,对象文字表示法和构造函数完全不同。但是在每种情况下,您仍然最终会在内存中创建一个新对象,并使用变量bike作为指向该对象的指针。使用构造函数,您可以使许多Bike具有相同属性和功能的对象。

为对象分配属性和功能

如果从bike上面的示例推断出对象中有两种可能的成员类型-属性和函数-您将是正确的。  

属性具有三种基本形状。

  • 原语
  • 对象
  • 数组

有六种基本类型在JavaScript:字符串,数字,布尔nullundefined和符号。如果变量是原始类型,则在分配时按值传递。也就是说,每次分配基元时,都会复制值并将其分配给新变量。 

几乎所有不是JavaScript中原始语言的东西都是对象。在对象文字表示法中,对象属性用大括号表示。 

数组本身也被实现为JavaScript中的对象。可以使用Array()构造函数或以方括号表示的文字符号来创建数组。 

函数在此模块中有其自己的单元,因此我们在这里不再讨论它们,但是基于以上内容,让我们通过bike使用对象文字符号定义更复杂的对象的方法。

const bike = {
  frontGearIndex: 0,
  rearGearIndex: 0,
  transmission: {
    frontGearTeeth: [30,45],
    rearGearTeeth: [11,13,15,17,19,21,24,28,32,36]
  },
  calculateGearRatio: function() {
    let front = this.transmission.frontGearTeeth[this.frontGearIndex],
        rear = this.transmission.rearGearTeeth[this.rearGearIndex];
    return (front / rear);
  },
  changeGear: function(frontOrRear, newValue) {
    if (frontOrRear === 'front') {
      this.frontGearIndex = newValue;
    } else {
      this.rearGearIndex = newValue;
    }
  }
};

通过括号语法引用属性

引用对象成员通常是使用点符号来完成的。例如,在前面的示例中,我们按如下方式引用对象的属性和功能。

bike.frontGearIndex
bike.transmission.frontGearTeeth
bike.calculateGearRatio()

用点表示法,对属性名称有严格的规定。但是,JavaScript还允许使用另一种称为括号符号的语法。上面的成员将在括号中引用如下。

bike["frontGearIndex"]
bike["transmission"]["frontGearTeeth"]
bike["calculateGearRatio"]()

虽然需要更多的输入,但方括号表示法有两个好处。您可以为属性或函数命名任何所需的名称,并且由于它是字符串,因此可以通过变量传递属性或函数名称并进行调用。

让我们通过重新构想changeGear功能来了解这一点。现在,我们使用四个功能来定义前后齿轮的上下变速。在changeGear函数中,我们根据String参数构造要调用的函数名称,然后调用它。 

changeGear: function(frontOrRear, upOrDown) {
  let shiftFunction = frontOrRear + upOrDown;
  this[shiftFunction]();
},
frontUp: function(){
  this.frontGearIndex += 1;
},
frontDown: function(){
  this.frontGearIndex -= 1;
},
rearUp: function(){
  this.rearGearIndex += 1;
},
rearDown: function(){
  this.rearGearIndex -= 1;
}

将它们添加到我们的自行车对象中,我们可以在工作中看到它们。 

console.log(bike.calculateGearRatio()); // 2.727272727
//Calls the frontUp() function
bike.changeGear("front", "Up");
console.log(bike.calculateGearRatio()); // 4.090909091
//calls the rearUp() function
bike.changeGear("rear", "Up");
console.log(bike.calculateGearRatio()); // 3.461538461

对象可变性

除了用于定义对象的不同语法外,JavaScript对象还有另一个关键原理:可变性。 

JavaScript中的对象是可变的,这意味着如果您想要修改对象的形状,则可以。 

让我们来看看bike我们创建的对象。例如,我们可以添加一个新的属性或函数。 

bike.isTandem = true;
bike.popAWheelie = function() {
…
};

即使您可能无法访问最初定义对象的代码,也可以在将对象保存在内存中后修改其形状。不过,重要的一点是,只有一个对象实例发生了变化。让我们回顾一下我们的Bike 构造函数:

const bike1 = new Bike();
const bike2 = new Bike();
bike1.isTandem = true;
console.log(bike1.isTandem); // true
console.log(bike2.isTandem); // undefined

如果您希望多个对象共享相同的属性或方法,则有一个继承模型。让我们看看。 

对象与继承

尽管没有古典语言定义的类,JavaScript仍具有一个继承模型,称为原型继承。 

实际上,原型是另一个对象。它位于内存中,并定义其他对象共享相同原型时所继承的属性或函数。 

传统上,JavaScript对象通过共享相同的构造函数来共享相同的原型。记住Bike 构造函数。我们将changeGear函数分配给prototype。 

function Bike(gears, startGear) {
  this.gears = gears;
  this.currentGear = startGear;
}
Bike.prototype.changeGear = function(direction, changeBy) {
  if (direction === 'up') {
    this.currentGear += changeBy;
  } else {
    this.currentGear -= changeBy;
  }
}

这样,从中创建的每个对象都会Bike继承该changeGear函数。 

您还可以使用原型实现多级继承。它被称为原型链。使用构造函数来实现原型链非常复杂,并且需要大量样板代码。它也超出了本模块的范围。您需要知道的是,为了解决原型链的复杂性,ECMA为实现继承的更直接的语法制定了一个标准:class语法。 

类和JavaScript

如果您阅读“类”一词并感到温暖而模糊,以为您正在寻找可以创建基于类的真正继承的东西,请准备感到失望。尽管如此,classJavaScript中的关键字还是一个不错的语法糖,可以使用构造函数来解决原型继承的复杂性。在幕后,引擎仍在使用,Object.create并且没有类(在面向对象的意义上),只是内存中的原型对象是实际的继承源。 

好消息是,它确实从Java或C#中读取了很多类似的代码,并且需要考虑一些JavaScript特定的内容。 

注意

当由Lightning Web Components使用时,包括类语法的多级原型链超出了此模块。有关使用JavaScript对象的较新功能的更多详细信息,请参见本单元末尾的资源链接。我们强烈建议您在本教程中使用其他 模块,即Modern JavaScript Development,该模块在Classes中有一个完整的单元

尽管我们在这里不会深入探讨JavaScript类的细节,但出于学术目的,很高兴看到使用类语法实现的bike对象的版本。 

class Bike {
    constructor(gears, startGear){
        this.gears = gears;
        this.currentGear = startGear;
    }
    changeGear(direction, changeBy) {
        if (direction === 'up') {
            this.currentGear += changeBy;
        } else {
            this.currentGear -= changeBy;
        }
    }
}
const bike = new Bike(10, 5);
console.log(bike.currentGear); // 5
bike.changeGear('up', 2);
console.log(bike.currentGear); // 7

如您所见,语法看起来更像Java或Apex中的类。明显的区别是,构造函数始终为命名constructor。一个重要的功能是,函数和属性自动属于原型链,而不必直接引用Object.prototype。这也简化了创建多级原型继承的过程。 

闪电Web组件和对象

本单元的几个部分与开发Lightning Web Components有关,包括我们讨论的一些语法以及原型链。 

类和闪电Web组件

闪电Web组件利用了JavaScript的许多现代改进,最明显的是使用了类语法。组件通常由JavaScript类定义,该类扩展了另一个名为LightningElement的类。看起来是这样的: 

import { LightningElement } from lwc;
export default class MyComponent extends LightningElement {
    myProperty;
    myFunction() {
        console.log(this.myProperty);
    }
} 

Lightning Web组件的功能在JavaScript类中定义。此示例还使用了一些关于模块(importexport)尚未涉及的语法。

论对象文字

在本模块的某些示例中,为了学习对象的工作方式,我们在对象文字中声明了函数。请注意,这不是现代JavaScript中推荐的做法。对象文字是创建临时数据结构以在JavaScript程序的功能部分之间传递数据的一种好方法,但是您应避免在对象文字中定义函数。