DEX601

课程介绍

今天我们来聊聊Salesforce的入门知识。Salesforce是一个非常强大的客户关系管理（CRM）工具，它可以帮助企业更好地管理客户信息、销售流程、市场营销活动等等。 首先，我们要了解Salesforce的基本界面。当你登录Salesforce后，你会看到一个仪表盘，这里会显示一些关键的数据和报告，帮助你快速了解业务状况。左侧有一个导航栏，你可以通过它访问不同的模块，比如“客户”、“销售机会”、“市场营销”等等。 接下来，我们来谈谈Salesforce的核心概念——对象（Object）。在Salesforce中，对象就像是数据库中的表，用来存储不同类型的数据。比如，“客户”对象存储客户信息，“销售机会”对象存储销售机会信息。每个对象都有字段（Field），字段就是表中的列，用来存储具体的数据项。 Salesforce还有一个非常重要的概念——记录（Record）。记录就是对象中的一行数据，比如一个具体的客户信息就是一个记录。你可以通过Salesforce的界面来查看、编辑、删除这些记录。 最后，我们来简单介绍一下Salesforce的自动化功能。Salesforce提供了很多自动化工具，比如工作流（Workflow）、流程构建器（Process Builder）和Apex触发器（Apex Trigger），这些工具可以帮助你自动化一些重复性的任务，提高工作效率。 好了，今天的内容就到这里。希望这些基础知识能帮助你更好地理解Salesforce。如果你有任何问题，随时可以问我。我们下次再见！

课程章节

本课程共有 191 个章节

• 1

  Unit 2 Getting Started

  第 50 页

  今天我们来聊聊Salesforce的入门知识。Salesforce是一个非常强大的客户关系管理（CRM）工具，它可以帮助企业更好地管理客户信息、销售流程、市场营销活动等等。 首先，我们要了解Salesforce的基本界面。当你登录Salesforce后，你会看到一个仪表盘，这里会显示一些关键的数据和报告，帮助你快速了解业务状况。左侧有一个导航栏，你可以通过它访问不同的模块，比如“客户”、“销售机会”、“市场营销”等等。 接下来，我们来谈谈Salesforce的核心概念——对象（Object）。在Salesforce中，对象就像是数据库中的表，用来存储不同类型的数据。比如，“客户”对象存储客户信息，“销售机会”对象存储销售机会信息。每个对象都有字段（Field），字段就是表中的列，用来存储具体的数据项。 Salesforce还有一个非常重要的概念——记录（Record）。记录就是对象中的一行数据，比如一个具体的客户信息就是一个记录。你可以通过Salesforce的界面来查看、编辑、删除这些记录。 最后，我们来简单介绍一下Salesforce的自动化功能。Salesforce提供了很多自动化工具，比如工作流（Workflow）、流程构建器（Process Builder）和Apex触发器（Apex Trigger），这些工具可以帮助你自动化一些重复性的任务，提高工作效率。 好了，今天的内容就到这里。希望这些基础知识能帮助你更好地理解Salesforce。如果你有任何问题，随时可以问我。我们下次再见！

  ▶ 播放视频 查看详情
• 2

  Unit 2: Getting Started

  第 51 页

  大家好，欢迎来到第2单元的学习。今天我们要一起探索如何利用HTML5和Salesforce的Lightning组件来开发功能强大的移动应用程序。 首先，我们会回顾一下HTML5应用程序的一些基本特征、功能以及它的一些限制。了解这些基础知识对于我们后续的开发工作非常重要。 接着，我们将深入使用Aura Components和Apex来开发Salesforce移动应用程序。Aura Components是Salesforce提供的一种强大的UI框架，它可以帮助我们快速构建响应式的用户界面。而Apex则是Salesforce的一种强大的编程语言，它允许我们编写复杂的业务逻辑。 在本单元中，我们还会学习如何使用CSS来主题化我们的组件，使应用程序看起来更加美观和专业。同时，我们也会学习如何定义和操作组件的属性，以及如何处理系统和用户事件，这些都是开发中不可或缺的技能。 当然，开发过程中难免会遇到一些问题，所以我们也会学习如何进行调试和故障排除，确保我们的应用程序能够稳定运行。 最后，我们会学习如何与Apex合作，使用基本的Aura组件，提出和处理事件，以及使用Lightning数据服务进行CRUD操作（即创建、读取、更新和删除操作）。 好了，这就是我们今天的学习内容。希望大家能够跟上节奏，积极参与到每一个环节中来。如果有任何疑问，随时提问，我会尽力帮助大家解答。让我们一起开始这段精彩的学习之旅吧！

  ▶ 播放视频 查看详情
• 3

  Topics

  第 52 页

  同学们，今天我们来聊聊HTML5在应用程序开发中的优势和缺点，以及Salesforce的Lightning组件架构。 首先，HTML5的优势非常明显。它支持跨平台开发，这意味着你只需要编写一次代码，就可以在多种设备上运行，无论是手机、平板还是电脑。此外，HTML5还提供了丰富的API支持，比如地理定位、本地存储等，这些都大大增强了应用的功能和用户体验。 但是，HTML5也有它的缺点。由于它依赖于浏览器的支持，不同浏览器的兼容性问题可能会导致应用在某些设备上表现不一致。此外，HTML5的性能可能不如原生应用，特别是在处理复杂动画或大量数据时。 接下来，我们回顾一下Salesforce的Lightning组件架构。Lightning组件是基于Aura框架的，它允许开发者创建动态、响应式的用户界面。Lightning组件是可重用的，这意味着你可以在不同的应用中多次使用同一个组件，极大地提高了开发效率。 表面光环组件是Lightning组件的一种，它提供了一种简单的方式来展示数据，比如列表、表格等。这些组件非常直观，易于使用，可以帮助你快速构建出功能丰富的用户界面。 使用Lightning和Visualforce，你可以创建出既美观又功能强大的应用。Visualforce是Salesforce的一种标记语言，它允许你创建自定义的用户界面，而Lightning则提供了现代化的UI组件和交互体验。 了解Aura组件的最佳使用案例也很重要。Aura组件非常适合用于构建复杂的、动态的用户界面，特别是在需要高度定制化的场景中。它们可以帮助你快速实现复杂的业务逻辑和用户交互。 最后，我们来看看OOTB（Out of the Box）Aura组件。这些是Salesforce提供的现成组件，你可以直接在你的应用中使用，无需从头开发。它们覆盖了各种常见的业务需求，比如数据展示、表单输入等。 使用名称空间是管理组件的一种有效方式。名称空间可以帮助你组织和区分不同的组件，特别是在大型项目中，这可以避免命名冲突，提高代码的可维护性。 好了，今天的课程就到这里。希望大家能够理解HTML5的优势和缺点，以及如何在Salesforce中有效地使用Lightning组件。记得查看学生指南中的幻灯片，以便更深入地理解这些概念。如果有任何问题，随时提问。谢谢大家！

  ▶ 播放视频 查看详情
• 4

  Lightning Component Programming Models

  第 53 页

  今天我们来聊聊Salesforce中的Lightning组件编程模型。在Salesforce中，我们主要使用两种编程模型来构建Lightning组件：一种是闪电Web组件，另一种是光环组件。 首先，闪电Web组件，这是一种比较新的技术，它基于现代的Web标准，比如HTML、CSS和JavaScript。这种组件模型提供了更好的性能和更简洁的代码结构，非常适合需要高性能和现代Web开发经验的场景。 然后，我们有光环组件，这是Salesforce早期推出的一种组件模型。光环组件使用Aura框架，这个框架提供了一套丰富的API和事件处理机制，使得开发者可以构建复杂的用户界面和交互逻辑。光环组件虽然不如闪电Web组件那样现代化，但在Salesforce生态中仍然非常流行，尤其是在需要与Salesforce的旧系统集成时。 在本课程中，我们主要会学习如何构建自定义的光环组件。我们会从基础开始，逐步深入到更高级的主题，比如组件间的通信、事件处理等。课程的最后一天，我们会讨论闪电Web组件，并看看它们是如何与光环组件交互的。这样，你就能全面了解Salesforce中的组件开发，无论是使用传统的Aura框架还是现代的Web标准。 希望这能帮助你更好地理解Salesforce中的Lightning组件编程模型。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 5

  Using HTML5 and Lightning Components to Develop Apps

  第 54 页

  让我们来聊聊使用HTML5和Lightning组件开发应用程序的一些关键点。 首先，原生应用程序是为特定的设备平台开发的，比如iOS或Android。这意味着如果你想要在多个平台上运行你的应用，你可能需要为每个平台编写不同的代码。而HTML5应用程序则不同，它们使用相同的代码库就可以在多个设备和操作系统上运行。这大大简化了开发过程，因为你只需要维护一个代码库。 原生应用程序通常通过应用商店分发，比如苹果的App Store或谷歌的Play Store。而HTML5应用程序则可以通过用户的移动网络浏览器直接访问，不需要通过应用商店。这意味着用户可以更快地访问到你的应用，而不需要经历下载和安装的过程。 HTML5应用程序使用的是开源技术，这意味着开发成本可能会更低，因为你不必为使用这些技术支付许可费用。此外，由于HTML5应用程序是基于Web的，它们可以被搜索引擎“爬行”，这有助于提高应用的可见性和可发现性。 另一个优点是，HTML5应用程序可以在网络服务器上即时更新。这意味着你可以在不打扰用户的情况下更新应用，而不需要用户手动更新应用。这对于快速修复错误或添加新功能非常有用。 对于开发者来说，使用HTML5开发移动应用程序意味着他们可以利用现有的Web开发技能，而不需要学习新的编程语言，如Java或Objective-C。这可以加快开发速度，并降低学习曲线。 最后，基于HTML5的应用程序通常较少受到移动操作系统变化的影响。这意味着即使操作系统更新，你的应用程序也可能会继续正常工作，而不需要大量的修改。 总的来说，HTML5提供了一种灵活、成本效益高的方式来开发跨平台的移动应用程序，这对于需要快速响应市场变化的企业来说是一个非常有吸引力的选择。

  ▶ 播放视频 查看详情
• 6

  Single Page Architecture (SPA)

  第 55 页

  今天我们来聊聊单页面架构，也就是SPA。想象一下，你正在使用一个非常流畅的手机应用，每次你点击一个按钮或者滑动屏幕，页面内容就会立刻更新，而整个页面并没有重新加载。这就是SPA的魅力所在。 SPA，全称是Single Page Application，意思就是整个应用只有一个HTML页面。这个页面就像一个舞台，所有的表演——也就是内容的更新，都是通过JavaScript来控制的。JavaScript会动态地修改页面的内容，比如文字、图片或者布局，而不需要重新加载整个页面。 这样做的好处是什么呢？首先，它减少了页面加载的时间，因为只有需要更新的部分才会被重新加载。其次，它提高了应用的性能，因为减少了与服务器的通信次数。最后，它还支持离线使用，因为很多数据可以在第一次加载时就存储在本地。 在SPA中，数据通常是通过浏览器的Fetch API或者XMLHttpRequest对象来与服务器进行通信的。这些技术允许应用在不重新加载页面的情况下，从服务器获取数据或者发送数据。 总的来说，SPA提供了一种更加流畅和高效的用户体验，特别是在移动设备上。它让应用感觉更像是一个桌面应用，而不是一个网页。这就是为什么越来越多的开发者选择使用SPA来构建他们的HTML5移动应用程序。

  ▶ 播放视频 查看详情
• 7

  Understanding the Drawbacks of Developing with HTML5

  第 56 页

  让我们来聊聊使用HTML5开发时可能会遇到的一些小麻烦。首先，HTML5在处理动画和网络请求时，可能会遇到一些性能上的挑战。比如，动画可能不会像在本地应用中那样流畅，或者网络请求可能会有延迟，这可能会影响用户体验。 其次，HTML5应用可能无法直接访问某些本地设备的API。这意味着如果你想使用设备的摄像头、GPS或者其他硬件功能，可能会遇到一些限制。 再来说说浏览器兼容性问题。不同的浏览器，甚至同一浏览器的不同版本，可能会对HTML5的支持有所不同。这可能会导致你的应用在某些浏览器上表现良好，而在其他浏览器上却出现问题。 还有一个问题是，HTML5应用通常无法锁定设备的屏幕方向。这意味着用户可能会在横屏和竖屏之间切换，这可能会影响应用的布局和用户体验。 最后，随着HTML5标准的不断更新，新的API可能会出现，但并不是所有的浏览器都能及时支持这些新特性。这可能会导致你的应用在某些浏览器上无法使用最新的功能。 总的来说，虽然HTML5提供了跨平台开发的便利，但在性能、设备访问、浏览器兼容性和新特性支持方面，可能会遇到一些挑战。希望这些信息能帮助你更好地理解HTML5开发的潜在问题。

  ▶ 播放视频 查看详情
• 8

  Reviewing the Lightning Component Architecture

  第 57 页

  让我们来回顾一下Salesforce的Lightning组件体系结构，我会尽量用简单易懂的方式来解释。 首先，Salesforce Lightning应用程序就像是一个大盒子，这个盒子里装的是你应用的整体界面。你可以在这个盒子里使用一种叫做“标记”的东西来定义界面，并且可以调用Aura组件来构建更复杂的部分。 接下来，我们来说说APEX。APEX是一种编程语言，它有点像Java，但它是专门为Salesforce设计的。使用APEX，开发者可以在Salesforce的服务器上执行各种操作，比如处理数据、控制流程等。APEX还可以调用Salesforce提供的各种API，让开发者能够更灵活地操作数据。 然后，我们来看看AURA。AURA是Salesforce开发的一个开源框架，Lightning组件框架就是基于AURA构建的。所以，当你在使用Lightning组件时，可能会看到很多和AURA相关的东西。 APEX的语法和Java以及数据库存储过程很像，这让开发者可以很容易地为各种系统事件添加业务逻辑。比如，当用户点击一个按钮，或者更新一条记录时，APEX代码就可以被触发执行。 最后，你会创建Apex控制器。这个控制器的任务是把Salesforce平台上的数据和资源“打包”好，然后传递给Aura组件使用。这样，你的Aura组件就能获取到需要的数据，并在界面上展示出来。 简单来说，Salesforce Lightning应用程序是一个大盒子，APEX是处理数据和逻辑的工具，AURA是构建界面的框架，而Apex控制器则是连接数据和界面的桥梁。希望这个解释能帮助你更好地理解Salesforce的Lightning组件体系结构。

  ▶ 播放视频 查看详情
• 9

  Surfacing Aura Components

  第 58 页

  让我们来聊聊Salesforce的几个关键组件和功能，这样你可以更好地理解它们是如何工作的。 首先，Aura Components是Salesforce用来构建动态和响应式用户界面的框架。它们是在Lightning Experience中使用的，这是Salesforce在2016年冬季推出的新界面。Lightning Experience提供了一个更现代、更直观的用户体验，帮助用户更高效地完成任务。 Salesforce Mobile是一个可以从Apple App Store和Google Play下载的应用程序。它是一个HTML5/混合原生应用程序，意味着它结合了网页技术和原生应用的优势，让你在移动设备上也能享受到接近桌面版的体验。 Salesforce Classic是Lightning Experience之前使用的界面。虽然它现在看起来可能有点过时，但仍然有很多用户在使用它，特别是那些习惯于旧界面的用户。 Salesforce社区是一个品牌空间，允许你的员工、客户和合作伙伴连接和互动。你可以根据需要定制和创建社区，使得不同群体之间的过渡更加无缝。 Lightning Out是一个在2016年冬季推出的功能，它允许你在不属于Salesforce平台的网页中嵌入闪电组件。这意味着你可以在任何网页上使用Salesforce的强大功能，而且这些组件直接在网页的DOM中运行，自动处理跨域通信和环境初始化。 最后，Visualforce是Lightning的前身。它允许你在Salesforce平台上使用任何你喜欢的JavaScript框架来开发自定义应用程序。这些应用程序通常被放在IFRAME中，这意味着它们可以在Salesforce的页面中独立运行。 希望这些解释能帮助你更好地理解Salesforce的这些组件和功能。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 10

  Using Lightning and Visualforce

  第 59 页

  让我们来聊聊Salesforce中的Lightning和Visualforce这两个重要的技术。 首先，Visualforce是Salesforce早期提供的一种页面开发技术，它允许开发者使用类似于HTML的标记语言来创建自定义的用户界面。Visualforce页面通常嵌入在iframe中，这种方式虽然灵活，但确实会增加一些性能上的开销，尤其是在移动设备上。 而Lightning框架，是Salesforce为了提升性能，特别是在Salesforce 1移动应用上的性能而推出的。它采用了一种更现代化的前端技术，使得页面加载更快，用户体验更流畅。Lightning框架还支持组件化开发，这意味着你可以创建可重用的组件，这在开发大型应用时非常有用。 现在，Lightning已经成为Salesforce官方推荐的主要开发平台。它不仅在性能上有所提升，还提供了大量的第三方组件，这些组件可以帮助开发者更快地构建应用。 如果你已经熟悉Visualforce，那么学习Lightning会是一个很好的补充。你可以从Visualforce页面中调用Lightning组件，这样你就可以逐步迁移到Lightning，而不需要一次性重写所有的代码。 虽然Lightning是未来的趋势，但Salesforce仍然会长期支持Visualforce。实际上，Visualforce页面每个月都有数十亿的浏览量，这说明它仍然在很多场景下非常有用。 如果你已经在使用Visualforce结合一些前端框架（如Angular.js或jQuery Mobile）来开发单页应用（SPA），你可能会考虑是否需要转向Lightning。这取决于你的具体需求，比如你是否需要更好的性能，或者你是否希望利用Lightning提供的现代化组件和工具。 总之，无论是Visualforce还是Lightning，Salesforce都提供了强大的工具来帮助你构建高效、可扩展的应用。选择哪一种技术，取决于你的项目需求和你对技术的熟悉程度。希望这能帮助你更好地理解这两种技术，并做出最适合你和你客户的选择。

  ▶ 播放视频 查看详情
• 11

  Optimal Use Cases for Lightning Components

  第 60 页

  今天我们来聊聊Salesforce的Lightning组件，也就是我们常说的闪电设备。首先，闪电设备是一个非常强大的工具，它可以帮助我们为Salesforce Mobile开发自定义的单页面应用程序。这意味着你可以创建一个非常简洁、用户友好的界面，让用户在一个页面上就能完成所有操作，而不需要跳来跳去。 此外，闪电设备还允许业务用户通过一个非常直观的拖放界面来创建他们自己的自定义应用程序。这就像是玩乐高积木一样，你可以通过简单的拖放操作来构建你需要的功能，而不需要编写复杂的代码。 还有一点，闪电设备可以帮助我们开发那些通过标准Salesforce配置功能无法实现的自定义用户体验。这意味着如果你有一些特殊的需求，或者想要给用户提供一些独特的功能，闪电设备可以帮助你实现这些想法。 但是，使用闪电设备也有一些需要注意的地方。首先，不要用它来复制现有的Salesforce功能。因为Salesforce本身已经提供了很多强大的功能，如果你只是简单地复制这些功能，那么使用闪电设备就没有太大的意义了。 其次，不要开发与Lightning Experience或Salesforce移动设备完全不一致的自定义用户体验。因为这样会让用户感到困惑，他们可能会觉得你的应用和Salesforce的其他部分不协调，从而影响他们的使用体验。 最后，不要在没有仔细考虑工作水平和投资回报率的情况下，就重新实施现有的Visualforce应用程序。因为这样做可能会浪费大量的时间和资源，而且可能并不会带来预期的效果。 总之，闪电设备是一个非常强大的工具，但是我们在使用它的时候，一定要考虑清楚我们的需求和目标，这样才能发挥它的最大价值。

  ▶ 播放视频 查看详情
• 12

  Scenarios

  第 61 页

  让我们来聊聊这两个场景，看看是否应该使用Lightning Components。 ，场景61：客户A， 客户A设计了一个自定义对象，用来存储客户汽车的信息，比如品牌、型号、颜色、年份和购买价格。现在，客户A希望自定义数据输入表格的布局。 ，是否应该使用Lightning Components？， 对于客户A的需求，其实不一定需要使用Lightning Components。因为客户A的需求主要是自定义数据输入表格的布局，这可以通过Salesforce的标准功能来实现，比如使用“页面布局编辑器”或“记录类型”来调整字段的排列和显示方式。Lightning Components更适合用于创建复杂的、动态的用户界面，或者需要高度定制化的功能。如果客户A的需求只是简单的布局调整，使用标准功能就足够了，这样既简单又省时。 ，场景62：客户B， 客户B希望创建一个自定义应用程序，这个应用程序会出现在Lightning Experience内的自定义选项卡中。客户B的IT团队精通React.JS，但还没有Lightning组件框架的经验。这个应用程序主要由网格、搜索表格和一些动态生成的HTML组成。 ，是否应该使用Lightning Components开发应用程序？， 对于客户B的情况，使用Lightning Components可能是一个不错的选择。虽然客户B的IT团队目前没有Lightning组件框架的经验，但Lightning Components是基于现代Web技术（如HTML、CSS和JavaScript）构建的，与React.JS有一些相似之处。因此，IT团队可以相对容易地上手。 此外，Lightning Components是Salesforce原生支持的开发框架，能够很好地与Lightning Experience集成，提供一致的用户体验。如果客户B希望应用程序能够无缝融入Salesforce环境，并且未来可能需要扩展或与其他Salesforce功能集成，那么使用Lightning Components会是一个更合适的选择。 当然，如果客户B的应用程序功能相对简单，且IT团队更倾向于使用他们熟悉的React.JS，也可以考虑使用React.JS开发，然后通过Lightning Container组件嵌入到Salesforce中。不过，这种方式可能会增加一些复杂性，尤其是在与Salesforce数据交互时。 总结一下： - 客户A的需求可以通过标准功能实现，不一定需要Lightning Components。 - 客户B的需求更适合使用Lightning Components，尤其是考虑到未来的扩展和集成需求。 希望这些解释对你有帮助！如果有更多问题，随时问我哦！

  ▶ 播放视频 查看详情
• 13

  Scenarios (Continued)

  第 62 页

  让我们来聊聊客户C的需求，以及他们是否应该使用Lightning Components来开发这个自定义报告仪表板。 首先，客户C想要的是一个响应式布局的仪表板，这意味着它需要在不同的设备上都能很好地显示，无论是桌面电脑、平板还是手机。他们还希望这个仪表板可以通过Lightning Experience中的自定义选项卡和Salesforce Mobile访问，这基本上涵盖了Salesforce的主要用户界面。 现在，他们想要在仪表板中包含一些复杂的可视化效果，这些效果目前无法通过Salesforce的基础闪电组件来实现。他们考虑使用D3.js库来实现这些复杂的可视化。D3.js是一个非常强大的JavaScript库，专门用于创建复杂的数据驱动文档和可视化效果。 那么，客户C是否应该使用Lightning Components来开发这个应用程序呢？答案是：是的，他们应该使用Lightning Components。 为什么呢？因为Lightning Components是Salesforce的现代UI框架，专门为构建响应式、高性能的应用程序而设计。它能够很好地与Salesforce的生态系统集成，包括Lightning Experience和Salesforce Mobile。使用Lightning Components，客户C可以轻松地创建自定义的、响应式的用户界面，并且可以确保这些界面在不同的设备上都能良好地工作。 此外，虽然Salesforce的基础闪电组件可能无法满足客户C对复杂可视化的需求，但Lightning Components框架是高度可扩展的。客户C可以轻松地将D3.js库集成到他们的Lightning Components中，从而创建出他们所需的复杂可视化效果。 总结一下，客户C应该使用Lightning Components来开发他们的自定义报告仪表板。这样，他们不仅可以实现响应式布局和跨平台访问，还可以利用D3.js库来创建复杂的可视化效果，满足他们的所有需求。

  ▶ 播放视频 查看详情
• 14

  Reviewing OOTB Aura Components

  第 63 页

  让我们来回顾一下自2019年春季以来，Salesforce中Aura组件的一些新内容。首先，我们需要明确一点：Aura组件和Lightning Web组件（LWC）是Salesforce中两种不同的技术。Aura组件是Salesforce较早推出的前端开发框架，而Lightning Web组件则是基于现代Web标准构建的，更轻量级且性能更好。 从2019年春季开始，Salesforce在Aura组件方面并没有太多重大的更新，因为Salesforce的开发重点已经逐渐转向了Lightning Web组件。不过，Aura组件仍然在Salesforce生态系统中扮演着重要角色，特别是在一些旧的项目或应用中。 如果你想查看你的Salesforce实例中已经安装的所有组件的文档，你可以访问这个链接：https://.lightning.force.com/docs/component-library。这里的是你自定义的Salesforce域名。在这个组件库中，你可以找到很多常见的UI组件，它们都属于UI命名空间。 在这个文档中，你会看到每个组件的详细信息，包括： 1. ，组件概述，：告诉你这个组件是做什么的，以及如何在你的应用中实例化它。 2. ，组件源代码，：包括组件的标记（HTML）、客户端JavaScript控制器、以及CSS文件。 3. ，工作示例，：你可以直接看到这个组件在实际应用中的效果。 不过需要注意的是，对于“开箱即用”的组件（也就是Salesforce自带的组件）和托管组件，文档中只会显示三个选项卡： 1. ，使用，：告诉你如何使用这个组件。 2. ，规范，：列出组件的属性和方法。 3. ，文件，：提供组件的相关文档。 总的来说，虽然Aura组件的更新不多，但它仍然是Salesforce开发中不可或缺的一部分。如果你还在使用Aura组件，记得定期查看组件库，确保你使用的是最新的功能和最佳实践。

  ▶ 播放视频 查看详情
• 15

  Access the Component Library from Developer Console

  第 64 页

  今天我们来聊聊如何在Salesforce的开发控制台中快速访问组件库。这个功能对于开发者来说非常有用，因为它能帮助我们快速查找和使用各种组件，提高开发效率。 首先，打开你的Salesforce开发控制台。你可以通过点击右上角的齿轮图标，然后选择“开发者控制台”来进入。 进入开发控制台后，你会看到顶部有一个菜单栏。在这个菜单栏中，找到并点击“文件”选项。在下拉菜单中，你会看到一个叫做“组件库”的选项。点击它，就可以直接访问组件库了。 组件库里有很多预定义的组件，比如按钮、表格、输入框等等。你可以直接拖拽这些组件到你的页面上，然后进行自定义设置。这样，你就不用从头开始编写代码了，省时又省力。 另外，如果你经常使用某个组件，可以把它添加到你的收藏夹中。这样下次再使用时，就能更快地找到它。 总之，通过开发控制台访问组件库是一个非常方便的功能，能大大提升你的开发效率。希望这个小技巧对你有帮助！

  ▶ 播放视频 查看详情
• 16

  Using Namespaces

  第 65 页

  让我们来聊聊Salesforce中的命名空间。想象一下，命名空间就像是一个文件夹，它帮助我们把相关的组件组织在一起。这样，当我们需要使用某个组件时，就可以通过这个“文件夹”快速找到它。 如果你所在的开发组织设置了命名空间前置，那么你就需要使用这个特定的命名空间来访问你的组件。如果没有设置，那么你可以使用默认的命名空间，也就是“c”来访问组件。 这里有个小提示：自定义的命名空间只能在开发者版的组织中创建。这意味着，如果你想要一个特别的命名空间，你需要在这个特定的环境中进行设置。 现在，假设你有一个组件叫做“helloWorld”，它位于“docsample”这个命名空间里。如果另一个组件想要使用它，就可以通过添加``这样的标记来引用它。 在你的组织中，你可以选择是否设置命名空间前置。如果你设置了，那么这个命名空间将会用于你所有的Lightning组件。特别是如果你打算在AppExchange上提供托管包，那么设置命名空间前置就是必须的。 最后，值得一提的是，在Lightning框架的早期版本中，确实要求为自定义组件定义命名空间。但是，这个限制现在已经取消了，给了开发者更多的灵活性。 希望这个解释能帮助你更好地理解Salesforce中的命名空间。如果你有任何问题，随时欢迎提问！

  ▶ 播放视频 查看详情
• 17

  Namespaces

  第 66 页

  今天我们来聊聊Salesforce中的一些关键组件和它们的功能。首先，我们来看“搜索速度66”，这其实是一个比喻，用来形容Salesforce中搜索功能的快速和高效。Salesforce的搜索功能非常强大，可以帮助用户迅速找到他们需要的信息。 接下来是“aura”，这是一个高级输出标签，用于在Salesforce中创建动态和交互式的用户界面。它允许开发者构建复杂的UI组件，这些组件可以在不同的设备和平台上运行。 “force”组件是特定于Salesforce的，主要用于处理数据。这些组件可以帮助开发者轻松地与Salesforce的数据模型进行交互，执行数据操作如查询、插入、更新和删除。 “forceChatter”组件用于将Chatter，也就是Salesforce的社交功能，集成到自定义应用程序中。这样，用户可以在应用程序内部直接进行社交互动，如发布消息、评论和点赞。 “forceCommunity”是一个抽象组件，用于加载菜单数据并处理导航。它帮助开发者在Salesforce社区中创建一致和用户友好的导航体验。 “闪电”组件，也就是Lightning组件，是Salesforce提供的一套用户体验组件。它们旨在提供现代化的、响应式的用户界面，提升用户的操作体验。 “ltng”标签用于加载JavaScript和CSS，这对于自定义Lightning组件的样式和行为非常重要。 “ui”组件包括输入和输出组件，这些是构建用户界面的基础元素，如按钮、输入框、下拉菜单等。 最后是“wave”组件，特别是“wave:waveDashboard”组件，它用于将Salesforce Analytics云仪表板添加到Salesforce Experience（SFX）页面。这使得用户可以直接在Salesforce平台上查看和分析数据。 这些组件和功能共同构成了Salesforce强大的生态系统，帮助企业和开发者构建高效、用户友好的应用程序。希望这些信息对你们理解Salesforce有所帮助！

  ▶ 播放视频 查看详情
• 18

  Review the out-of-the-box Aura Components.

  第 67 页

  同学们，今天我们来做一个简单的练习，叫做“查看开箱即用的Aura附件”。这个练习的目标是让大家熟悉一下Salesforce中那些现成的、可以直接使用的Aura组件。这些组件是Salesforce已经为我们准备好的，不需要我们从头开始编写代码，所以非常方便。 首先，我们需要知道什么是Aura组件。Aura组件是Salesforce提供的一种用户界面元素，可以用来构建自定义的应用程序界面。它们是基于Aura框架的，这个框架是Salesforce用来开发动态、响应式用户界面的工具。 现在，我们来做练习2-1，叫做“审查可用组件”。这个练习的目的是让大家查看一下Salesforce中已经有哪些Aura组件可以直接使用。我们只需要花10分钟的时间，就可以对这些组件有一个基本的了解。 首先，打开Salesforce的开发人员控制台。在控制台中，你可以找到一个叫做“组件库”的地方。这里列出了所有可用的Aura组件。你可以浏览这些组件，看看它们的功能和用途。 比如，你可以找到一个叫做“lightning:button”的组件，这是一个按钮组件，你可以直接在你的应用程序中使用它来创建一个按钮。还有“lightning:input”组件，这是一个输入框组件，可以用来收集用户的输入信息。 通过浏览这些组件，你可以快速了解Salesforce提供了哪些现成的工具，这样在开发应用程序时，你就可以直接使用这些组件，而不需要从头开始编写代码。 好了，这就是今天的练习。希望大家通过这10分钟的浏览，能够对Salesforce的Aura组件有一个初步的了解。下次我们会继续深入探讨如何使用这些组件来构建更复杂的应用程序界面。谢谢大家！

  ▶ 播放视频 查看详情
• 19

  Unit 2: Getting Started - 68

  第 68 页

  大家好，欢迎来到第2单元的学习。今天我们要一起探索如何利用HTML5和Salesforce的Lightning组件来开发功能强大的移动应用程序。首先，我们会简单回顾一下HTML5应用程序的一些基本特征、功能以及它的一些限制。这有助于我们更好地理解在Salesforce平台上开发应用时，HTML5能为我们带来什么。 接下来，我们会深入Aura Components和Apex的使用。Aura Components是Salesforce提供的一种强大的UI框架，它可以帮助我们快速构建响应式的用户界面。而Apex则是Salesforce的编程语言，用于编写业务逻辑和数据库操作。我们将学习如何结合这两者，按照最佳实践来开发应用程序。 在课程中，我们还会学习如何使用CSS来为组件添加主题，让应用界面更加美观。同时，我们也会学习如何定义和操作组件的属性，以及如何处理系统和用户事件。这些技能对于开发交互式的应用程序至关重要。 当然，开发过程中难免会遇到问题，所以我们也会学习一些调试和故障排除的技巧，帮助你快速定位并解决问题。 最后，我们会探讨如何与Apex合作，使用基本的Aura组件，以及如何提出和处理事件。我们还会学习使用Lightning数据服务进行CRUD（创建、读取、更新、删除）操作，这是管理数据的基础。 整个单元的内容非常丰富，但不用担心，我们会一步步来，确保你能够跟上并掌握这些知识。准备好了吗？让我们一起开始这段精彩的学习之旅吧！

  ▶ 播放视频 查看详情
• 20

  Topics - 69

  第 69 页

  同学们，今天我们来聊聊如何在Aura Components的CM文件中使用HTML标记，以及如何重新启动Aura组件。这个话题听起来可能有点技术性，但别担心，我会用简单的方式来解释。 首先，Aura Components是Salesforce中用于构建用户界面的框架。在CM文件中，你可以使用HTML标记来定义组件的结构和样式。这就像是在网页中使用HTML一样，你可以创建按钮、输入框、列表等元素。 接下来，如果你需要重新启动Aura组件，你可以通过几种方式来实现。比如，你可以使用Salesforce提供的开发人员控制台，这是一个强大的工具，可以帮助你调试和测试你的组件。你还可以使用Lightning应用程序构建器，这是一个可视化的工具，让你可以通过拖放的方式来构建和修改你的组件。 此外，Salesforce还提供了架构构建器，这可以帮助你更好地理解和管理你的组件结构。如果你想要在移动设备上测试你的组件，你可以使用桌面浏览器来模拟Salesforce Mobile环境。 最后，别忘了在开始之前，花点时间在学生指南中找到相关的幻灯片，这些幻灯片会帮助你更好地理解今天的内容。 好了，这就是今天的内容。希望你们能够理解并掌握如何在Aura Components中使用HTML标记，以及如何重新启动组件。如果有任何问题，随时提问。我们下次再见！

  ▶ 播放视频 查看详情
• 21

  Getting Started with Lightning Development

  第 70 页

  今天我们来聊聊Salesforce的Lightning Development入门中的一个实用小技巧——如何启用调试模式。这个功能对于开发人员来说非常有用，尤其是在解决代码运行时的问题时。 首先，我们知道Lightning框架默认会压缩和缩小JavaScript代码。这意味着，当你查看代码时，函数名称和代码结构可能会变得难以辨认，这给调试带来了不小的挑战。 但是，Salesforce提供了一个叫做“收件箱模式”的功能，启用这个模式后，JavaScript的压缩和缩小功能就会被禁用。这样，你就可以在浏览器的开发人员工具中更清晰地看到代码，更容易地找到并解决问题。 那么，如何启用这个调试模式呢？步骤其实很简单： 1. 首先，点击页面右上角的个人资料图标。 2. 接着，点击“设置”。 3. 然后，找到并点击“高级用户详细信息”，再点击“编辑”。这里注意，编辑按钮可能不会直接显示，需要你稍微滚动一下页面。 4. 在弹出的选项中，你会看到一个“收件箱模式”的复选框，勾选它。 5. 最后，别忘了点击“保存”来应用你的更改。 这样，你就成功启用了调试模式，可以更轻松地进行代码调试了。希望这个小技巧能帮助你在Salesforce的开发工作中更加得心应手！

  ▶ 播放视频 查看详情
• 22

  Aura Component Bundle

  第 71 页

  让我们来聊聊Aura组件包里的各种资源。想象一下，Aura组件包就像是一个小工具箱，里面装满了各种工具，每个工具都有它独特的用途。 首先，我们有一个必不可少的工具，那就是组件或应用程序文件，通常以.cmp或.app结尾。这个文件就像是工具箱里的主工具，没有它，整个工具箱就失去了意义。它包含了组件或应用程序的基本结构和标记。 接下来是控制器，这是一个.js文件。你可以把它想象成工具箱里的一个智能助手，它负责处理组件中发生的事件。比如，当用户点击一个按钮时，控制器就会跳出来，执行相应的操作。 然后我们还有Helper，这也是一个.js文件。Helper就像是一个多面手，它可以在任何需要的时候被调用，帮助完成各种JavaScript任务。 样式文件，也就是.css文件，就像是工具箱里的装饰工具。它负责给组件穿上漂亮的衣服，让组件看起来更加美观。而且，这些样式是被封装起来的，不会和其他组件的样式打架。 文档文件，.auradoc文件，就像是工具箱里的说明书。它详细描述了组件的功能，提供了示例代码，帮助你更好地理解和使用这个组件。 渲染器，.js文件，是一个高级工具。它允许你自定义组件的显示方式，覆盖默认的渲染行为。 设计文件，.Design文件，是专门为Lightning App Builder或Lightning页面设计的。它确保组件在这些环境中能够正常工作。 最后，我们还有SVG文件，这是为Lightning App Builder中的组件提供自定义图标的。它就像是工具箱里的标签，让你的组件在众多组件中脱颖而出。 所以，Aura组件包里的每个资源都有其独特的作用，它们协同工作，共同构建出功能强大、外观精美的组件。希望这个比喻能帮助你更好地理解Aura组件包的构成！

  ▶ 播放视频 查看详情
• 23

  Defining an Aura Component in Developer Console

  第 72 页

  今天我们来聊聊如何在Salesforce的开发者控制台中定义Aura组件。这个过程其实很简单，就像你在电脑上创建一个新文件一样。 首先，打开你的开发者控制台。在这里，你可以通过选择“文件”菜单，然后点击“新建”，接着选择“Lightning组件”来创建一个新的Aura组件。这个操作就像你在Word文档中点击“新建”来开始一个新文档一样简单。 当你创建了这个组件后，系统会自动为你添加一些基本的配置选项。这些配置选项会出现在你的组件标签中，也就是标签里。这些配置让组件能够在Salesforce.com的不同区域中显示和使用。 举个例子，如果你勾选了“Lightning Page”这个复选框，那么你的组件就可以在Lightning App Builder中被使用了。这就像是给你的组件一个通行证，让它可以在Salesforce的页面上自由展示。 这些内容在我们即将学习的DEX 601课程的第3单元中会有更详细的讲解。到时候，我们会一起深入探讨这些配置选项的具体用途和如何更有效地使用它们来增强你的Salesforce应用。 希望今天的讲解能帮助你更好地理解如何在Salesforce中创建和配置Aura组件。如果有任何疑问，随时欢迎提问！

  ▶ 播放视频 查看详情
• 24

  Defining an Aura Component in VS Code

  第 73 页

  同学们，今天我们来学习如何在VS Code 73中定义Aura组件。这个过程其实很简单，跟着我一步步来就可以了。 首先，打开你的VS Code 73。在左侧的“资源管理器”中，找到你的项目文件夹。然后，右键点击“aura”文件夹，选择“SFDX：创建Lightning组件”这个选项。 接下来，系统会提示你输入组件的名称。你只需要输入你想要的组件名称，比如“MyComponent”，然后按下回车键。VS Code会自动为你生成一个组件捆绑包，里面包含了这个Aura组件所需的所有资源文件，比如控制器、帮助器、样式表等等。 这样，你就成功地在VS Code 73中定义了一个Aura组件。是不是很简单呢？接下来，你就可以在这个组件的基础上进行开发了。希望这个讲解对你有帮助，如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 25

  Defining an Aura Component

  第 74 页

  让我们来聊聊Aura组件的基本概念。Aura组件是Salesforce中用于构建用户界面的基本单元。每个Aura组件都包含一个以`.cmp`为后缀的文件，这个文件里定义了组件的结构和行为。 首先，每个Aura组件都必须被包裹在``标签中。这个标签就像是组件的容器，告诉Salesforce这是一个Aura组件。在这个容器里，你可以添加文本、HTML元素，或者引用其他组件。 举个例子，如果你想创建一个简单的“Hello World”组件，代码可能会是这样的： ```html <h1>Hello World!</h1> ``` 在这个例子中，``标签包裹了一个`<h1>`标签，里面写着“Hello World!”。当这个组件被渲染到页面上时，用户就会看到一个大大的“Hello World!”标题。 除了显示文本，Aura组件还可以包含其他组件，甚至可以定义一些元数据，比如组件的描述、版本信息等。这些元数据可以帮助开发者更好地理解和管理组件。 总之，Aura组件是构建Salesforce应用的基础，通过组合和嵌套这些组件，你可以创建出功能丰富、交互性强的用户界面。希望这个简单的解释能帮助你理解Aura组件的基本概念！</h1>

  ▶ 播放视频 查看详情
• 26

  Using HTML Markup in Apps and Components

  第 75 页

  让我们来聊聊在Salesforce中使用HTML标记框架的一些重要点。首先，想象一下，每个HTML标签在Salesforce中都被当作一个独立的组件来对待。这意味着，无论是简单的段落标签<p>，还是更复杂的结构，它们都享有与其他Salesforce组件相同的权利和特权。这就像是在一个大家庭中，每个成员都受到平等的尊重和对待。 但是，这里有一个小细节需要注意：在使用这些HTML标签时，我们必须严格遵守HTML的标准。比如，如果你想要插入一个换行，你应该使用<br>而不是<br>。这就像是遵守交通规则，确保一切运行顺畅，避免不必要的麻烦。 此外，这个框架并不支持所有HTML标签。在幻灯片中列出的那些标签，可能在这个框架中就无法使用。这就像是在一个特定的俱乐部里，只有符合特定条件的成员才能进入。 在设计这些组件时，我们特别考虑到了无障碍性。这意味着，无论是视力障碍的用户，还是使用辅助技术的用户，都能轻松使用你的应用程序。这就像是在设计一个公共空间时，确保每个人都能方便地进出和使用。 当你开始构建更复杂的组件时，你会发现有一些现成的、开箱即用的组件可以大大简化你的工作。这些组件已经为你处理了很多底层的细节，让你可以专注于更重要的部分。这就像是使用预制件来建造房子，既快速又可靠。 最后，这些组件会自动使用Salesforce Lightning设计系统的主题。这意味着，你的应用程序不仅功能强大，而且外观也会与Salesforce的其他部分保持一致，给用户带来一致的体验。这就像是在一个品牌连锁店中，无论你走进哪一家，都能感受到相同的风格和服务。 希望这些信息能帮助你更好地理解和使用Salesforce中的HTML标记框架。如果你有任何问题，随时提问！</p>

  ▶ 播放视频 查看详情
• 27

  Invoking Aura Components from a CMP File

  第 76 页

  让我们来聊聊如何在Salesforce中创建一个Aura组件，并且如何从CMP文件中重新启动它。 首先，Aura组件是Salesforce中用来构建用户界面的基本单元。每个Aura组件都有一个以`.cmp`为后缀的文件，这个文件包含了组件的定义和结构。在这个文件中，所有的内容都必须被包裹在``标签内。这个标签就像是组件的容器，告诉Salesforce：“嘿，这里开始是一个组件了！” 在这个容器里，你可以放入文本、HTML元素，甚至是其他组件。比如，如果你想显示一个简单的“你好世界”消息，你可以这样写： ```html <div>你好世界</div> ``` 这里，`<div>`标签用来创建一个简单的HTML元素，里面写着“你好世界”。 如果你想在组件中使用Salesforce的标准组件，比如Chatter的新闻源，你可以这样写： ```html <div>抖音</div> ``` 这里，``是Salesforce提供的一个标准组件，用来显示Chatter的新闻源。 如果你有自己的自定义组件，比如一个叫做`MyCustomComponent`的组件，你也可以在Aura组件中引用它。引用时，需要使用`c:`命名空间，像这样： ```html <div>自定义组件</div> ``` 这里，``就是对你自定义组件的引用。 总结一下，Aura组件是Salesforce中构建用户界面的基础。每个组件都有一个`.cmp`文件，里面包含了组件的定义和结构。你可以在这个文件中放入文本、HTML元素，甚至是其他组件。通过使用``标签，你可以轻松地创建和管理你的Aura组件。 希望这个解释对你有帮助！如果你有任何问题，随时问我哦！</div>

  ▶ 播放视频 查看详情
• 28

  Using Available Tooling

  第 77 页

  今天我们来聊聊如何在Salesforce平台上使用各种工具来创建基于Lightning的应用程序。Lightning是Salesforce的一个现代化用户界面框架，它让开发更加直观和高效。 首先，我们有，开发者控制台，。这是一个内置的工具，可以帮助你编写和调试Aura组件和Apex代码。它提供了代码提示和验证功能，让你在编写代码时更加得心应手。此外，你还可以在这里进行单元测试和调试，确保你的代码运行无误。 接下来是，Salesforce代码扩展，，这是基于Visual Studio Code编辑器的。这个扩展包非常适合那些喜欢使用VS Code的开发者。它支持Salesforce DX、Apex、Aura组件和Visualforce的开发。通过这个工具，你可以轻松地管理你的Salesforce项目，并且它还提供了一个架构生成器，帮助你设计和查看自定义对象之间的关系。 如果你不是开发者，或者你更喜欢可视化操作，那么，App Builder，就是你的好帮手。这个工具允许你通过拖放的方式，将现成的和自定义的Lightning组件组合在一起，快速构建出漂亮的应用程序。它非常适合那些没有编程背景的用户。 除了Salesforce自带的工具，还有一些第三方的开发环境也支持Lightning开发。比如，Sublime Text 3，，这是一个轻量级的文本编辑器，通过安装一个Lightning扩展，你就可以在这里编写Lightning代码。 ，Cloud 9，是一个基于云的集成开发环境（IDE），它支持Lightning组件，并且提供了许多企业级的功能，非常适合团队协作开发。 ，Lightning云，是另一个强大的工具，它托管在JetBrains IntelliJ IDEA IDE中。无论你使用的是社区版还是旗舰版，都可以利用这个工具进行Salesforce平台的开发。 最后，我们还有，WELKIN Suite TWS，，这是一个新一代的Salesforce平台IDE。它支持Apex、Visualforce、HTML、CSS、JavaScript等多种技术，并且可以执行单元测试、SOQL查询等操作。这个工具集成了许多方便的功能，让你在一个环境中就能完成大部分开发工作。 总之，无论你是开发者还是非开发者，Salesforce都提供了丰富的工具来帮助你创建基于Lightning的应用程序。选择适合你的工具，开始你的开发之旅吧！

  ▶ 播放视频 查看详情
• 29

  Using the Developer Console

  第 78 页

  让我们来聊聊Salesforce的开发人员控制台，这是一个非常强大的工具，可以帮助开发者更好地理解和调试他们的代码。 首先，开发人员控制台有几个主要的面板，每个都有其独特的功能： 1. ，日志面板，：这里你可以查看所有的日志列表，并且可以在日志检查器中打开它们。日志检查器非常有用，因为它可以显示操作的来源、触发操作的内容以及之后发生的事情。这对于排查数据库事件、APEX处理、工作流程和验证逻辑的问题特别有帮助。 2. ，测试面板，：在这个面板中，你可以选择和运行Apex测试类，包括单元测试、功能测试和回归测试。同时，它还会显示你组织中每个类的代码覆盖率百分比。你还可以在源代码编辑器中查看这些类的代码覆盖率。 3. ，检查点，：这是一个非常有用的功能，允许你设置和查看检查点，以帮助你确定Apex代码中的错误来源。 4. ，查询编辑器，：这里你可以编辑和执行Salesforce对象查询语言(SOQL)和Salesforce对象搜索语言(SOSL)查询。这对于从数据库中检索数据非常有用。 5. ，查看状态，：这个功能允许你检查Visualforce页的查看状态，帮助你理解页面是如何渲染的。 6. ，进度面板，：实时显示开发人员控制台发出的所有异步请求的状态。这对于监控长时间运行的操作非常有用。 7. ，问题面板，：在源代码编辑器中显示Apex服务器端控制器的编译错误的详细信息。当你编辑代码时，任何错误都会在包含错误的行旁边显示错误指示器。你可以点击“问题”选项卡中的一行，直接跳转到导致错误的代码行。 通过这些工具，开发人员可以更有效地编写、测试和调试他们的Salesforce应用程序。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 30

  Opening Lightning Resources in Developer Console

  第 79 页

  同学们，今天我们来聊聊如何在Salesforce的开发者控制台中打开Lightning资源。这个过程其实很简单，跟着我一步步来，你很快就能掌握。 首先，打开你的开发者控制台。然后，在顶部菜单栏找到“文件”选项，点击它，你会看到一个下拉菜单。在这个菜单中，选择“打开Lightning资源”，或者你可以直接使用快捷键Alt + A，这样会更快一些。 当你选择了“打开Lightning资源”后，屏幕上会弹出一个对话框，这个对话框会列出所有可用的Lightning资源。你可以在这里浏览，找到你需要编辑或查看的资源。 找到你想要的资源后，你可以点击它，然后点击对话框下方的“打开选定”按钮。这样，这个资源就会作为一个新的标签页在开发者控制台中打开，你就可以开始编辑了。 如果你需要同时打开多个资源，这里有个小技巧：你可以双击多个资源，它们会同时打开。而且，这些资源在编辑器中的标签页顺序，会和你从对话框中选择它们的顺序一致，这样你就能更方便地管理和切换不同的资源了。 好了，这就是如何在开发者控制台中打开Lightning资源的全部步骤。希望你们都能轻松掌握，如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 31

  Automatically Formatting your Code

  第 80 页

  同学们，今天我们来聊聊如何在编程时自动初始化代码。这个功能非常实用，尤其是当你需要快速设置代码结构时。 首先，你需要选中你想要初始化的代码。选中之后，你可以使用快捷键Alt + Tab来快速切换并应用初始化。如果你不太习惯用快捷键，也可以从编辑菜单中找到相应的选项来执行这个操作。 这样，你的代码就会自动按照预设的格式进行初始化，节省了你手动调整的时间。是不是很方便呢？试试看吧！

  ▶ 播放视频 查看详情
• 32

  Using Lightning App Builder

  第 81 页

  今天我们来聊聊Salesforce中的Lightning App Builder。想象一下，如果你有一盒乐高积木，你可以随意组合，创造出任何你想要的东西。Lightning App Builder就像是Salesforce世界里的那盒乐高积木，它让你能够轻松地构建和自定义页面，而不需要编写复杂的代码。 首先，Lightning App Builder是一个拖放式的工具，这意味着你只需要用鼠标点击、拖动，就可以把各种组件放到页面上。这对于那些不太懂技术的用户来说，简直是个福音。你可以用它来为Lightning Experience和Salesforce移动版创建单页面的应用程序，也可以自定义你的主页和记录页面。 Lightning Pages是介于传统的页面布局和Visualforce页面之间的一个中间地带。它们比页面布局更灵活，但又不像Visualforce页面那样需要深入的编程知识。在Lightning Pages中，你可以添加各种Lightning组件，这些组件比传统的字段或Visualforce组件更加灵活和强大。 总的来说，Lightning App Builder让Salesforce的自定义变得更加简单和直观，即使你不是一个技术高手，也能轻松上手，打造出符合你业务需求的页面。

  ▶ 播放视频 查看详情
• 33

  Using the Schema Builder

  第 82 页

  今天我们来聊聊Salesforce中的架构构建器。想象一下，架构构建器就像是一个沙盒，让你可以轻松地看到和调整你的应用程序中的所有对象和它们之间的关系。这就像是在玩拼图，你可以通过拖放来移动和添加新的拼图块，也就是自定义对象、字段和关系。 当你移动这些拼图块时，架构构建器会自动帮你保存这些变化，这样你就不用担心会丢失任何重要的布局信息。而且，它还会告诉你每个字段的值、哪些字段是必须填写的，以及如何通过查找和主从关系来连接不同的对象。 你可以看到所有的标准对象和自定义对象的字段和关系，就像是在看一张详细的地图。要开始使用架构构建器，你只需要点击“设置”，然后选择“架构生成器”就可以了。 简单来说，架构构建器就是一个让你轻松管理和调整你的Salesforce数据模型的工具，让复杂的数据结构变得一目了然。

  ▶ 播放视频 查看详情
• 34

  Using your Browser to Test a Component in Salesforce Mobile

  第 83 页

  同学们，今天我们来聊聊如何在Salesforce Mobile中测试Lightning组件。这个过程其实挺简单的，我们只需要用到Google Chrome浏览器的一些开发工具。 首先，打开你的Google Chrome浏览器。然后，找到并打开“开发人员工具”。这个工具通常在浏览器的右上角，你可以通过点击三个小点的菜单找到它，或者直接按快捷键Ctrl+Shift+I（在Windows上）或Cmd+Option+I（在Mac上）。 打开开发人员工具后，你会看到一个选项叫做“移动模拟”。点击这个选项，你的浏览器就会模拟一个移动设备的屏幕。这样，你就可以看到你的Lightning应用在移动设备上会是什么样子了。 接下来，你需要重新加载Lightning Experience。当你这样做的时候，Salesforce会自动识别到你在使用移动模拟，并且会激活Salesforce移动图形用户界面。这是因为你的浏览器会被重定向到一个特定的URL，通常是http://[yourzone]/one/one.app。 这样，你就可以在模拟的移动环境中测试你的Lightning组件了。这个过程不仅简单，而且非常实用，可以帮助你确保你的应用在移动设备上的表现和功能都符合预期。 希望这个小技巧对你们有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 35

  Generating a Password to Allow Login via the Salesforce App

  第 84 页

  今天我们来聊聊如何在Salesforce中生成允许登录的密码。首先，我们需要知道，当你创建一个新的scratch org时，默认情况下，你的用户是没有设置密码的。这意味着你不能直接登录到这个环境中。那么，我们该怎么办呢？ 这里有一个非常方便的命令可以帮助我们解决这个问题。你可以使用Salesforce的命令行工具，也就是我们常说的CLI，来生成一个密码。具体命令是这样的： ```bash sfdx force:user:password:generate ``` 当你运行这个命令后，系统会为你的用户生成一个密码。比如说，如果你的用户名是`test@example.com`，那么系统可能会生成一个像`_3mafV3cqb`这样的密码。这个密码就是你可以用来登录Salesforce应用程序的凭证。 接下来，如果你是在Salesforce应用程序中操作，你需要确保选择的是Sandbox作为你的连接环境。这是因为Sandbox环境是用来测试和开发的，它和正式的生产环境是分开的。 如果你是在网页上操作，那么你需要登录到`test.salesforce.com`，而不是我们通常使用的`login.salesforce.com`。这是因为`test.salesforce.com`是专门用于测试环境的登录页面。 总结一下，通过使用`sfdx force:user:password:generate`命令，你可以轻松地为你的scratch org用户生成一个密码，然后根据你是在应用程序中还是在网页上操作，选择正确的连接方式或登录页面。这样，你就可以顺利登录到你的Salesforce环境中了。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 36

  Unit 2: Getting Started - 86

  第 86 页

  同学们，今天我们来聊聊第2单元的内容。这一单元主要是关于如何使用HTML5和Lightning组件来开发Salesforce的移动应用程序。听起来是不是有点技术性？别担心，我会用简单的话来解释。 首先，我们会看看HTML5应用程序的一些特点、功能和限制。HTML5是一种非常流行的网页技术，它让网页更加动态和互动。然后，我们会学习如何使用Aura Components和Apex来开发应用程序。Aura Components是Salesforce提供的一种强大的工具，可以帮助我们快速构建用户界面。而Apex是Salesforce的一种编程语言，用来处理业务逻辑。 接下来，我们会学习如何使用CSS来给组件设置主题。CSS是用来控制网页样式的语言，通过它，我们可以让应用程序看起来更漂亮。Salesforce还提供了一套叫做Salesforce Lightning Design System（SLDS）的预定义样式，使用这些样式可以让我们的应用程序看起来和Salesforce的其他部分保持一致。 我们还会学习如何定义和操作组件的属性，以及如何处理系统和用户的事件。这些都是开发应用程序时非常重要的技能。 最后，我们会学习如何调试和排除应用程序中的问题。开发过程中难免会遇到一些问题，学会如何快速找到并解决问题是非常重要的。 总之，这一单元的内容非常丰富，但别担心，我们会一步步来，确保每个人都能跟上。准备好了吗？让我们开始吧！

  ▶ 播放视频 查看详情
• 37

  Topics - 87

  第 87 页

  同学们，今天我们来聊聊Salesforce Lightning设计系统，简称SLDS。这个系统是Salesforce提供的一套设计指南和组件库，帮助开发者快速构建与Salesforce Lightning体验一致的用户界面。 首先，我们来看看如何加载SLDS。你只需要在你的项目中引入SLDS的CSS文件，就可以开始使用它提供的样式和组件了。这个过程非常简单，就像给你的网页穿上一件新衣服一样。 接下来，我们要审查SLDS的组件蓝图。这些蓝图详细描述了每个组件的结构和样式，帮助你理解如何正确地使用它们。你可以把这些蓝图看作是建筑图纸，指导你如何搭建一个既美观又功能强大的界面。 然后，我们会应用SLDS课程中的知识。这些课程会教你如何将SLDS的组件和样式应用到你的项目中，确保你的应用与Salesforce的其他部分保持一致。 使用SLDS图标也是一个重要的部分。SLDS提供了一套丰富的图标，可以帮助你更好地传达信息。这些图标就像是语言中的词汇，让你的界面更加生动和直观。 当然，如果你需要更个性化的设计，你也可以使用自定义CSS来设计组件的样式。这就像是为你的界面添加一些独特的装饰，让它与众不同。 在处理CSS供应商前缀时，我们需要特别注意。这些前缀是为了确保CSS在不同浏览器中的兼容性。我们需要确保我们的代码在所有环境中都能正常工作。 最后，我们还要应对冬季闪电体验中的背景变化编码。这意味着我们需要确保我们的界面在不同的主题和背景下都能保持良好的可读性和美观性。 好了，这就是我们今天要讲的内容。记得在学生指南中找到相关的幻灯片，这样你可以更深入地理解每个部分。希望你们能从中学到很多，开始构建出既美观又实用的Salesforce应用吧！

  ▶ 播放视频 查看详情
• 38

  Introducing the Salesforce Lightning Design System (SLDS)

  第 88 页

  今天我们来聊聊Salesforce Lightning设计系统，简称SLDS。你可以把它想象成一个设计师和开发者的工具箱，里面装满了各种工具和指南，帮助我们在Salesforce平台上打造既美观又实用的用户界面。 首先，SLDS提供了一套设计指南。这些指南就像是烹饪书中的食谱，告诉我们如何搭配颜色、字体和布局，来制作出既吸引人又易于使用的界面。这些设计模式都是经过反复测试的，确保它们在不同的应用和场景中都能提供一致且出色的用户体验。 接下来，SLDS还包含一个UI库。这个库就像是乐高积木，里面有很多现成的组件和示例，比如按钮、表格和导航栏等。这些组件都是用真实的HTML和CSS代码构建的，确保它们不仅看起来好看，而且在代码层面上也是高效和可访问的。 最后，SLDS使用了Sass这个强大的工具。Sass是一种CSS预处理器，它让我们能够更高效地编写和管理样式代码。想象一下，如果你有一大堆的CSS代码需要管理，Sass就像是你的私人助手，帮你整理和优化这些代码，让它们更加简洁和易于维护。 总的来说，Salesforce Lightning设计系统是一个全面的资源，无论是设计师还是开发者，都可以利用它来创建既美观又功能强大的Salesforce应用。你可以访问www.lightningdesignsystem.com，亲自探索这个强大的工具箱。

  ▶ 播放视频 查看详情
• 39

  Loading SLDS

  第 89 页

  今天我们来聊聊如何在Salesforce的Lightning应用中加载SLDSA样式表。SLDSA是Salesforce Lightning Design System的缩写，它提供了一套标准化的样式和组件，帮助开发者快速构建美观且一致的用户界面。 首先，如果你使用的是Salesforce的Lightning应用程序，并且想要加载SLDSA样式表，你需要在你的Aura组件中的``标签里添加一个属性，叫做`extends=&quot;force:slds&quot;`。这个属性告诉Salesforce，你想要使用SLDSA的样式表来美化你的应用。 举个例子，假设你有一个Aura组件，你可以在组件的定义中这样写： ```html ``` 这样，当你的应用加载时，Salesforce就会自动应用SLDSA的样式。 另外，如果你是在使用Lightning Out或者Visualforce页面中嵌入Aura组件，你也需要确保这些组件能够继承SLDSA的样式。这通常意味着你需要在组件的定义中同样添加`extends=&quot;force:slds&quot;`。 在DEX 601课程中，我们会更详细地探讨如何在Aura组件中使用这些技术，包括如何更有效地利用SLDSA来提升你的应用界面。 希望这个解释能帮助你理解如何在Salesforce中加载和使用SLDSA样式表。如果你有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 40

  SLDS Component Blueprints

  第 90 页

  今天我们来聊聊Salesforce的SDDS组件蓝图90。这个蓝图里包含了很多非常实用的组件，可以帮助我们更高效地构建用户界面。 首先，我们有“手风琴”组件，它可以让用户展开或折叠内容，非常适合展示大量信息时使用。接下来是“活动收件箱”，这个组件可以帮助用户管理和查看他们的活动通知。 “警报”组件用于显示重要的信息或警告，确保用户不会错过关键信息。而“应用启动器”则是一个方便的工具，让用户快速访问不同的应用。 “化身”和“徽章”组件可以用来展示用户的头像和一些状态标识，增加界面的个性化。“面包屑”组件则帮助用户了解他们在应用中的当前位置，非常实用。 “按钮”和“按钮组”是用户交互的基础，无论是提交表单还是触发操作，都离不开它们。“按钮图标”则是在按钮上添加图标，使操作更加直观。 “卡”组件用于展示信息块，非常适合展示产品详情或用户信息。“复选框按钮”和“复选框组”让用户可以进行多项选择，非常灵活。 “combobox”是一个下拉选择框，用户可以从预定义的选项中选择。“数据表”组件用于展示表格数据，支持排序和筛选。 “择偶者”和“选项卡”组件帮助用户在多个选项或页面之间切换。“瓷砖”组件则用于展示图片或信息块，适合用于仪表盘或产品展示。 “对接作曲家”和“对接表格页脚”组件帮助我们在页面布局时更加灵活。“对接公用事业条”则提供了一些常用的工具和快捷方式。 “决斗挑选表”和“动态图标”组件增加了界面的互动性和视觉效果。“可扩展部分”让用户可以根据需要展开或收起内容。 “饲料”组件用于展示动态更新的信息流，非常适合社交功能。“文件选择器”和“文件”组件帮助用户上传和管理文件。 “表单元素”和“表单布局”组件是构建表单的基础，确保用户输入的数据结构清晰。“全局标头”和“全球导航”组件则提供了统一的导航体验。 “网格系统”帮助我们进行页面布局，确保内容在不同设备上都能良好显示。“图标”和“图像”组件用于展示视觉元素，增加界面的美观性。 “工具提示”组件在用户悬停时显示额外信息，非常实用。“树木”组件用于展示层级结构，适合用于文件管理或组织结构展示。 “列表构建”和“查找”组件帮助用户快速找到他们需要的信息。“媒体对象”组件用于展示多媒体内容，如图片、视频等。 “菜单”组件提供了导航选项，用户可以快速访问不同功能。“Modals”组件用于弹出窗口，展示重要信息或进行用户交互。 最后，SLDS包含的CSS样式类可以帮助我们将HTML标记可视化为一系列组件。请注意，Winter 18版本中已经将许多原型实现为完整的闪电组件。但需要注意的是，SDDS主要用于可视化，你可能还需要编写额外的JavaScript代码来处理用户交互，以完全实现那些尚未添加到命名空间的SDS原型组件。 希望这些内容能帮助你更好地理解和使用SDDS组件蓝图90。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 41

  SLDS Component Blueprints - 91

  第 91 页

  让我们来聊聊SDDS组件蓝图。想象一下，SDDS就像是一个设计师的工具箱，里面装满了各种CSS样式类。这些样式类就像是不同的画笔和颜料，可以帮助你把HTML标记——也就是网页的基本结构——变成一系列漂亮的、可视化的组件。 现在，Winter 18版本带来了一个好消息：它包含了很多原型，这些原型已经变成了完全实现的闪电组件。你可以把它们看作是已经组装好的家具，直接拿来用就可以了。 但是，有一点需要注意：SDDS主要是用来做可视化的。也就是说，它帮你把东西做得好看，但如果你想让这些组件动起来，比如点击按钮有反应，或者输入框能接受用户输入，那你还需要写一些JavaScript代码来处理这些用户交互。 特别是对于那些还没有被添加到命名空间的SDS原型组件，你就更需要自己动手，用JavaScript来让它们活起来。所以，SDDS帮你把界面设计得美美的，但让它真正工作起来，还需要你的一些编程魔法哦！

  ▶ 播放视频 查看详情
• 42

  Applying SLDS Classes

  第 92 页

  让我们来聊聊这段代码和BEM的概念。首先，这段代码是一个简单的Salesforce Lightning组件，使用了Salesforce Lightning Design System（SLDS）来设计按钮的外观。 在这个组件中，我们定义了三个按钮：刷新、编辑和拯救。每个按钮都使用了`slds-button`这个类，这是SLDS中的一个标准类，用来定义按钮的基本样式。而`slds-button_neutral`则是一个修饰符类，用来表示按钮的中性状态，也就是默认的按钮样式。 现在，让我们来谈谈BEM。BEM是一种CSS类命名约定，它帮助我们更好地组织和管理CSS代码。BEM代表“块（Block）-元素（Element）-修饰符（Modifier）”。 - ，块（Block），：块是高级组件，比如`slds-button`。你可以把块看作是一个独立的、可重用的组件。 - ，元素（Element），：元素是块的子元素，比如`slds-button__icon`。元素是块的一部分，不能独立存在。 - ，修饰符（Modifier），：修饰符用来表示块或元素的不同状态或变体，比如`slds-button_neutral`。修饰符可以改变块或元素的外观或行为。 在这个例子中，`slds-button`是一个块，`slds-button_neutral`是一个修饰符，表示按钮的中性状态。 SLDS不仅提供了许多类来复制原生Lightning Experience组件的外观和感觉，还处理了排版、定位、用户交互等方面。这意味着你可以使用SLDS来快速构建符合Salesforce设计标准的用户界面，而不需要从头开始编写CSS。 总结一下，这段代码展示了如何使用SLDS和BEM命名约定来创建一组按钮。通过理解BEM的概念，你可以更好地组织和管理你的CSS代码，使你的组件更加模块化和可维护。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 43

  Applying SLDS Classes - 93

  第 93 页

  同学们，今天我们来聊聊Salesforce Lightning Design System（SLDS）中的一个非常实用的类别——SDDS。这个类别在布局和设计中非常有用，尤其是在你想要将文本或内容精确地放置在容器的中心时。 首先，SDDS和BEM（Block Element Modifier）在某些方面是不同的。BEM是一种命名约定，用于CSS类名，而SDDS是Salesforce提供的一套预定义的CSS类，用于快速实现常见的UI模式。 现在，假设你有一个容器，你想让里面的文本或内容绝对居中。在SDDS中，这非常简单。你只需要在包含文本的块级元素上添加一个类名，叫做`slds-ign_absolute-center`。这个类会自动处理所有的CSS属性，比如`position: absolute;`、`top: 50%;`、`left: 50%;`以及`transform: translate(-50%, -50%);`，这样你的内容就会完美地居中显示在容器中。 举个例子，如果你有一个`div`标签，里面有一些文本，你希望这些文本在`div`中居中，你可以这样写： ```html <div class="slds-ign_absolute-center"> 这里是居中的文本 </div> ``` 这样，无论你的容器大小如何变化，文本都会保持在中心位置。这种方法既简单又高效，非常适合快速开发和维护。 希望这个解释对你们有帮助，如果还有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 44

  Using SLDS Icons

  第 94 页

  同学们，今天我们来聊聊如何在Salesforce中使用SDDS图标。SDDS图标库非常丰富，里面有200多个图标，你可以随意挑选用在你的应用程序中。这些图标被分成了几个类别，比如行动、自定义、DOCTYPE、标准和实用等。 如果你想在Salesforce的基本光环组件中使用这些图标，你需要按照特定的格式来调用它们。这个格式是“categoryName:iconName”。举个例子，如果你想在一个叫做lightning:card的组件中使用一个名为“add_touch”的操作图标，你的代码应该写成这样： ```html ``` 这里，“action”就是图标所属的类别名称，而“add_touch”就是具体的图标名称。这样，Salesforce就知道你要用哪个图标了。 简单吧？下次当你需要在你的Salesforce应用中加入图标时，记得按照这个方法来调用哦！

  ▶ 播放视频 查看详情
• 45

  Styling a Component with CSS

  第 95 页

  让我们来聊聊如何在Salesforce中使用CSS来设计你的组件样式。首先，你需要知道的是，每个Salesforce组件都可以通过添加CSS来定制它的外观。这个过程其实很简单，你只需要在开发人员控制台的侧边栏中找到并点击“STYLE”按钮，就可以开始为你的组件添加CSS了。 这里有一个小技巧，Salesforce为了确保你的CSS样式不会影响到其他组件，它会自动为你的组件中的所有顶级元素添加一个特殊的CSS类，叫做“THIS”。这个“THIS”类就像是给你的CSS样式加了一个保护罩，确保它们只作用于当前的组件，不会和其他组件的样式打架。 如果你不按照这个规则来写CSS，Salesforce框架就会抛出错误，告诉你需要修正。所以，记得在使用CSS时，一定要遵循这个命名空间的约定。 举个例子，如果你想给你的组件设置一个独特的背景色，你可以这样写CSS： ```css .THIS { background-color: #f0f0f0; } ``` 这里的“.THIS”就是前面提到的那个特殊的类，它确保了背景色的样式只会应用到你当前的组件上。 最后，记住一点，如果你想对组件的直接后代元素应用样式，你的CSS选择器应该是“THIS.className”。这样，你就可以精确地控制你的样式，让它们只作用于你想要的元素上。 希望这些信息对你有帮助，让你在Salesforce的世界里更加得心应手！

  ▶ 播放视频 查看详情
• 46

  Handling CSS Vendor Prefixes

  第 96 页

  同学们，今天我们来聊聊CSS供应商前缀的问题。你们知道吗，有时候我们在写CSS的时候，会遇到一些属性，比如`border-radius`或者`user-select`，这些属性在不同的浏览器中可能需要加上一些前缀才能正常工作。比如，`-moz-`是给Firefox用的，`-webkit-`是给Chrome和Safari用的。 但是，在Salesforce的Lightning框架里，你们不需要自己手动去加这些前缀。框架会自动帮你们处理这些麻烦事。你们只需要写标准的CSS属性，比如`user-select`，框架在生成最终的CSS代码时，会自动加上所有需要的供应商前缀。 举个例子，如果你写了这样的CSS： ```css .user-select { user-select: none; } ``` 框架会自动帮你生成这样的代码： ```css .user-select { -webkit-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none; } ``` 这样，你的代码在所有浏览器中都能正常工作，而且你也不用担心忘记加哪个前缀了。 当然，如果你有特殊的需求，想要手动指定某个前缀的值，你也可以自己写上去。框架会优先使用你手动指定的值。比如： ```css .user-select { -webkit-user-select: auto; user-select: none; } ``` 这样，Chrome和Safari会使用`auto`，而其他浏览器会使用`none`。 总结一下，在Lightning框架里，你们可以放心地写标准的CSS属性，框架会帮你们处理好所有的供应商前缀问题。除非你有特殊需求，否则不需要自己手动加前缀。这样不仅省事，还能避免出错。 好了，今天的课就到这里，大家有什么问题吗？

  ▶ 播放视频 查看详情
• 47

  Background Color and Image

  第 97 页

  同学们，今天我们来聊聊Salesforce的Lightning Experience在1918年冬天的一个小更新——背景颜色和图像的调整。这个更新虽然听起来不大，但对我们的使用体验影响可不小哦。 首先，这个更新意味着什么呢？简单来说，就是Lightning页面的背景颜色和图像有了新的变化。这样一来，我们之前使用的一些自定义Lightning组件，或者从AppExchange下载的组件，可能就需要做一些调整了。为什么呢？因为这些组件的背景颜色和图像可能和新的背景不搭，导致内容看不清楚。 那么，我们该怎么办呢？其实很简单，只需要调整一下这些组件的CSS样式就可以了。CSS，就是控制网页样式的代码。通过调整CSS，我们可以给组件设置一个坚实的背景颜色，这样在新背景上，内容就能保持清晰可见了。 举个例子，假设我们有一个自定义的Lightning组件，我们可以通过修改它的CSS，给它加上一个白色的背景。这样，无论背景怎么变，我们的内容都能一目了然。 另外，还有一个更简单的方法，就是使用Salesforce提供的组件来包裹我们的自定义组件。是一个基础的Aura组件，它自带了一些样式和布局，可以帮助我们更轻松地管理组件的显示效果。 而且，使用这些基础的Aura组件还有一个好处，就是它们会自动继承Salesforce Design System（SDS）的任何未来更新。比如，在Winter &#39;18版本中，的背景颜色就从灰色变成了白色。如果我们使用了这些基础组件，就不需要手动去调整了，系统会自动帮我们更新。 好了，今天的分享就到这里。记住，随着Salesforce的不断更新，我们的组件也需要与时俱进。通过调整CSS或者使用基础组件，我们可以确保我们的内容始终清晰可见。希望这些小技巧对你们有帮助，我们下次再见！

  ▶ 播放视频 查看详情
• 48

  Changing Background in Lightning Experience

  第 98 页

  今天我们来聊聊如何在Salesforce的Lightning Experience中更改背景。作为管理员，你可以通过一些简单的步骤来定制你的Salesforce界面，让它看起来更符合你的品牌或者个人喜好。 首先，你需要进入“设置”菜单。在设置中，找到“活动主题”这一部分。这里就是你可以开始施展魔法的地方了。你可以选择更改默认的背景图像，或者调整背景颜色，让整个界面焕然一新。 选择背景图像时，你可以上传自己的图片，确保它符合Salesforce的规格要求，这样显示效果会更好。如果你更喜欢简洁的风格，也可以选择单一的颜色作为背景，这样不仅加载速度快，还能减少视觉干扰。 完成这些设置后，记得保存你的更改。这样，下次你或者你的团队成员登录Salesforce时，就能看到这个全新的、个性化的背景了。 简单吧？通过这样的定制，不仅能让Salesforce的使用体验更加愉悦，还能增强团队的归属感。试试看，让你的Salesforce界面与众不同吧！

  ▶ 播放视频 查看详情
• 49

  Unit 2: Getting Started - 100

  第 100 页

  同学们，今天我们来聊聊第2单元的内容。这个单元主要是关于如何使用HTML5和Salesforce的Lightning组件来开发应用程序的。听起来有点技术性，但别担心，我会尽量用简单的话来解释。 首先，我们会看看HTML5应用程序的一些特点、功能和限制。HTML5是一种非常流行的网页技术，它让网页更加动态和互动。然后，我们会学习如何使用Aura Components和Apex来开发Salesforce的移动应用程序。Aura Components是Salesforce提供的一种工具，可以帮助我们快速构建用户界面，而Apex是Salesforce的一种编程语言，用于处理业务逻辑。 接下来，我们会学习如何开始使用Lightning进行开发。Lightning是Salesforce的一个框架，它让开发更加快速和高效。我们还会学习如何使用CSS来美化我们的组件，让它们看起来更漂亮。 然后，我们会学习如何定义和操作组件的属性。属性就像是组件的设置，我们可以通过改变属性来改变组件的行为。我们还会学习如何处理系统和用户的事件，比如点击按钮或者数据加载完成。 当然，开发过程中难免会遇到问题，所以我们也会学习如何调试和排除故障。这就像是侦探工作，找出问题所在并解决它。 最后，我们会学习如何与Apex合作，使用基本的Aura组件，提出和处理事件，以及使用Lightning数据服务进行CRUD操作。CRUD是指创建(Create)、读取(Read)、更新(Update)和删除(Delete)数据的基本操作。 好了，这就是第2单元的主要内容。虽然听起来有点复杂，但只要你跟着步骤来，一步一步学习，你会发现其实并没有那么难。加油！

  ▶ 播放视频 查看详情
• 50

  Topics - 101

  第 101 页

  同学们，今天我们来聊聊Salesforce Lightning组件中的一些基础但非常重要的概念。首先，我们得知道什么是“配置范围”。简单来说，配置范围就是决定你的组件属性在哪里可以被访问和修改。这就像是你家里的房间，有的房间是私密的，只有你能进，有的则是客厅，所有人都可以进。 接下来是“配置属性的数据类型”。这就像是给每个房间贴上标签，告诉别人这个房间是用来做什么的。在Salesforce中，我们给属性定义数据类型，比如文本、数字、日期等，这样系统就知道如何处理这些数据了。 然后，我们来看看“以声明方式将属性传递给组件”。这就像是你给朋友寄礼物，你不需要亲自去送，只需要写好地址，邮递员就会帮你送到。在组件中，我们通过声明的方式，把属性传递给其他组件，而不需要写复杂的代码。 “使用表达式”就像是数学中的公式，我们可以用它们来计算或转换数据。比如，你可以用表达式来计算两个数字的和，或者把文本转换成大写。 “使用数字文本”和“使用算术运算符”就是我们在数学课上学的基础知识，比如加减乘除。在Salesforce中，我们也可以用这些运算符来处理数字数据。 “使用数学函数”则是一些更高级的数学工具，比如求平方根、对数等。这些函数可以帮助我们进行更复杂的计算。 “使用字符串文本”和“实现字符串级联”是关于处理文本的。字符串级联就是把多个文本连接在一起，比如把“Hello”和“World”连接成“Hello World”。 “使用三元运算符生成条件标记”和“使用生成条件标记”是关于条件判断的。这就像是做选择题，如果条件成立，就选A，不成立就选B。 “使用条件运算符”和“使用逻辑运算符”则是更复杂的条件判断工具，比如“与”、“或”、“非”等。 “确定是否是变量为空”就是检查一个变量是否有值。这就像是检查你的邮箱里有没有新邮件。 “通过数组循环和对象”是关于处理多个数据的。数组就像是一排邮箱，你可以一个个检查里面的邮件。对象则是一个更复杂的数据结构，可以包含多个属性和方法。 最后，“评论您的组件标记”就是在你的代码中添加注释，帮助别人理解你的代码。这就像是在书的旁边做笔记，帮助自己或别人更好地理解内容。 好了，今天的课程就到这里。希望大家能够理解这些基础但重要的概念。如果有任何问题，随时提问。记得查看学生指南中的幻灯片，那里有更详细的信息。下次见！

  ▶ 播放视频 查看详情
• 51

  Defining and Manipulating Component Attributes

  第 102 页

  同学们，今天我们来聊聊Salesforce中的组件属性。想象一下，组件属性就像是给组件穿上了一件可以随时更换的衣服，让组件在不同的场合下展现出不同的样子。这些属性是组件实例上的特定字段，它们有类型，比如文本、数字等，这样我们就可以在组件的标记里引用它们，让组件变得更加灵活和动态。 举个例子，假设我们有一个显示用户信息的组件，我们可以通过设置属性来改变显示的用户名、头像等信息，而不需要每次都去修改组件的代码。 现在，我们来看一下设置属性时需要注意的几个小细节： 1. ，属性名称的命名规则，：属性名称必须以字母或下划线开头，之后可以包含数字或连字符。比如，`userName` 或 `user_name` 都是合法的，但 `1userName` 就不行，因为它以数字开头了。 2. ，属性名称的长度，：属性名称至少要有两个字符。所以，像 `a` 这样的单字母名称是不被允许的。 3. ，连字符的使用，：虽然属性名称中可以包含连字符，但在表达式中使用这些属性时，不能直接使用带有连字符的属性。比如，如果你有一个属性叫 `user-name`，在表达式中引用它时，你需要用其他方式来处理，比如使用驼峰命名法。 4. ，标签的位置，：虽然这不是硬性规定，但通常我们会把 `` 标签放在组件标记的最前面。这样做的好处是，当你或其他人查看代码时，可以一眼就看出这个组件有哪些属性，就像看菜单一样，一目了然。 好了，这就是关于组件属性的基本介绍。记住，属性是让组件变得灵活和动态的关键，合理使用它们，可以让你的组件更加智能和适应性强。希望这些信息对你们有所帮助！

  ▶ 播放视频 查看详情
• 52

  Configuring Scope

  第 103 页

  今天我们来聊聊Salesforce中的，特别是它的访问属性，也就是我们常说的“Scope”。这个Scope决定了你的属性可以在哪里被访问和使用。 首先，我们来看一下三种主要的访问属性： 1. ，全球（Global），：这个属性就像是一个国际旅行者，它可以在任何命名空间中使用。无论你在哪个组件或应用中，只要你想用这个属性，它都能被访问到。 2. ，公共（Public），：这是默认的访问属性。它就像是一个社区成员，只能在同一个命名空间中使用。也就是说，如果你在一个特定的命名空间内定义了这个属性，那么只有在这个命名空间内的组件和应用才能访问它。 3. ，私人（Private），：这个属性就像是一个家庭的秘密，它只能在定义它的容器应用程序、接口、组件或事件中使用。外部的人是无法访问这个属性的。通常，我们会用私有属性来存储一些由组件的控制器或帮助器中的事件处理程序专门设置的变量。 记住，无论是组件、应用程序、事件还是界面，它们都有自己的范围。理解这些范围，可以帮助你更好地控制属性的访问权限，确保你的应用既安全又高效。 希望这个解释能帮助你更好地理解的访问属性。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 53

  Configuring an Attribute's Data Type

  第 104 页

  今天我们来聊聊Salesforce中配置属性的数据类型。这些数据类型就像是不同种类的容器，用来装不同类型的数据。我们一起来看看这些“容器”都有哪些吧。 首先，我们有，布尔，类型。这个类型很简单，它只能装两个值：真（true）或者假（false）。就像开关一样，要么开，要么关。 接下来是，日期，类型。这个类型专门用来装日期，比如2023年10月5日。它只关心日期，不关心具体的时间。 然后是，datetime，类型。这个类型比日期类型更详细，它不仅装日期，还装时间。比如2023年10月5日下午3点。 ，小数，类型是用来装带小数点的数字的，比如3.14。它适合用来表示精确的数值。 ，对象，类型是一个比较通用的类型，它可以装任何类型的对象。你可以把它想象成一个万能的容器。 ，地图，类型有点特别，它装的是键值对。就像字典一样，每个词（键）对应一个解释（值）。 ，标准和自定义对象类型，，比如账户（Account）或者收件箱（Inbox__c），这些都是Salesforce中定义的对象类型。你可以根据业务需求创建自定义对象。 如果你想表示一个数组，也就是一组相同类型的数据，你可以用，括号符号，来表示。比如，`` 表示一个日期数组。 ，双，类型是用来装双精度浮点数的，适合需要高精度的计算。 ，整数，类型就是用来装整数的，比如1、2、3等等。 ，长，类型是用来装更大的整数的，适合需要处理大数字的场景。 ，字符串，类型是用来装文本的，比如“你好，世界！”。 ，列表，类型和数组有点像，但它更灵活，可以装不同类型的元素。 最后是，设置，类型，它和列表类似，但它不允许有重复的元素。 好了，这些就是Salesforce中常用的数据类型。希望这些解释能帮助你更好地理解和使用它们。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 54

  Configuring an Attribute’s Data Type

  第 105 页

  今天我们来聊聊Salesforce中的两种数据类型：列表（List）和映射（Map）。这两种类型在Aura组件中非常常用，理解它们的概念和使用方法对你的开发工作会有很大帮助。 首先，我们来看，列表（List），。你可以把列表想象成一个有序的购物清单。比如，你去超市买东西，清单上列出的物品是有顺序的，第一个是苹果，第二个是香蕉，第三个是橙子。在Aura组件中，列表也是这样，它是一个有序的集合，里面可以存放多个项目。比如，你可以定义一个颜色列表，像这样： ```html ``` 这里，`colorPalette` 是一个列表，里面包含了三种颜色：红色、绿色和蓝色。列表中的每个项目都有一个位置，你可以通过位置来访问它们。 接下来，我们来看，映射（Map），。映射有点像字典，每个词（键）对应一个解释（值）。比如，字典里“苹果”这个词对应的是“一种水果”。在Aura组件中，映射也是这样，它是一个键值对的集合。每个键都是唯一的，不能重复，每个键对应一个值。比如，你可以定义一个标签映射，像这样： ```html ``` 这里，`sectionLabels` 是一个映射，里面有两个键值对。键 `a` 对应的值是 `label1`，键 `b` 对应的值是 `label2`。你可以通过键来访问对应的值。 总结一下，列表是一个有序的集合，适合存放一系列有顺序的项目；而映射是一个键值对的集合，适合存放需要通过键来查找值的场景。希望这些解释能帮助你更好地理解和使用这两种数据类型。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 55

  Configuring an Attribute’s Data Type - 106

  第 106 页

  今天我们来聊聊Salesforce中的数据类型，特别是集合类型和sObjects。 首先，集合（Set）是一种非常特别的数据类型。它最大的特点就是不包含重复的元素。想象一下，你有一个装满了不同颜色球的袋子，每个颜色只能有一个球。这就是集合的概念。在Salesforce中，你可以用Set来存储一组唯一的值。比如，你可以有一个包含数字1、2、3的集合。但是，集合中的元素顺序是不保证的，也就是说，你可能会得到“3，2，1”这样的顺序，而不是你最初放入的“1，2，3”。 接下来，我们来看看sObjects。sObjects是Salesforce中的一种数据类型，它可以是标准的Salesforce对象，比如联系人（Contact），也可以是自定义对象。这意味着你可以在你的代码中声明一个属性为Contact类型，或者任何你自定义的对象类型。例如，你可以创建一个属性来存储一个联系人的信息，包括联系人的名字等。 在代码中，你可以这样定义一个集合和一个联系人属性： ```html ``` 在这段代码中，`collection`是一个Set类型的属性，默认包含数字1、2、3。而`myContacts`是一个Contact类型的属性，默认包含一个名为“New Contact”的联系人。 希望这能帮助你更好地理解Salesforce中的数据类型，特别是集合和sObjects。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 56

  Passing Attributes to a Component Declaratively

  第 107 页

  让我们来聊聊如何在Salesforce的Lightning组件中声明性地传递属性。这个例子中，我们有一个简单的组件叫做`add2Nums`，它的作用是接收两个数字，然后把它们加在一起显示出来。 首先，我们来看一下`add2Nums`组件的代码。在这个组件中，我们定义了两个属性，`num1`和`num2`，它们的类型都是`Decimal`，并且默认值都是`0`。这意味着，如果我们在使用这个组件的时候没有给这两个属性赋值，它们就会自动取值为`0`。 接下来，我们有一个`<span>`标签，它用来显示`num1`和`num2`相加的结果。这里我们用了一个表达式`{! v.num1 + v.num2}`，这个表达式的作用是把`num1`和`num2`的值相加，然后把结果显示在这个`<span>`标签里。 然后，我们来看一下`addTest`应用的代码。在这个应用中，我们使用了`add2Nums`组件，并且给它的`num1`和`num2`属性分别赋值为`1`。这样，当这个应用运行时，`add2Nums`组件就会接收到这两个值，然后把它们相加，结果显示出来就是`1 + 1 = 2`。 总结一下，我们通过``这样的语法，可以很方便地在HTML中声明性地传递属性给组件。在这个例子中，我们就是通过这种方式，把`1`传递给了`add2Nums`组件的`num1`和`num2`属性，然后组件内部进行了加法运算并显示了结果。希望这个解释能帮助你理解如何在Salesforce中声明性地传递属性给组件。</span></span>

  ▶ 播放视频 查看详情
• 57

  Using Expressions

  第 108 页

  今天我们来聊聊Salesforce中的Expressions，也就是表达式。表达式在Salesforce中非常有用，它们可以帮助我们在组件标记内进行计算，或者访问一些特性值和其他数据。简单来说，表达式就是用来动态输出信息或者传递值给组件的工具。 表达式的形式有两种：{#Expression} 和 {!Expression}。这里的“Expression”就是你要计算或者访问的内容。比如，你可以用表达式来显示一个数字，或者显示某个组件的属性值。 当你在组件中使用{!Expression}时，Salesforce会在组件每次渲染或者值发生变化时，重新计算这个表达式，并更新显示的内容。而{#Expression}则只在组件渲染时计算一次，之后即使值变了，显示的内容也不会更新。 表达式的计算方式和JavaScript很像，你可以使用一些基本的运算符，比如加、减、乘、除等。如果你想让某些计算先进行，可以用括号来指定顺序。 表达式的结果可以是各种类型的数据，比如数字、字符串、布尔值，甚至是JavaScript对象或者组件。如果你想在表达式中使用文本，记得用单引号括起来，比如{#‘Hello World’}。如果是数字，直接写就行，比如{!123}。 如果你想输出组件的某个属性值，可以用{#v.属性名}或者{!v.属性名}这样的语法。这里的“v”代表的是组件的视图值提供者，它可以帮助我们访问组件的属性。 总之，表达式是Salesforce中非常强大的工具，掌握它们可以让你更灵活地控制组件的显示和行为。希望这些解释能帮助你更好地理解和使用表达式！

  ▶ 播放视频 查看详情
• 58

  Using Numeric Literals

  第 109 页

  让我们一起来看一下这段代码。这段代码是用在Salesforce的Lightning组件中的，它展示了如何在表达式中使用数字文字。 首先，我们有一个``标签，这是定义一个Lightning组件的开始。在这个组件里，我们定义了一个属性`num1`，它的类型是`Decimal`，并且默认值是`2`。 接下来，我们有三行输出： 1. 第一行是`2 + {！v.num1 } = {！2 + v.num1 }`。这里，`{！v.num1 }`表示引用`num1`的值，也就是`2`。所以`2 + 2`等于`4`，这就是为什么第一行输出是`2 + 2 = 4`。 2. 第二行是`2000 = {！2e3 }`。这里的`2e3`是科学计数法，表示`2`乘以`10`的`3`次方，也就是`2000`。所以第二行输出是`2000 = 2000`。 3. 第三行是`2 +空= {！2 +空}`。这里的`空`表示`null`或者`undefined`。在JavaScript中，任何数字加上`null`都会返回数字本身。所以`2 + null`等于`2`，这就是为什么第三行输出是`2 +空= 2`。 总结一下，这段代码展示了如何在Lightning组件中使用数字文字和表达式来进行简单的数学运算。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 59

  Using Arithmetic Operators

  第 110 页

  让我们来聊聊这个Salesforce的Aura组件，它展示了如何使用算术运算符来处理两个数字。这个组件有两个属性，Num1和Num2，它们的默认值都是0。我们可以通过传递不同的值给这两个属性，来展示不同的算术运算结果。 首先，我们来看加法。在组件中，我们使用了`{!v.num1 + v.num2}`来计算Num1和Num2的和。比如，如果Num1是2，Num2是4，那么2加4等于6。 接下来是减法，使用`{!v.num1 - v.num2}`来计算。2减4等于-2。 然后是乘法，使用`{!v.num1 * v.num2}`。2乘以4等于8。 除法使用`{!v.num1 / v.num2}`。2除以4等于0.5。 我们还使用了取模运算符`%`，它返回除法的余数。2除以4的余数是2，所以`{!v.num1 % v.num2}`的结果是2。 最后，我们还展示了如何取一个数的负数。使用`{!-v.num1}`，如果Num1是2，那么它的负数就是-2。 这些运算符在Salesforce的Aura组件中都是支持的，可以帮助我们进行各种数值计算。通过这种方式，我们可以动态地展示和计算数据，使得我们的应用更加灵活和强大。

  ▶ 播放视频 查看详情
• 60

  Using Math Functions

  第 111 页

  同学们，今天我们来聊聊如何在Salesforce的Aura组件中使用数学函数。数学函数可以帮助我们在页面上进行一些简单的计算，比如加法、减法，甚至求绝对值。 首先，我们来看一个简单的例子。假设我们有一个Aura组件，里面有几个`<div>`标签，每个标签都显示一个数学运算的结果。 ```html <div>2 + 2 = {!add(2,2)}</div> <div>2 - 2 = {!sub(2,2)}</div> <div>abs(-5) = {!abs(-5)}</div> ``` 在这个例子中，我们使用了三个数学函数：`add`、`sub`和`abs`。 1. ，`add(2,2)`，：这个函数的作用是将两个数字相加。在这里，2加2等于4，所以页面上会显示“2 + 2 = 4”。 2. ，`sub(2,2)`，：这个函数的作用是将两个数字相减。2减2等于0，所以页面上会显示“2 - 2 = 0”。 3. ，`abs(-5)`，：这个函数的作用是求一个数的绝对值。绝对值就是不管这个数是正数还是负数，结果都是正数。所以，-5的绝对值是5，页面上会显示“abs(-5) = 5”。 最后，页面的输出结果会是这样的： ``` 2 + 2 = 4 2 - 2 = 0 abs(-5) = 5 ``` 需要注意的是，这些函数名称是区分大小写的，所以一定要确保你写的是正确的函数名，比如`add`、`sub`和`abs`，不能写成`Add`或`SUB`。 好了，这就是今天的内容。通过这些简单的数学函数，我们可以在Aura组件中轻松地进行一些基础的计算。希望你们能理解并尝试在自己的项目中使用这些函数。如果有任何问题，随时问我！</div>

  ▶ 播放视频 查看详情
• 61

  Using String Literals

  第 112 页

  让我们来聊聊在Salesforce中如何处理字符串。首先，记住一点：当你想要使用一个字符串时，这个字符串必须用单引号括起来。比如，&#39;Hello World&#39; 就是一个标准的字符串表示。 现在，说到双引号，它们有特别的用途。双引号主要用于封闭属性值。比如，在HTML标签中，你可能会看到类似 `class=&quot;example&quot;` 这样的用法，这里的双引号就是用来包围属性值的。 接下来，如果你在字符串中需要包含一些特殊字符，比如引号本身，你就需要使用“\”这个字符来进行转义。例如，如果你想在字符串中包含一个双引号，你可以这样写：`&quot;He said, \&quot;Hello!\&quot;&quot;`。这里的反斜杠告诉系统，接下来的双引号是字符串的一部分，而不是字符串的结束。 最后，关于Unicode字符，Salesforce允许你将Unicode字符编码为“\u#”的形式，其中#代表的是四位十六进制数字。比如，如果你想表示一个笑脸符号，你可以使用 `\u263A`。记住，所有的Unicode字符都需要四位数字来表示。 希望这些信息对你有帮助！如果有任何疑问，随时问我哦！

  ▶ 播放视频 查看详情
• 62

  Implementing String Concatenation

  第 113 页

  同学们，今天我们来聊聊如何在Salesforce的Lightning组件中实现字符串的级联操作。字符串级联，简单来说，就是把两个或多个字符串拼接在一起。这在很多场景下都非常有用，比如生成一个邮件链接。 首先，我们来看第一个例子。在这个组件中，我们定义了两个属性：`address`和`label`，它们都是字符串类型，并且是必需的。然后，我们使用了一个`<a target="_blank">`标签来创建一个邮件链接。这里的关键部分是`href`属性，我们使用了`{! &#39;mailto:&#39; + v.address }`这样的表达式。这里的`+`操作符就是把`mailto:`和`v.address`这两个字符串拼接在一起，形成一个完整的邮件链接地址。 接下来，我们再看第二个例子。这个例子和第一个非常相似，但这次我们使用了`concat()`函数来实现字符串的拼接。`concat()`函数的作用和`+`操作符是一样的，都是把多个字符串连接在一起。在这个例子中，我们使用了`{!concat(&#39;mailto:&#39;,v.address)}`这样的表达式，效果和第一个例子是一样的。 总结一下，无论是使用`+`操作符还是`concat()`函数，我们都可以轻松地实现字符串的级联操作。选择哪种方式主要取决于你的个人喜好和代码的可读性。希望这个解释对你们有所帮助，如果有任何问题，欢迎随时提问！</a>

  ▶ 播放视频 查看详情
• 63

  Generating Conditional Markup

  第 114 页

  今天我们来聊聊在Salesforce的Aura框架中，如何使用条件来生成不同的标记内容。这个技巧在开发动态用户界面时非常有用。 首先，我们来看一个简单的例子，使用三进制运算符。这个运算符就像一个快速的条件判断工具。它的基本形式是这样的：`条件 ? 值1 : 值2`。如果条件为真，就返回值1；如果条件为假，就返回值2。比如，你可以用它来决定显示哪个文本，或者哪个组件。 接下来，我们谈谈``标签。这个标签非常强大，它允许你根据一个条件来决定是否渲染某段HTML或者组件。你只需要在`isTrue`属性中设置一个表达式。如果这个表达式的结果是`True`，那么``标签里面的内容就会被渲染出来。如果结果是`False`，那么你可以选择渲染`else`属性中定义的内容。 这里的关键是，所有的这些条件判断都是在服务器端完成的。这意味着，你的应用可以更高效地处理这些逻辑，而不需要把所有的负担都放在客户端。 总结一下，使用三进制运算符和``标签，你可以轻松地在Salesforce的Aura框架中实现条件渲染。这不仅能让你的代码更简洁，还能提高应用的性能。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 64

  Using Conditional Operators

  第 115 页

  今天我们来聊聊在Salesforce的Lightning框架中使用的条件操作符。这些操作符其实和我们在JavaScript中使用的非常相似，但Lightning还提供了一些额外的便利。 首先，我们来看看基本的比较操作符。在JavaScript中，我们常用的比较操作符有等于（==）、不等于（!=）、大于（&gt;）、小于（=）和小于等于（

  ▶ 播放视频 查看详情
• 65

  Using Conditional Operators - 116

  第 116 页

  让我们来聊聊这段代码。这段代码是用在Salesforce的Lightning组件中的，它主要的功能是检查两个数字，确保我们不会进行一个无效的数学操作——也就是除以零。 首先，我们定义了两个属性`num1`和`num2`，它们都是小数类型（Decimal），并且默认值都设置为0。这意味着如果用户没有输入任何值，这两个数字就会自动是0。 接下来，我们有一个``标签，这是一个条件判断语句。它检查`num2`是否等于0。如果`num2`确实是0，那么它会显示一条消息：“你不能被零除！”这是因为在数学中，除以零是没有意义的，所以我们需要避免这种情况。 如果`num2`不是0，那么``标签就会生效，它会计算`num1`除以`num2`的结果，并显示出来。 这个例子很好地展示了如何使用条件运算符来防止程序执行可能导致错误或无效结果的数学操作。通过这种方式，我们可以确保我们的应用程序更加健壮和用户友好。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 66

  Using Logical Operators

  第 117 页

  让我们来聊聊在Salesforce的Lightning框架中如何使用逻辑运算符。在JavaScript中，我们通常使用`&amp;&amp;`来表示“与”操作，但在Lightning组件的标记语言中，我们不能直接使用`&amp;&amp;`。相反，我们需要使用`and()`函数来实现相同的逻辑。 举个例子，假设我们有两个条件：`isUtiled`和`hasPermit`。在JavaScript中，我们可能会这样写： ```javascript if (isUtiled &amp;&amp; hasPermit) { // 执行某些操作 } ``` 但在Lightning组件的标记中，我们需要这样写： ```html ``` 这里，`and()`函数接受两个参数，`isUtiled`和`hasPermit`，并返回一个布尔值。如果这两个条件都为真，那么`and()`函数就会返回`true`，从而触发``标签中的内容。 所以，简单来说，当你在Lightning组件的标记中需要用到“与”逻辑时，记得使用`and()`函数，而不是`&amp;&amp;`操作符。这样，你的代码就能在Lightning框架中顺利运行了。

  ▶ 播放视频 查看详情
• 67

  Using Logical Operators - 118

  第 118 页

  让我们来聊聊这段代码。首先，这段代码是用在Salesforce的Lightning组件中的，主要是用来处理两个数字的逻辑判断。 在这段代码中，我们有两个属性，`num1` 和 `num2`，它们都是小数类型的。我们想要检查这两个数字是否都是正数，如果是，我们再进一步检查 `num2` 是否为零，因为除数不能为零。 这里的关键点是逻辑运算符 `&amp;&amp;`，它表示“并且”的意思。也就是说，`v.num1 &gt;= 0 &amp;&amp; v.num2 &gt;= 0` 这个条件的意思是，`num1` 大于等于零 ，并且， `num2` 也大于等于零。 但是，在Lightning组件的标记中，直接使用 `&amp;&amp;` 是不行的，因为 `&amp;&amp;` 是JavaScript中的逻辑运算符，而在组件的标记中，我们需要使用 `and()` 函数来实现相同的逻辑。 所以，你可以把 `&amp;&amp;` 替换为 `and()` 函数，像这样： ```html ``` 这样，`and()` 函数就会检查两个条件是否都为真，如果是，就执行接下来的逻辑。 接下来，如果 `num2` 是零，我们会显示一条消息“你不能被零除！”，否则我们会计算 `num1` 除以 `num2` 的结果。 如果 `num1` 或 `num2` 不是正数，我们会显示一条错误消息“错误-两个数字都必须是正值。” 总结一下，这段代码的逻辑是： 1. 检查 `num1` 和 `num2` 是否都是正数。 2. 如果是，再检查 `num2` 是否为零。 3. 如果 `num2` 是零，显示错误消息。 4. 如果 `num2` 不是零，计算并显示 `num1` 除以 `num2` 的结果。 5. 如果 `num1` 或 `num2` 不是正数，显示错误消息。 希望这个解释能帮助你理解这段代码的逻辑和用法！

  ▶ 播放视频 查看详情
• 68

  Determining If a Variable is Empty

  第 119 页

  今天我们来聊聊如何在Salesforce中确定一个变量是否为空。这个话题其实挺实用的，尤其是在处理数据的时候。 首先，我们有两个常用的函数可以帮助我们：`long()` 和 `empty()`。 ### 1. 使用 `long()` 函数 `long()` 函数可以用来确定一个数组或字符串的长度。比如，如果你有一个数组 `v.myArray`，你可以用 `v.myArray.long()` 来获取这个数组的长度。如果长度是0，那就说明这个数组是空的。 ### 2. 使用 `empty()` 函数 `empty()` 函数则更直接一些。它会检查一个变量是否满足以下条件之一： - 这个变量是未定义的（undefined） - 这个变量是空的（null） - 如果这个变量是一个数组，那么这个数组是空的 - 如果这个变量是一个字符串，那么这个字符串是空的 如果满足以上任何一个条件，`empty()` 函数就会返回 `true`，表示这个变量是空的。 ### 3. 性能比较 这里有一个小技巧：使用 `{! !empty(v.myArray)}` 来判断数组是否为空，比使用 `{! v.myArray &amp;&amp; v.myArray.long() &gt; 0}` 要快一些。为什么呢？因为 `empty()` 函数内部已经做了很多优化，直接检查变量是否为空，而不需要先计算长度再比较。 ### 总结 - 如果你想检查一个数组或字符串的长度，可以用 `long()` 函数。 - 如果你想快速判断一个变量是否为空，用 `empty()` 函数会更高效。 希望这些内容对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 69

  Looping Through Arrays and Objects

  第 120 页

  让我们来聊聊如何在Salesforce的Aura框架中使用`aura:iteration`来循环遍历一个数组。 首先，想象一下你有一个列表，里面有几个名字，比如“Steve”、“Dave”、“Joe”和“Jyoti”。你想在网页上展示这些名字，每个名字都显示在一个列表项中。这时候，`aura:iteration`就派上用场了。 在你的Aura组件中，你首先定义了一个属性`myNames`，它是一个字符串数组，默认值就是刚才提到的那些名字。这个属性就像是一个容器，里面装着所有你想要展示的名字。 接下来，你使用了`aura:iteration`组件。这个组件的作用就是遍历`myNames`数组中的每一个元素。在每次循环中，`aura:iteration`会把当前元素的值赋给一个变量，这里我们叫它`thisName`。 然后，在`aura:iteration`的标签内部，你使用了`<ul><li>`标签来创建一个列表项，并在其中插入了`{! thisName}`。这表示你要把当前循环中的名字显示在这个列表项里。 最后，当这个组件被渲染到网页上时，`aura:iteration`会遍历`myNames`数组中的每一个名字，并为每个名字创建一个`</li><li>`标签，最终你会看到一个包含所有名字的无序列表。 简单来说，`aura:iteration`就像是一个勤劳的工人，它一遍又一遍地走过你的名字列表，每次都会拿起一个名字，然后把它放到网页上的一个小格子里。这样，你就可以轻松地在网页上展示所有的名字了。</li></ul>

  ▶ 播放视频 查看详情
• 70

  Commenting your Markup

  第 121 页

  让我们来聊聊Salesforce Lightning组件框架中的评论功能。你知道吗，Lightning组件框架使用和HTML一样的评论标签，就是。但是，这里有个小区别。在HTML里，如果你在浏览器里选择“查看”&gt;“源”，你就能看到这些评论。但在Lightning里，这些评论是完全不会出现在最终输出里的。也就是说，你在Lightning里写的评论，用户是看不到的。 而且，如果你在评论里写了任何标记，比如HTML标签，这些标记也不会被执行。它们只是静静地待在那里，不会对页面产生任何影响。 这里有个小提示：如果你在Lightning应用程序或组件中使用评论，记得不要用两个连字符（--）来包围SDS样式类。如果你遇到名字里有两个连字符的SDS风格类，最好把它们替换成单个下划线（_）。这样可以避免一些不必要的小麻烦。 希望这些信息对你有帮助！如果你有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 71

  During this exercise, you will start building the student gallery.

  第 122 页

  同学们，今天我们要开始一个非常有趣的练习——构建一个学生画廊。这个练习会帮助我们更好地理解如何使用Salesforce的组件属性来创建动态内容。 首先，我们要定义一个叫做`StudentTile`的组件。这个组件将会是我们画廊中的每一个小格子，每个格子代表一个学生的信息。 接下来，我们要定义这个组件的属性。属性就像是组件的“特征”或者“设置”，它们决定了组件如何显示和表现。比如，我们可以为`StudentTile`组件定义一些属性，比如学生的名字、照片、年级等。 最后，我们要生成动态标记。这意味着我们的组件将能够根据我们提供的数据动态地生成内容。比如，如果我们有10个学生的信息，我们的`StudentTile`组件就会自动生成10个格子，每个格子显示一个学生的信息。 这个练习大约需要15分钟，大家准备好了吗？让我们一起动手，开始构建我们的学生画廊吧！

  ▶ 播放视频 查看详情
• 72

  Unit 2: Getting Started - 123

  第 123 页

  同学们，今天我们来聊聊第2单元的内容。这个单元主要是关于如何使用HTML5和Salesforce的Lightning组件来开发应用程序的。听起来有点技术性，但别担心，我会尽量用简单的话来解释。 首先，我们会回顾一下HTML5应用程序的一些基本特征、功能和限制。HTML5是一种非常流行的网页技术，它让网页更加动态和互动。然后，我们会学习如何使用Aura Components和Apex来开发Salesforce的移动应用程序。Aura Components是Salesforce提供的一种强大的工具，可以帮助我们快速构建用户界面。 接下来，我们会学习如何入门Lightning开发。Lightning是Salesforce的一个框架，它让开发更加快速和高效。我们还会学习如何使用CSS来美化我们的组件，让它们看起来更漂亮。 然后，我们会学习如何定义和操作组件的属性。属性就像是组件的设置，我们可以通过改变这些设置来改变组件的行为和外观。我们还会学习如何处理系统和用户的事件，比如点击按钮或者页面加载时发生的事情。 当然，开发过程中难免会遇到问题，所以我们也会学习如何调试和排除故障。这就像是侦探工作，找出问题所在并解决它。 最后，我们会学习如何与Apex合作。Apex是Salesforce的一种编程语言，它让我们可以编写更复杂的逻辑。我们还会学习如何使用基本的Aura组件，提出和处理事件，以及使用Lightning数据服务进行CRUD操作。CRUD操作是指创建、读取、更新和删除数据，这是任何应用程序的基础。 好了，这就是第2单元的主要内容。虽然听起来有点复杂，但别担心，我们会一步步来，确保每个人都能跟上。准备好了吗？让我们开始吧！

  ▶ 播放视频 查看详情
• 73

  Topics - 124

  第 124 页

  同学们，今天我们来聊聊Salesforce中的一些高级功能，特别是关于客户端控制器、事件分配器以及如何高效地使用JavaScript和Aura框架来增强我们的应用。 首先，，客户端控制器事件分配器，，这听起来有点复杂，但其实很简单。想象一下，你在一个房间里，有几个人在同时说话，你需要一个方式来确保每个人都能听到他们感兴趣的话题。事件分配器就是这样的角色，它帮助我们在Salesforce应用中管理和分发事件，确保每个组件都能接收到它需要的信息。 接下来是，使用条件表达的处理器，。这就像是一个聪明的管家，它根据不同的条件来决定执行哪些操作。比如，如果用户点击了一个按钮，处理器会根据按钮的类型来决定接下来要做什么。 ，与助手一起重复使用代码，，这就像是你有一个工具箱，里面装满了各种工具。每次你需要完成一个任务时，你可以从工具箱里拿出合适的工具来使用，而不需要每次都重新制作工具。在Salesforce中，助手就是这样的工具箱，它帮助我们重复使用代码，提高开发效率。 ，按ID查找组件，，这就像是在一个大图书馆里找到一本特定的书。每个组件都有一个唯一的ID，通过这个ID，我们可以快速找到并操作这个组件。 ，获取和设置组件属性值，，这就像是调整电视的音量。你可以读取当前的音量大小，也可以根据需要调整它。在Salesforce中，我们可以读取和修改组件的属性值，来控制组件的行为和显示。 ，隐藏和显示组件，，这就像是在舞台上控制灯光。你可以根据需要让某些演员（组件）出现在舞台上，或者暂时让他们退场。 ，来自JavaScript的静态资源，，这就像是从一个宝箱里取出宝物。静态资源是我们存储在Salesforce中的文件，比如JavaScript文件，我们可以随时调用它们来增强我们的应用。 ，修改多姆，，这里的“多姆”指的是DOM，也就是文档对象模型。通过JavaScript，我们可以直接修改网页的结构和内容，这给了我们极大的灵活性。 ，闪电收件箱编码，，这就像是给你的电子邮件客户端添加新的功能。通过编码，我们可以定制Salesforce的闪电收件箱，让它更好地满足我们的需求。 ，使用DeliverAPI查看器，，这就像是一个放大镜，帮助我们查看和理解通过DeliverAPI发送和接收的数据。 ，处理系统事件，，这就像是处理公司内部的紧急通知。当系统发生某些重要事件时，我们需要有相应的处理机制来响应。 ，收听组件收件箱，，这就像是监听一个特定的频道，只有当有消息发送到这个频道时，我们才会收到通知。 ，聆听组件渲染，，这就像是在观察一个画家作画。我们可以监听组件的渲染过程，确保它们在正确的时间和位置被绘制出来。 好了，同学们，这就是我们今天的内容。希望这些比喻能帮助你们更好地理解这些概念。记得查看学生指南中的幻灯片，那里有更多的细节和示例。我们下次课再见！

  ▶ 播放视频 查看详情
• 74

  Handling Events

  第 125 页

  让我们来聊聊Salesforce中的事件闪电框架，以及如何使用它来处理事件。想象一下，你正在设计一个网页，用户点击一个按钮，或者鼠标悬停在一个图片上，这些动作都会触发一个事件。在Salesforce中，我们使用事件驱动编程来响应这些用户交互。 首先，客户端控制器是你的JavaScript资源，它负责处理组件内的用户事件。你可以把它想象成一个指挥中心，当用户做了某些动作时，控制器就会调用相应的函数来响应这些动作。 但是，如果所有的逻辑都放在控制器里，代码可能会变得很复杂。这时候，客户端帮助器就派上用场了。帮助器是一个单独的文件，你可以把复杂的逻辑放在这里，这样控制器就可以保持简洁，而且你还可以从多个控制器函数中调用同一个帮助器函数。 接下来是表达式。表达式是用来为HTML属性分配操作函数的，比如onClick、onhover等。这些属性通常以“on”开头，表示当某个事件发生时应该执行的操作。Salesforce提供了一些现成的组件，比如，它们简化了向用户界面事件分配操作的过程。 举个例子，如果你想为一个<div>元素的点击事件分配一个处理函数，你可以使用这样的语法： ```html <div>点击我</div> ``` 这里的`{!c.handleClick}`是一个表达式，它引用了一个名为`handleClick`的控制器函数。当用户点击这个<div>时，`handleClick`函数就会被调用。 记住，事件的名称是区分大小写的，所以`onClick`和`onclick`是不同的。确保你使用正确的大小写来避免错误。 这就是Salesforce中处理事件的基本概念。通过使用客户端控制器、帮助器和表达式，你可以有效地响应用户的交互，让你的应用更加动态和互动。希望这能帮助你更好地理解事件闪电框架的工作原理！</div></div>

  ▶ 播放视频 查看详情
• 75

  Defining a Client-Side Controller Event Handler

  第 126 页

  让我们来聊聊Salesforce中的客户端控制器和事件处理器。想象一下，你正在使用一个网页，当你点击一个按钮或者把鼠标移到一个图片上时，网页会做出反应，比如弹出一个提示框或者显示一些信息。在Salesforce中，我们使用客户端控制器来处理这些用户交互。 客户端控制器其实就是一个包含多个函数的对象，每个函数都对应一个特定的用户动作，比如点击或者鼠标悬停。这些函数被称为事件处理器，因为它们处理用户触发的事件。 每个事件处理器函数通常接受三个参数： 1. ，组件，：这是指事件发生的那个组件，比如一个按钮或者一个图片。 2. ，事件，：这是指用户触发的具体事件，比如点击事件或者鼠标悬停事件。 3. ，助手，：这是一个可选参数，如果你在组件包中定义了帮助函数，你可以通过这个参数来调用它们。 客户端控制器的代码通常被包裹在方括号和花括号中，这表示它是一个对象，里面包含了一系列的名称-值对。每个名称对应一个事件类型，比如“点击”或“鼠标悬停”，而值则是对应的处理函数。 例如，你可能会看到这样的代码： ```javascript ({ click: function(component, event, helper) { alert(&#39;哎哟！&#39;); }, mouseOver: function(component, event, helper) { console.log(&#39;鼠标越过！&#39;); } }) ``` 在这个例子中，`click`和`mouseOver`是事件类型，而紧随其后的函数就是处理这些事件的代码。当用户点击组件时，会弹出一个提示框显示“哎哟！”，而当用户把鼠标移到组件上时，控制台会打印出“鼠标越过！”。 记得，每个函数之间要用逗号分隔，这样JavaScript才能正确解析它们。把这些事件处理程序代码放在你的组件包的控制器中，就可以让组件响应用户的交互了。 希望这个解释能帮助你理解客户端控制器和事件处理器的工作原理！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 76

  Supported DOM Events

  第 127 页

  同学们，今天我们来聊聊Salesforce中的多姆事件（DOM Events）。这些事件在网页开发中非常常见，尤其是在使用Lightning框架时。多姆事件是指当用户与网页上的元素进行交互时，比如点击鼠标、移动鼠标等，浏览器会触发的一些事件。 首先，我们来看几个常见的多姆事件： 1. ，onclick，：当用户点击某个元素时触发。比如，你点击一个按钮，就会触发这个事件。 2. ，onmouseover，：当用户把鼠标移到某个元素上时触发。比如，你把鼠标悬停在一个链接上，就会触发这个事件。 3. ，onMouseOut，：当用户把鼠标从某个元素上移开时触发。比如，你把鼠标从一个按钮上移开，就会触发这个事件。 4. ，ondblClick，：当用户双击某个元素时触发。比如，你双击一个图片，就会触发这个事件。 5. ，onmousedown，：当用户按下鼠标按钮时触发。比如，你按下鼠标左键，就会触发这个事件。 6. ，onmouseup，：当用户释放鼠标按钮时触发。比如，你松开鼠标左键，就会触发这个事件。 这些事件在标准的HTML和JavaScript中都是支持的，而在Salesforce的Lightning框架中，这些事件同样适用。Lightning框架不仅支持这些标准的多姆事件，还提供了一些自己特有的事件，特别是在使用Aura Components时。 需要注意的是，Aura Components有一些自己独特的事件名称，这些事件名称可能与标准的HTML事件名称有所不同。所以在使用Aura Components时，你需要查阅相关的文档，确保你使用的事件名称是正确的。 总结一下，多姆事件是用户与网页交互时触发的事件，Lightning框架支持大多数标准的HTML多姆事件，同时也提供了一些特有的事件。理解这些事件的使用场景和触发条件，对于开发交互性强的网页应用非常重要。 好了，今天的课程就到这里，希望大家对这些多姆事件有了更清晰的理解。如果有任何问题，欢迎随时提问！

  ▶ 播放视频 查看详情
• 77

  Assigning Handlers with Conditional Expressions

  第 128 页

  让我们来聊聊这个Salesforce的Aura组件示例。这个组件的主要功能是根据用户是否“喜欢”某个东西来改变按钮的显示和行为。 首先，我们有一个``标签，这是定义一个Aura组件的基础。在这个组件中，我们定义了一个名为`likeId`的属性，它的类型是字符串（String）。这个属性用来存储用户是否“喜欢”某个东西的状态。 接下来，我们有一个`<div>`标签，它有一个`onclick`事件。这个事件会根据`likeId`的值来决定调用哪个函数。如果`likeId`是空的（null），那么点击这个`<div>`时会调用`likeIt`函数；如果`likeId`不是空的，那么会调用`unlikeIt`函数。 在`<div>`标签内部，我们使用了一个条件表达式来显示不同的文本。如果`likeId`是空的，显示“喜欢它”；如果不是空的，显示“不像它”。 然后，我们来看一下控制器的部分。在控制器中，我们定义了两个函数：`likeIt`和`unlikeIt`。`likeIt`函数会将`likeId`设置为“like”，表示用户喜欢这个东西；`unlikeIt`函数会将`likeId`设置为空，表示用户不再喜欢这个东西。 最后，我们提到了这个组件的测试文件`Test.cmp`和`TestController.js`。这些文件用来测试组件的行为，确保它能够根据`likeId`的值正确地调用不同的函数，并且能够正确地更新显示。 总结一下，这个组件通过条件表达式和动态属性更新，实现了根据用户是否“喜欢”某个东西来改变按钮的显示和行为。这是一个非常实用的功能，可以增强用户界面的互动性和响应性。</div></div></div>

  ▶ 播放视频 查看详情
• 78

  Reusing Code with Helpers

  第 129 页

  让我们来聊聊如何在Salesforce中使用Helpers来重用代码。想象一下，Helpers就像是你的小助手，它们可以帮助你在不同的地方重复使用相同的代码，而不需要每次都重新写一遍。这样不仅节省时间，还能让你的代码更加整洁和易于管理。 首先，Helpers是组件捆绑包的一部分。这意味着每个组件都可以有自己的Helper，而且这个Helper是通过一个特定的命名约定自动连接到组件的。这个命名约定是“Helper.js”，并且它会自动连接到对应的组件名称。比如，如果你的组件叫做“MyComponent”，那么它的Helper就会自动命名为“MyComponentHelper.js”。 现在，如果你想在开发人员控制台中创建一个Helper，你可以这样做：首先，打开开发人员控制台，然后在组件侧边栏中找到并点击“帮助”按钮。这个操作会为你创建一个新的Helper文件，这个文件会自动连接到你的组件。这个Helper文件的作用范围仅限于它自动连接到的那个组件，也就是说，它只能在这个组件内部使用。 简单来说，Helpers让你的代码更加模块化，易于维护和重用。通过这种方式，你可以更高效地开发Salesforce应用，同时保持代码的清晰和一致性。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 79

  Reusing Code with Helpers - 130

  第 130 页

  让我们来聊聊如何在Salesforce的Aura组件中重用代码，特别是通过使用Helpers来简化我们的工作。 首先，想象一下你有一个Aura组件，里面有一个按钮。当用户点击这个按钮时，你希望弹出一个警告框，显示“ouch!”。同样地，当用户把鼠标移到按钮上时，你也希望弹出一个警告框，显示“oooh”。为了实现这个功能，你可能会在控制器（Controller）中写一些代码来处理这些事件。 但是，如果你有多个事件都需要弹出警告框，那么在每个事件处理函数中都写一遍弹出警告框的代码，就显得有点重复了。这时候，Helpers就派上用场了。 Helpers就像是一个工具箱，里面装满了各种工具（函数），你可以在需要的时候随时调用它们。在这个例子中，我们可以在Helper中写一个`showAlert`函数，专门用来弹出警告框。然后，在控制器中，当用户点击按钮或鼠标移到按钮上时，我们只需要调用这个`showAlert`函数，并传递相应的消息就可以了。 这样做的好处是，如果你的弹出警告框的逻辑需要修改，你只需要在Helper中修改一次，所有调用这个函数的地方都会自动更新，非常方便。 最后，记住一个最佳实践：在调用Helper函数时，总是把组件（component）作为参数传递进去。这样，Helper函数就可以访问和操作组件的状态和数据了。 总结一下，Helpers让我们能够重用代码，减少重复，提高开发效率。通过将常用的功能封装在Helpers中，我们可以让控制器更加简洁，逻辑更加清晰。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 80

  Finding Components By ID

  第 131 页

  让我们来聊聊如何在Salesforce的Lightning组件中通过ID查找组件。这个过程其实很简单，就像你在家里找东西一样，你知道东西放在哪个房间，然后直接去那个房间找就行了。 首先，假设你有一个组件，我们叫它`Sample.CMP`。在这个组件里，你有一个`<span>`标签，你想通过代码找到这个标签。为了找到它，你需要给这个标签一个“名字”，也就是一个ID。在Lightning组件中，我们使用`aura:id`来给组件内部的元素命名。 比如，你的`<span>`标签可能是这样的： ```html <span>这是一个示例</span> ``` 现在，你想在JavaScript代码中找到这个`<span>`标签。你可以使用`cmp.find(&quot;mySpan&quot;)`这个方法。这里的`cmp`是对当前组件的引用，`find`是一个函数，它接受一个参数，就是你之前给`<span>`标签设置的`aura:id`。 所以，你的JavaScript代码可能是这样的： ```javascript var spanElement = cmp.find(&quot;mySpan&quot;); ``` 这行代码的意思就是：“嘿，`cmp`，帮我找一下`mySpan`这个ID对应的元素。”然后，`cmp.find`就会返回一个指向这个`<span>`标签的DOM元素的引用，你可以用这个引用来做很多事情，比如改变它的内容、样式，或者添加事件监听器。 总结一下，通过`aura:id`给组件内部的元素命名，然后在JavaScript中使用`cmp.find`方法，你就可以轻松地找到并操作这些元素了。就像在家里找东西一样，有了名字，找起来就方便多了！</span></span></span></span></span>

  ▶ 播放视频 查看详情
• 81

  Getting and Setting Component Attribute Values

  第 132 页

  让我们来聊聊如何在Salesforce的Aura组件中获取和设置属性值。这个过程其实很简单，就像你在家里控制灯的开关一样。 首先，想象你有一个按钮，按钮上写着“点击我！”。当你点击这个按钮时，我们希望按钮上的文字变成“按钮已被点击！”。这就是我们要实现的功能。 在Aura组件中，我们首先定义了一个属性，叫做`Message`，它的类型是字符串，默认值是“点击我！”。这个属性就像是按钮上的标签，我们可以随时改变它。 接下来，我们有一个处理点击事件的函数，叫做`HandleClick`。在这个函数里，我们首先获取当前的`Message`值，这就像是你先看看灯现在是开还是关。我们使用`Component.get(&#39;v.message&#39;)`来获取这个值，并把它存储在变量`msg`中。 然后，我们把这个值打印到控制台，这样我们就可以在开发者工具中看到它。这就像是你告诉别人灯现在是开还是关。 接着，我们把`msg`的值改为“按钮已被点击！”，这就像是你决定把灯从关变成开。我们使用`Component.set(&#39;v.Message&#39;, msg)`来更新组件的属性值。 最后，因为Aura框架会自动检测到属性值的变化，所以组件会自动重新渲染，按钮上的文字就会更新为“按钮已被点击！”。这就像是你按下开关后，灯的状态立即改变。 总结一下，获取和设置组件属性值就像是你控制家里的灯一样简单。你只需要知道当前的灯的状态（获取属性值），然后决定是开还是关（设置属性值），剩下的就交给Aura框架来处理了。 希望这个解释能帮助你更好地理解如何在Aura组件中操作属性值。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 82

  Hiding and Showing Components

  第 133 页

  让我们来聊聊如何在Salesforce中通过代码来控制页面上组件的显示和隐藏。这其实是一个非常实用的技巧，尤其是在你想要根据用户的操作动态改变页面内容时。 首先，我们有几个非常方便的工具函数，它们可以帮助我们操作DOM元素的样式类。这些函数都是由Salesforce提供的，名字分别是`$A.util.addClass`、`$A.util.removeClass`和`$A.util.toggleClass`。 - `$A.util.addClass(el, className)`：这个函数的作用是给指定的DOM元素添加一个样式类。比如，如果你想给某个元素添加一个让它显示的样式，就可以用这个函数。 - `$A.util.removeClass(el, className)`：这个函数的作用正好相反，它是从指定的DOM元素中移除一个样式类。比如，如果你想隐藏某个元素，就可以用这个函数移除让它显示的样式。 - `$A.util.toggleClass(el, className)`：这个函数非常智能，它会检查指定的DOM元素是否已经有这个样式类。如果有，就移除它；如果没有，就添加它。这样你就可以通过一个函数来实现显示和隐藏的切换。 接下来，我们来看看如何使用这些函数来切换元素的可见性。Salesforce的SLDS框架提供了一些预定义的CSS类，这些类可以帮助我们控制元素的显示和隐藏。 - `.slds-show`：这个类会让元素显示出来，它通过将`display`属性设置为`block`来实现。 - `.slds-hide`：这个类会让元素隐藏起来，它通过将`display`属性设置为`none`来实现。 - `.slds-hidden`：这个类也会让元素隐藏，但它使用的是`visibility`属性，设置为`hidden`。这样元素虽然看不见了，但它仍然占据页面上的空间。 - `.slds-visible`：这个类会让元素显示出来，它通过将`visibility`属性设置为`visible`来实现。 - `.slds-collapsed`：这个类用于隐藏容器内的元素，它通过控制`height`和`overflow`属性来实现。 - `.slds-is-expanded`：这个类用于显示容器内的元素，它会让容器内的内容展开显示。 举个例子，假设你有一个按钮，点击这个按钮时，你想切换一个元素的显示和隐藏。你可以这样做： ```javascript toggleVisibility : function(component, event, helper) { var el = component.find(&quot;myElement&quot;).getElement(); $A.util.toggleClass(el, &#39;slds-hide&#39;); } ``` 在这个例子中，`myElement`是你想要切换显示和隐藏的元素的ID。当你点击按钮时，`toggleVisibility`函数会被调用，它会检查`myElement`是否有`slds-hide`这个类。如果有，就移除它，让元素显示出来；如果没有，就添加它，让元素隐藏起来。 这样，你就可以通过简单的代码实现动态的显示和隐藏效果了。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 83

  Hiding and Showing Components - 134

  第 134 页

  让我们来一步步理解这段代码。这段代码是一个简单的Salesforce Lightning组件，它的功能是当你点击一个按钮时，会隐藏或显示一个文本。 首先，我们来看一下HTML部分，也就是`Clickme.cmp`文件： ```html <div> <div>单击我</div> <div>现在你看到我了！</div> </div> ``` 这里有两个`div`元素。第一个`div`是一个按钮，上面写着“单击我”。当你点击这个按钮时，会触发一个叫做`clickMe`的JavaScript函数。第二个`div`有一个`aura:id`属性，这个属性是用来在JavaScript中引用这个元素的。这个`div`里面写着“现在你看到我了！”。 接下来，我们来看一下JavaScript部分，也就是`ClickmeController.js`文件： ```javascript ({ clickMe: function(component, event, helper) { var el = component.find(&#39;response&#39;); $A.util.toggleClass(el, &#39;slds-hide&#39;); } }) ``` 这个`clickMe`函数做了两件事情： 1. `component.find(&#39;response&#39;)`：这行代码是用来找到那个`aura:id`为`response`的`div`元素。 2. `$A.util.toggleClass(el, &#39;slds-hide&#39;)`：这行代码是用来切换`div`元素的`class`。`slds-hide`是Salesforce Lightning Design System（SLDS）中的一个类，它可以让元素隐藏。所以，每次你点击按钮时，这个`div`就会在显示和隐藏之间切换。 总结一下，这个组件的功能就是：当你点击“单击我”按钮时，下面的“现在你看到我了！”文本会显示或隐藏。 希望这个解释对你有帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 84

  Accessing Static Resources from JavaScript

  第 135 页

  同学们，今天我们来聊聊如何在JavaScript中删除静态资源。首先，静态资源是什么呢？简单来说，就是那些不会经常变化的文件，比如图片、CSS文件或者JavaScript文件。在Salesforce中，我们经常需要处理这些静态资源。 现在，假设你已经在Salesforce中上传了一个静态资源，比如一个JavaScript文件，我们叫它“myScript.js”。你可能会在某个Lightning组件中使用这个文件。但是，有时候你可能需要删除这个静态资源，或者替换它。 在JavaScript代码中，我们通常使用`$A.get(&#39;$Resource.resourceName&#39;)`来获取对静态资源的引用。这里的`resourceName`就是你上传的静态资源的名称。比如，如果你想引用“myScript.js”，你可以这样写： ```javascript var myResource = $A.get(&#39;$Resource.myScript&#39;); ``` 这样，`myResource`就包含了对你静态资源的引用。你可以使用这个引用来加载或者操作这个资源。 但是，如果你想要删除这个静态资源，你不能直接在JavaScript代码中删除它。因为静态资源是存储在Salesforce服务器上的，你需要通过Salesforce的管理界面来删除它。 总结一下，`$A.get(&#39;$Resource.resourceName&#39;)`是用来获取静态资源引用的，但删除静态资源需要通过Salesforce的管理界面来完成。希望这个解释对你们有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 85

  Asset Files and the $ContentAsset Global Value Provider

  第 136 页

  今天我们来聊聊Salesforce中的$Content Asset和全局价值提供程序。这个功能非常有用，尤其是在你使用Lightning组件时，想要引用一些图像、样式表或者JavaScript文件的时候。 首先，$Content Asset是一个全局价值提供程序，它允许你在Lightning组件中引用这些资产文件。你可以在组件的标记中，或者在JavaScript的控制器和帮助器代码中使用它。 从Spring &#39;19版本开始，$Content Asset有一个小限制：它不支持版本控制或者调整图像大小。也就是说，你只能获取到资源文件的最新版本，而且图像会以原始大小返回。 那么，如何在组件标记中使用$Content Asset呢？很简单，如果你想引用一个特定的资源文件，你可以使用这样的语法：$Content Asset.YourNamespace__assetName。如果你的组织没有命名空间，那就用$Content Asset.assetDeveloperName。这个语法无论用户是否已经登录都可以使用。 如果你需要引用归档文件中的内容资产，你可以在基本语法后面加上一个参数，像这样：$Content Asset.YourNamespace__assetName+&#39;pathinarchive=Images/sampleImage.jpg&#39;。这样就可以指定归档文件中的具体路径了。 总的来说，$Content Asset是一个非常方便的工具，可以帮助你在Lightning组件中轻松管理和使用各种资源文件。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 86

  Modifying the DOM – Best Practices

  第 137 页

  今天我们来聊聊在Salesforce Lightning框架中，如何正确地操作DOM（文档对象模型）。DOM简单来说，就是网页的结构，它允许我们通过JavaScript来访问和修改网页的内容、结构和样式。 首先，一个非常重要的原则是：，永远不要在渲染器外部直接修改DOM，。这是因为Lightning框架有自己的一套渲染机制，如果你在渲染器外部直接修改DOM，可能会被框架的渲染过程覆盖掉，导致你的修改无效。 但是，你可以在渲染器外部，读取DOM，。这意味着你可以查看DOM的状态，比如获取某个元素的属性或内容，但不要试图去改变它。 接下来，我们来看看如何安全地操作DOM。，尽可能使用表达式，，而不是直接设置DOM元素。表达式是Lightning框架提供的一种声明式编程方式，它可以帮助你更安全、更高效地更新UI。 如果你需要在控制器中改变组件的可见性，比如显示或隐藏一个元素，可以使用以下函数： - `$A.util.addClass()`：给元素添加一个CSS类。 - `$A.util.removeClass()`：从元素中移除一个CSS类。 - `$A.util.toggleClass()`：切换元素的CSS类（如果存在则移除，不存在则添加）。 这些函数是框架提供的安全操作DOM的方式，它们会确保你的修改不会被渲染过程覆盖。 最后，记住两个非常重要的准则： 1. ，不要在渲染器外部直接修改DOM，。 2. ，尽量使用框架提供的方法来操作DOM，，比如表达式和上述的类操作函数。 遵循这些最佳实践，可以帮助你避免很多潜在的问题，让你的Lightning组件更加稳定和高效。希望这些内容对你有帮助！

  ▶ 播放视频 查看详情
• 87

  Coding for Lightning Locker

  第 138 页

  今天我们来聊聊Salesforce的Lightning Locker，这是一个非常有趣且重要的安全架构。想象一下，如果你在一个大办公室里工作，每个人都有自己的小隔间，这样大家既能专注于自己的工作，又不会打扰到别人。Lightning Locker就像是给每个Lightning组件都提供了一个这样的小隔间，确保它们在自己的空间里安全运行，不会影响到其他组件。 首先，Lightning Locker自动启用了JavaScript的严格模式。这意味着你不需要在代码里特意写上“use strict”，它已经帮你做好了。这样可以帮助你避免一些常见的编码错误，比如忘记用var声明变量。而且，你使用的任何库也必须在严格模式下工作，这就像是确保所有的小工具都符合安全标准。 接下来，Lightning Locker限制了DOM访问。每个组件只能访问自己创建的元素，不能去碰其他组件的DOM。这就像是说，你只能在自己的隔间里活动，不能随便跑到别人的隔间去翻东西。这样可以防止一些不安全的操作，保护整个系统的安全。 此外，Lightning Locker还加强了内容安全策略（CSP）。它禁止了内联脚本和不安全的评估，这样可以减少跨站点脚本攻击的风险。不过要注意，IE 11不支持CSP，所以Salesforce建议使用其他浏览器来增强安全性。 最后，Lightning Locker还限制了全局引用的访问。你可以访问一些内部对象，比如数组，但对于像Windows这样的全局对象，Lightning Locker提供了安全版本。这些安全版本会自动控制对对象及其属性的访问，确保你的代码不会因为访问了不安全的全局对象而出问题。 总的来说，Lightning Locker通过隔离组件、启用严格模式、限制DOM访问、加强内容安全策略以及限制全局引用的访问，大大增强了Lightning组件的安全性。这样，你的代码不仅更安全，也更易于维护和支持。希望这些信息对你有所帮助！

  ▶ 播放视频 查看详情
• 88

  Using Locker API Viewer

  第 139 页

  今天我们来聊聊Salesforce中的Locker API查看器，以及它如何帮助我们理解和处理Web组件的安全性问题。 首先，Locker API查看器是一个非常实用的工具，它提供了一个简化的用户界面，基于Salesforce Lightning Design System（SLDS）进行设计，使得查看和理解API变得更加直观和容易。通过这个工具，我们可以探索JavaScript DOM API的安全版本，比如Windows对象的安全版本。 在Salesforce平台上，为了确保安全性，我们不能直接使用第三方的Web组件。这是因为Web组件是自定义元素，而定义这些自定义元素通常需要使用stomElements.Define API。这个API是全局的，意味着它允许你在全局范围内注册组件名称。这听起来很方便，但也带来了安全风险，因为攻击者可以注册任何名称，从而可能接管页面。 为了应对这个问题，Salesforce引入了Lightning Locker的SecureWindow包装器。这个包装器阻止了创建自定义Web组件的CustomElement方法。在Locker API查看器工具中，你可以看到SecureWindow包装器的列表，其中CustomElements返回的是未定义。这意味着，即使尝试使用CustomElement方法，也无法在SecureWindow环境下创建自定义Web组件，从而有效地防止了潜在的安全风险。 总结一下，通过使用Locker API查看器，我们不仅可以更安全地使用JavaScript DOM API，还可以确保我们的Salesforce应用不会因为使用不安全的第三方Web组件而受到威胁。希望这能帮助你更好地理解和使用Salesforce中的这些安全特性。

  ▶ 播放视频 查看详情
• 89

  Locker Console: Evaluate and Benchmark JavaScript

  第 140 页

  同学们，今天我们来聊聊Salesforce中的收件箱控制台，特别是如何评估和基准测试JavaScript代码。这个功能非常实用，尤其是在你开发或调试Lightning组件时。 首先，你会看到一个区域，标记为“1”，这里你可以粘贴或输入你的JavaScript代码。你可以在这里测试你的代码，看看它是否按预期工作，或者进行一些性能测试。 接下来是“切换”部分，标记为“2”。这里有两个选项：一个是启用或禁用Lightning收件箱，另一个是启用或禁用严格的MPS（Managed Package Sharing）。这些切换可以帮助你模拟不同的环境，确保你的代码在各种设置下都能稳定运行。 最后是“行动”部分，标记为“3”。这里有三个按钮： - “评估”：点击这个按钮，控制台会运行你输入的JavaScript代码，并显示结果。 - “Benchmark”：这个按钮非常有用，它可以让你比较使用和不使用Lightning Buttons时的代码性能。你会得到一些性能指标，帮助你优化代码。 - “清除结果”：如果你想要重新开始，或者清除之前的结果，点击这个按钮就可以了。 通过这些工具，你可以更有效地开发和测试你的Salesforce应用。希望这些信息对你们有帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 90

  Handling System Events

  第 141 页

  让我们来聊聊Salesforce中的系统事件，特别是关于组件的初始化和渲染过程。这个过程听起来可能有点技术性，但我会尽量用简单的方式来解释。 首先，想象一下你正在组装一个玩具。在你开始把零件拼在一起之前，你需要先准备好所有的零件，对吧？在Salesforce中，当你创建一个组件时，也会发生类似的事情。这个组件在真正显示出来之前，会经历一个叫做“初始化”的阶段。这个阶段会触发一个叫做“init”的事件。这个事件就像是你在组装玩具前，检查所有零件是否齐全的步骤。 这个“init”事件只会在组件第一次创建时触发一次，除非你特别告诉系统不要显示这个组件。如果你想在这个阶段做一些事情，比如设置一些初始值或者准备一些数据，你可以使用一个叫做“AURA:Handler”的工具来监听这个事件。通常，处理这个事件的函数会被命名为“doInit”，这是一个约定俗成的做法。 接下来，当所有的零件都准备好了，玩具就可以开始组装了。在Salesforce中，当组件准备好显示时，会触发另一个叫做“render”的事件。这个事件发生在“init”事件之后，意味着组件已经完全显示出来了。这时候，如果你想要做一些额外的处理，比如改变组件的样式或者添加一些动态效果，你就可以在这个阶段进行操作。处理“render”事件的方式和处理“init”事件非常相似。 总结一下，组件的初始化和渲染是两个重要的阶段，分别由“init”和“render”事件来标记。通过监听这些事件，你可以在组件的不同生命周期阶段执行特定的操作，从而更好地控制和定制你的组件。希望这个解释能帮助你更好地理解Salesforce中的组件事件处理！

  ▶ 播放视频 查看详情
• 91

  Unit 2: Getting Started - 143

  第 143 页

  同学们，今天我们来聊聊第2单元的内容。这一单元主要是关于如何使用HTML5和Salesforce的Lightning组件来开发应用程序。听起来有点技术性，但别担心，我会尽量用简单的话来解释。 首先，我们会回顾一下HTML5应用程序的一些基本特征、功能和限制。HTML5是一种非常流行的网页技术，它让网页更加动态和互动。然后，我们会学习如何使用Aura Components和Apex来开发Salesforce的移动应用程序。Aura Components是Salesforce提供的一种强大的工具，可以帮助我们快速构建用户界面。 接下来，我们会学习如何入门Lightning开发。Lightning是Salesforce的一个开发框架，它让开发更加快速和高效。我们还会学习如何使用CSS来美化我们的组件，让它们看起来更漂亮。 然后，我们会学习如何定义和操作组件的属性。属性是组件的一部分，它们决定了组件的行为和外观。我们还会学习如何处理系统和用户事件，这些事件是用户与应用程序交互时触发的。 当然，开发过程中难免会遇到问题，所以我们也会学习如何调试和排除故障。这就像是给应用程序看病，找出哪里出了问题，然后修复它。 最后，我们会学习如何与Apex合作。Apex是Salesforce的一种编程语言，它让我们可以在服务器端执行更复杂的逻辑。我们还会学习如何使用基本的Aura组件，提出和处理事件，以及使用Lightning数据服务进行CRUD操作。CRUD操作是指创建、读取、更新和删除数据，这是任何应用程序的基础。 好了，这就是第2单元的概述。希望你们能跟上，如果有任何问题，随时问我。我们开始吧！

  ▶ 播放视频 查看详情
• 92

  Topics - 144

  第 144 页

  同学们，今天我们来聊聊Salesforce的调试模式，特别是如何在Chrome和Safari浏览器中进行调试和故障排除。调试模式是开发过程中非常重要的一部分，它帮助我们找到并修复代码中的问题。 首先，我们来看看如何禁用和清除Lightning组件的缓存。有时候，我们修改了代码，但是页面上并没有反映出这些变化，这可能是因为浏览器缓存了旧的组件。在Chrome或Safari中，你可以通过开发者工具来清除缓存，确保加载的是最新的组件。 接下来，我们谈谈使用调试器。调试器是一个非常强大的工具，它允许我们逐步执行代码，查看每一步的执行情况。你可以在代码中设置断点，这样当代码执行到断点时，程序会暂停，你可以检查当前的变量值和程序状态。 检查网络流量也是一个重要的调试步骤。通过查看网络请求，我们可以了解数据是如何在客户端和服务器之间传输的，这对于诊断网络相关的问题非常有帮助。 使用Salesforce Lightning Inspector是一个很好的选择。这是一个Chrome扩展，专门用于调试Salesforce Lightning组件。它提供了组件树视图，让你可以清楚地看到页面上所有组件的结构和层次关系。此外，你还可以检查每个组件的性能，看看是否有性能瓶颈。 审查交易和日志记录事件也是调试过程中不可或缺的部分。通过查看交易日志，我们可以了解系统在后台执行了哪些操作，这对于理解复杂的业务流程非常有帮助。 最后，我们还可以检查客户端存储。这包括查看本地存储和会话存储中的数据，这些数据可能会影响应用的运行。 好了，这就是今天关于Salesforce调试模式的介绍。希望这些信息能帮助你们更有效地进行开发和故障排除。记得，调试是一个需要耐心和细致的过程，但掌握了这些技巧后，你们会发现它其实并不难。祝你们调试愉快！

  ▶ 播放视频 查看详情
• 93

  How to Enable Debug Mode – Option 1

  第 145 页

  让我们来详细聊聊如何在Salesforce中启用调试模式。这个功能对于开发人员来说非常有用，因为它可以帮助我们更轻松地调试JavaScript代码。 首先，默认情况下，Salesforce会压缩和混淆你的JavaScript代码。这意味着所有的函数名和代码都会变得难以阅读，这对于调试来说是非常不方便的。启用调试模式后，Salesforce会停止这种压缩和混淆，使得代码在浏览器的开发者工具中更加清晰易读。 那么，如何启用这个调试模式呢？其实步骤很简单： 1. 首先，你需要点击页面右上角的个人资料图标，这通常是一个小头像或者你的名字。 2. 接着，点击“设置”选项，这会带你进入你的个人设置页面。 3. 在设置页面中，找到并点击“高级用户详细信息”这一项。这里可能会有一个“编辑”按钮，点击它来进入编辑模式。 4. 在编辑模式下，你会看到一个“收件箱模式”的复选框。勾选这个复选框，就表示你启用了调试模式。 5. 最后，别忘了点击“保存”按钮来保存你的更改。 这样，你就成功启用了Salesforce的调试模式。现在，当你使用浏览器的开发者工具时，你的JavaScript代码将会更加清晰，帮助你更有效地解决运行时的问题。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 94

  How to Enable Debug Mode – Option 2

  第 146 页

  我们来聊聊如何在Salesforce中启用调试模式，特别是为了调试JavaScript代码。这个功能非常有用，但也要注意，它可能会让Salesforce运行得慢一些。 首先，启用调试模式主要是为了帮助开发者更容易地找到和修复JavaScript代码中的问题。如果你正在开发或者调试一个包含JavaScript的页面或者组件，这个模式可以让你看到更多的错误信息和调试信息。 要启用调试模式，你可以按照以下步骤操作： 1. 登录到你的Salesforce账户。 2. 点击右上角的设置图标，然后选择“设置”。 3. 在设置页面的左侧，找到“我的个人信息”部分，点击“调试模式”。 4. 在这里，你会看到一个选项叫做“启用调试模式”。勾选这个选项。 5. 最后，别忘了点击“保存”按钮来保存你的更改。 启用后，当你浏览Salesforce时，如果页面中有JavaScript错误，你会看到更多的调试信息。这对于找出问题所在非常有帮助。 但是，记得一点，调试模式会增加系统的负担，可能会导致Salesforce运行得比平时慢。所以，当你不需要调试的时候，最好关闭这个模式，以保持系统的流畅运行。 这就是启用调试模式的基本步骤和一些注意事项。希望这对你有所帮助！如果你有其他问题，随时问我哦。

  ▶ 播放视频 查看详情
• 95

  How to Enable Debug Mode – Option 3

  第 147 页

  让我们来聊聊这段代码和它的作用。首先，这段代码的目的是为Salesforce中的一个特定用户启用“收件箱模式”的调试功能。这个功能主要是为了帮助开发者在调试JavaScript代码时更加方便。 首先，我们来看代码的第一部分： ```apex 用户默认用户= [SELECT Id FROM User WHERE Name =&#39;用户用户&#39;]; ``` 这里，我们正在查询一个名为“用户用户”的用户。通过这个查询，我们获取了这个用户的ID，这样我们就可以对这个用户进行一些设置。 接下来是这部分： ```apex defaultUser. userPreferencesUsegModePref = true; ``` 这里，我们将这个用户的`userPreferencesUsegModePref`属性设置为`true`。这个属性控制着是否启用收件箱模式的调试功能。设置为`true`意味着启用这个功能。 最后，我们通过： ```apex 更新默认用户; ``` 来保存这个更改。这样，这个用户就启用了收件箱模式的调试功能。 这段代码通常会在一个叫做`EXFiles/data/DeliverUsers.html`的文件中，并且是在一个匿名Apex块中运行的，这个块是在创建scratch org的脚本末尾执行的。 需要注意的是，启用调试模式会让Salesforce的运行速度变慢，所以建议只在需要调试JavaScript代码的时候启用这个功能，并且只为那些正在积极调试的用户启用。 希望这个解释能帮助你理解这段代码的作用和如何使用它。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 96

  Using Chrome and Safari for Debugging and Troubleshooting

  第 148 页

  让我们来聊聊如何在开发过程中使用Chrome和Safari进行调试和故障排除。首先，Chrome浏览器使用的是WebKit引擎，这个引擎也是iOS和Android上移动浏览器的基础。这意味着，当你在Chrome中查看CSS样式时，它的呈现效果会非常接近用户在实际移动设备上的体验。 Chrome有一个非常棒的功能，就是它可以模拟不同的移动屏幕分辨率和行为。这对于开发响应式网页设计来说非常有用，因为你可以直接在浏览器中看到你的网页在不同设备上的表现。此外，Chrome还提供了一系列先进的调试工具，比如开发者工具，这些工具可以帮助你检查网页的HTML结构、CSS样式和JavaScript代码，从而更容易地找到并修复问题。 特别是对于安卓设备，Chrome允许你直接检查和调试运行在安卓设备浏览器上的HTML页面。这意味着你可以在不离开你的开发环境的情况下，直接看到和解决在安卓设备上出现的问题。 而对于iOS设备，Safari浏览器提供了类似的功能。你可以使用Safari的开发者工具来检查和调试在iOS设备上运行的HTML页面。这对于确保你的网页在苹果设备上也能完美显示非常重要。 调试JavaScript和CSS可能会有些挑战，尤其是在开发一个需要根据屏幕分辨率显示不同内容的响应式应用程序时。虽然最终你需要在各种浏览器和设备上测试你的工作，但在开发过程中，我们建议优先使用Google Chrome浏览器。这是因为Chrome不仅提供了强大的调试工具，还能很好地模拟移动设备的显示效果，帮助你更高效地解决问题。

  ▶ 播放视频 查看详情
• 97

  Using the Chrome Debugger

  第 149 页

  今天我们来聊聊Chrome浏览器自带的调试工具，这个工具非常强大，能帮助我们更好地理解和优化网页。你只需要在网页上点击右键，选择“检查”，这个调试器就会弹出来。 调试器有多个选项卡，每个都有不同的功能： 1. ，元素，：这个选项卡让你可以点击网页上的任何部分，查看它的HTML代码和应用的CSS样式。你可以直接在这里修改样式，实时看到效果。 2. ，内存，：这里可以帮助你检查JavaScript代码的内存使用情况。你可以拍摄内存快照，看看是否有内存泄漏的问题。 3. ，网络，：这个选项卡显示所有网络请求，特别是AJAX请求。你可以看到发送到服务器的数据和服务器返回的数据，这对于调试网络问题非常有用。 4. ，源，：在这里，你可以看到所有加载的JavaScript文件。你可以设置断点，一步步执行代码，还可以监视变量的变化。 5. ，审核，：这个功能可以帮助你发现并修复影响网站性能、可访问性和用户体验的问题。 6. ，资源，：你可以查看本地存储、会话存储、cookies等信息。 7. ，性能，：这个选项卡显示页面加载的各个阶段的时间，帮助你找到性能瓶颈。 8. ，应用程序，：类似于资源选项卡，但更专注于HTML5的本地存储和数据库。 9. ，控制台，：这里显示错误信息和通过console.log()等函数输出的信息。你也可以在这里直接运行JavaScript代码。 10. ，安全性，：提供关于网站安全证书的详细信息。 通过这些工具，你可以更深入地理解网页的运行机制，快速定位和解决问题。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 98

  Mobile Emulation and DOM Inspection

  第 150 页

  今天我们来聊聊Salesforce中的两个重要概念：移动仿真和多姆检查150。这两个工具对于开发和测试移动应用非常有用。 首先，，移动仿真，。想象一下，你正在开发一个移动应用，但你手头没有各种型号的手机来测试。这时候，移动仿真就派上用场了。Salesforce提供了一个移动仿真工具，可以让你在电脑上模拟不同型号的手机，看看你的应用在各种设备上的表现如何。这样，你就不用担心应用在某些手机上显示不正常了。 接下来是，多姆检查150，。这个工具主要是用来检查你的应用在移动设备上的性能。它可以帮助你发现那些可能影响应用加载速度的元素，比如图片太大、脚本加载太慢等。多姆检查150会给你一个详细的报告，告诉你哪些地方需要优化，让你的应用跑得更快、更流畅。 总结一下，移动仿真让你在开发阶段就能看到应用在不同设备上的表现，而多姆检查150则帮助你优化应用性能，确保它在各种设备上都能快速加载。这两个工具结合起来，能大大提升你的移动应用开发效率和用户体验。 希望这个解释对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 99

  Disabling and Clearing Lightning Component Cache

  第 151 页

  今天我们来聊聊Salesforce中的Lightning组件缓存问题。首先，为什么要禁用和清除Lightning组件的缓存呢？简单来说，如果你不禁用缓存，浏览器可能会继续使用旧的代码版本，而不是你最新修改的版本。这样，你在开发过程中做的更改可能不会立即生效，导致你看到的页面或功能并不是最新的。 那么，如何清除这个缓存呢？主要有两种方法： 1. ，在会话设置中禁用所有用户的缓存，：这是一个全局设置，一旦启用，所有用户的缓存都会被禁用。这样，无论哪个用户访问你的应用，他们都会看到最新的代码版本，而不是缓存中的旧版本。 2. ，启用收件箱模式，按用户手动禁用缓存，：这个方法更加灵活，允许你为特定的用户禁用缓存。比如，如果你只想在测试时禁用缓存，而不影响其他用户，就可以使用这个方法。 在浏览器中测试代码之前，你应该确保禁用了缓存机制。这样，你才能确保浏览器加载的是你最新的代码更改，而不是缓存中的旧版本。 总结一下，禁用和清除Lightning组件缓存是非常重要的，尤其是在开发和测试阶段。通过禁用缓存，你可以确保每次加载的都是最新的代码，从而避免因为缓存问题导致的错误或混淆。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 100

  Inspecting Network Traffic

  第 152 页

  今天我们来聊聊如何检查网络通讯，以及如何通过一些技巧来优化你的应用程序或组件的加载速度。 首先，想象一下你的浏览器就像是一个快递员，它需要从服务器那里“下载”你的应用程序或组件的所有部分，比如图片、代码等。这个过程就像快递员从仓库里取包裹一样。但是，如果包裹太多或者太大，快递员就会花更多的时间。同样，如果你的应用程序或组件有很多大文件，浏览器加载它们也会变慢。 那么，我们怎么知道浏览器加载这些文件需要多长时间呢？这里有一个小工具可以帮助我们，叫做“网络”选项卡。你可以把它想象成一个计时器，它会告诉你每个文件下载和渲染需要多长时间。而且，你还可以设置一个“带宽限制”，这就像是给快递员设定一个速度限制，看看在慢速网络下，你的应用程序或组件会加载得多慢。 接下来，我们会学习一些技巧来减少这些“包裹”的大小，让快递员能更快地完成任务。比如，我们可以通过“代码缩小”来减少代码文件的大小，就像把包裹压缩得更小一样。我们还可以使用“Base 64编码”来处理图片，这就像是把图片转换成一种更紧凑的格式，让它们更容易被传输。另外，使用“精灵”技术，我们可以把多个小图片合并成一个大图片，这样只需要下载一次，就能用到所有的小图片。 最后，我们还会学习如何使用“网络”面板来查看HTTP标头和响应。这就像是查看快递单上的详细信息，帮助我们了解每个文件是如何被请求和传输的。这对于解决应用程序或Web服务的问题非常有帮助，因为它能告诉我们哪里出了问题，比如某个文件没有被正确下载。 好了，这就是今天的内容。通过这些技巧，你可以让你的应用程序或组件加载得更快，用户体验也会更好。希望这些知识对你有帮助！

  ▶ 播放视频 查看详情
• 101

  Programmatically Setting Breakpoints

  第 153 页

  今天我们来聊聊如何在JavaScript中设置断点。断点是什么呢？简单来说，断点就是你在代码中设置的一个标记，当程序运行到这个标记时，它会暂停执行。这样你就可以检查当前的变量值、调用栈等信息，帮助你更好地理解和调试代码。 在JavaScript中，设置断点非常简单。你只需要在代码中插入一行命令：`debugger;`。没错，就是`debugger;`这个关键字。当你运行这段代码时，如果浏览器的开发者工具（比如Chrome的调试器）是打开的，程序就会在`debugger;`这一行暂停。 举个例子，假设你有这样一段代码： ```javascript function add(a, b) { debugger; return a + b; } let result = add(5, 10); console.log(result); ``` 当你运行这段代码时，程序会在`debugger;`这一行停下来。这时，你可以打开Chrome的开发者工具，切换到“Sources”标签，就能看到程序暂停的位置。你可以查看`a`和`b`的值，甚至可以一步步地执行代码，看看每一步发生了什么。 不过要注意的是，`debugger;`只有在开发者工具打开时才会生效。如果开发者工具没有打开，`debugger;`这行代码会被忽略，程序会继续正常运行。 所以，总结一下，如果你想在JavaScript中设置断点，只需要在代码中插入`debugger;`，然后确保浏览器的开发者工具是打开的。这样，当程序运行到`debugger;`时，它就会暂停，方便你进行调试。 希望这个解释对你有帮助！如果你有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 102

  Programmatically Setting Breakpoints - 154

  第 154 页

  让我们来聊聊如何在JavaScript中设置断点。断点，简单来说，就是你在代码中设置的一个“暂停点”，当程序运行到这里时，它会停下来，让你有机会检查当前的变量值、程序状态等。 在JavaScript中，你可以通过插入一个简单的命令来设置这样的断点，这个命令就是`debugger;`。你只需要在你希望程序暂停的地方写上`debugger;`这一行代码就可以了。 举个例子，假设你正在调试一个函数，你想看看在某个特定时刻变量的值是什么，你可以在那个时刻的代码前加上`debugger;`。当你在浏览器中运行这段代码，并且打开了开发者工具（比如Chrome的调试器），程序运行到`debugger;`这一行时，就会自动暂停。 这时候，你可以看到程序停在了“源”部分，也就是你的JavaScript代码那里。你可以查看当前的变量值，单步执行代码，或者继续运行程序。这就像是在你的代码中放了一个“红绿灯”，让程序在你需要的时候停下来，给你时间去检查和理解程序的运行状态。 所以，`debugger;`是一个非常方便的工具，可以帮助你更有效地调试JavaScript代码。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 103

  Stepping Through Your Code

  第 155 页

  让我们来聊聊图28中的“步骤控制”功能。想象一下，你在调试代码时，就像是在走迷宫。每一步都可能有新的发现，也可能遇到问题。这时候，“步骤控制”就像是你的指南针，帮助你一步步地探索这个迷宫。 首先，你可以使用调试器控件来逐步执行代码。这就像是你在迷宫中一步一步地走，每走一步，你都能看到周围的环境变化。在代码中，每执行一步，你都能看到变量的值是如何变化的，这样你就能更好地理解代码的运行逻辑。 其次，你还可以设置“监视运算式”。这就像是你在迷宫中设置了一些标记，帮助你记住某些重要的位置。在代码中，这些标记就是变量。通过设置监视运算式，你可以实时查看这些变量的值是如何随着代码的执行而变化的。这样，你就能更清楚地看到代码是如何影响这些变量的。 总的来说，步骤控制和监视运算式是调试代码时非常强大的工具。它们帮助你一步步地理解代码的运行过程，就像是你在迷宫中一步步找到出口一样。希望这个比喻能帮助你更好地理解这些概念。

  ▶ 播放视频 查看详情
• 104

  Outputting Variables to the Debugger Console

  第 156 页

  同学们，今天我们来聊聊如何在Chrome调试器中使用JavaScript来输出变量。这在我们开发过程中非常有用，尤其是在调试和测试应用程序时。 首先，我们有三个常用的函数可以帮助我们输出信息到控制台：`console.log()`、`console.error()` 和 `console.warn()`。 1. ，console.log()，：这是最常用的方法，用来输出一般的信息。比如，你想看看某个变量的值是什么，就可以用这个函数。它会在控制台中以普通信息的形式显示出来。 2. ，console.error()，：这个函数用来输出错误信息。如果你在代码中检测到某些错误情况，可以用这个函数来输出错误信息。这样，错误信息会以更显眼的方式显示在控制台中，通常还会带有红色的错误图标，帮助你快速定位问题。 3. ，console.warn()，：这个函数用来输出警告信息。它和`console.error()`类似，但通常用于那些不是特别严重的问题，或者是一些需要注意的情况。警告信息通常会以黄色显示，提醒你注意。 在使用这些函数时，记得在测试应用程序时保持控制台打开。这样，一旦有错误或警告信息抛出，你就可以立即看到并进行检查。这就像是在开车时，仪表盘上的警告灯亮起，你会立即注意到并采取行动。 最后，Chrome调试器还允许你根据信息的类型来过滤控制台消息。比如，你可以选择只查看错误信息，或者只查看警告信息。这样可以帮助你更高效地找到你需要关注的信息。 好了，这就是今天的内容。希望这些技巧能帮助你在开发过程中更好地调试和测试你的应用程序。记得多实践，熟能生巧！

  ▶ 播放视频 查看详情
• 105

  Salesforce Lightning Inspector

  第 157 页

  大家好，今天我们来聊聊一个非常实用的工具——Salesforce Lightning Inspector。这是一个Chrome浏览器的插件，你可以从Chrome Web Store免费下载安装。它的主要功能是帮助我们更轻松地检查和导航Salesforce Lightning组件的结构。 首先，这个工具可以让你查看组件的创建时间图表。这是什么意思呢？简单来说，就是你可以看到每个组件在页面上加载和渲染的时间。这对于识别性能瓶颈特别有帮助。比如，如果你发现某个组件加载特别慢，你就可以针对性地优化它，提升整个页面的响应速度。 其次，Salesforce Lightning Inspector还能让你监视和修改服务器的响应。这意味着你可以更快地验证服务器交互是否正确。比如，当你进行数据提交或更新时，你可以实时看到服务器的反馈，确保一切按预期进行。 此外，这个工具还允许你导航组件树。你可以查看页面上所有的组件以及它们关联的DOM元素。这对于理解页面结构和调试非常有帮助。你可以清楚地看到每个组件的层级关系，以及它们是如何相互作用的。 最后，Salesforce Lightning Inspector还能跟踪事件的触发和处理顺序。这意味着你可以看到用户操作（比如点击按钮）后，事件是如何在组件之间传递和处理的。这对于调试复杂的事件流非常有帮助。 总的来说，Salesforce Lightning Inspector是一个非常强大的工具，特别适合那些需要深入理解和优化Salesforce Lightning应用的开发者。希望这些信息对你们有所帮助！

  ▶ 播放视频 查看详情
• 106

  Using the Salesforce Lightning Inspector

  第 158 页

  让我们来聊聊Salesforce Lightning Inspector这个工具，它就像是一个放大镜，帮助我们更清楚地看到Salesforce Lightning应用的内部运作。 首先，Lightning Inspector是Chrome浏览器的一个插件，安装后，它会在Chrome的开发者工具中新增一个选项卡。你可以通过这个选项卡来查看和调试你的Lightning组件。 当你打开这个工具，你会看到一个组件树，这就像是一棵家族树，展示了应用中所有组件的层次结构。你可以点击左侧的组件，右侧就会显示这个组件的详细属性，比如它的状态、数据等。 接下来，我们来看看Performance选项卡。这里，你可以看到每个组件渲染所花费的时间，单位是毫秒。如果你把鼠标悬停在那些彩色的条形图上，工具的左下角会显示更详细的性能数据，帮助你了解哪些部分可能需要优化。 Salesforce还提供了一些内置的应用程序，它们带有交易标记。这些标记可以帮助你查看在这些交易中进行的各种操作的详细指标。虽然目前你不能自己创建这些交易，但你可以看到你的组件发出的XHR请求的数量，这对于理解应用的网络交互非常有用。 最后，我们来看看事件日志功能。这个功能可以捕获Lightning框架中所有的用户和系统事件。你可以看到是哪个组件触发了事件，事件处理程序接收了哪些参数，甚至可以直接跳转到处理这些事件的代码部分。此外，你还能看到处理这些事件所花费的时间，这对于性能调优非常有帮助。 总的来说，Salesforce Lightning Inspector是一个非常强大的工具，它可以帮助开发者深入理解应用的运行机制，优化性能，确保应用的高效和稳定运行。希望这些信息对你有所帮助！

  ▶ 播放视频 查看详情
• 107

  Using the Salesforce Lightning Inspector - 159

  第 159 页

  让我们来聊聊Salesforce Lightning Inspector中的Actions选项卡。这个工具非常有用，特别是当你想要了解你的应用程序是如何与Apex进行交互的时候。 首先，Actions选项卡会显示所有从你的应用程序对Apex进行的调用。这些调用被分成了三类：挂起的、正在运行的和已完成的。这样，你可以一目了然地看到哪些操作还在等待，哪些正在处理，哪些已经完成了。 对于每一个事务，你都可以看到传递给Apex方法的参数以及Apex返回的响应。这就像是你在看一个对话记录，知道双方都说了什么。更有趣的是，你还可以为Apex方法设置重写。这意味着你可以调整服务器的响应，这样就能更容易地测试和调试你的应用程序中的不同分支和错误处理逻辑。 你还可以根据操作的状态来过滤这些操作。比如，你可以只看那些可以缓存的操作，或者只看那些已经成功执行的操作。如果你在调查性能问题，这些信息会非常有用。例如，你可以查看哪些操作被缓存了，哪些没有，这可能会帮助你找到性能瓶颈。 此外，Lightning框架还允许你在HTML5的IndexedDB存储库中持久化和缓存结构化数据。Lightning Inspector提供了一个简单的界面，让你可以查看浏览器中缓存的数据。这就像是打开了一个宝箱，里面装满了你的应用程序使用的数据。 总的来说，Lightning Inspector的Actions选项卡是一个非常强大的工具，它帮助你更好地理解和优化你的Salesforce应用程序。通过它，你可以更深入地了解应用程序的运行情况，确保一切都在顺利进行。

  ▶ 播放视频 查看详情
• 108

  Experiment with Debugging and Logging

  第 160 页

  同学们，今天我们来做一个非常有趣的实验，叫做“使用收件箱和日志进行实验160”。这个实验主要是帮助我们更好地理解如何在Salesforce中使用调试器和日志记录功能。我们会通过几个简单的任务来掌握这些技能。 首先，我们来看一下任务列表： 1. ，日志变量输出到调试器，：这个任务要求我们把一些变量的值输出到调试器中。这样做的目的是为了在代码运行时，能够实时查看这些变量的值，帮助我们更好地理解代码的执行过程。 2. ，交互式地浏览您的代码，：在这个任务中，我们会学习如何一步步地浏览我们的代码。通过这种方式，我们可以更清楚地看到代码的每一步是如何执行的，以及每一步的结果是什么。 3. ，直接从浏览器控制台卸载功能，：这个任务稍微有点高级，但也很实用。我们会学习如何直接从浏览器的控制台卸载一些功能。这个技巧在调试和测试时非常有用，可以帮助我们快速验证某些功能是否正常工作。 整个实验预计需要20分钟完成。在这段时间里，我们会通过实际操作来掌握这些技能。记住，调试和日志记录是开发过程中非常重要的部分，它们能帮助我们更快地找到问题并解决问题。 好了，现在让我们开始吧！首先，打开你的Salesforce开发环境，准备好你的代码，我们一步一步来完成这些任务。

  ▶ 播放视频 查看详情
• 109

  Unit 2: Getting Started - 161

  第 161 页

  同学们，今天我们来聊聊第2单元的内容。这一单元主要是关于如何使用HTML5和Salesforce的Lightning组件来开发应用程序。听起来有点技术性，但别担心，我会用简单的方式来解释。 首先，我们会回顾一下HTML5应用程序的特点、功能和限制。HTML5是一种非常流行的网页技术，它让网页更加动态和互动。然后，我们会学习如何使用Aura Components和Apex来开发Salesforce的移动应用程序。Aura Components是Salesforce提供的一种强大的工具，可以帮助我们快速构建用户界面。 接下来，我们会学习如何入门Lightning开发。Lightning是Salesforce的一个框架，它让开发更加快速和高效。我们还会学习如何使用CSS来美化我们的组件，让它们看起来更吸引人。 然后，我们会学习如何定义和操作组件的属性。属性是组件的一部分，它们决定了组件的行为和外观。我们还会学习如何处理系统和用户的事件，比如点击按钮或者提交表单。 当然，开发过程中难免会遇到问题，所以我们也会学习如何调试和排查应用程序中的错误。这就像是在找bug，找到并修复它们，让应用程序运行得更顺畅。 最后，我们会学习如何与Apex合作。Apex是Salesforce的一种编程语言，它让我们能够编写更复杂的逻辑。我们还会学习如何使用基本的Aura组件，提出和处理事件，以及如何使用Lightning数据服务进行CRUD操作。CRUD操作是指创建、读取、更新和删除数据，这是任何应用程序的基础。 好了，这就是第2单元的概述。希望你们能跟上我的节奏，我们一起探索Salesforce开发的奇妙世界吧！

  ▶ 播放视频 查看详情
• 110

  Topics - 162

  第 162 页

  同学们，今天我们来聊聊如何在Salesforce中使用Apex类来增强你的Lightning应用程序的功能。我们会从创建Apex类开始，然后逐步深入到如何使这些类在Lightning应用中发挥作用。 首先，，创建Apex类，。Apex类是Salesforce中的一种编程结构，允许你定义方法和变量来处理业务逻辑。你可以通过Salesforce的开发者控制台来创建Apex类，这就像是在你的应用程序中创建了一个小型的“大脑”，它可以处理数据、执行逻辑操作等。 接下来，，使Apex控制器功能可用于Lightning应用程序，。在Lightning组件中，你可以通过Apex控制器来处理服务器端的逻辑。这意味着当用户在Lightning应用中执行操作时，比如点击一个按钮，这个操作可以触发Apex控制器中的方法，执行相应的服务器端逻辑。 关于，安全，，Salesforce提供了多种机制来确保你的Apex代码安全运行。例如，你可以使用SOQL注入防护来防止恶意数据攻击，确保你的查询是安全的。 ，生成动态SOQL，是另一个重要的技能。SOQL是Salesforce对象查询语言，用于从Salesforce数据库中检索数据。动态SOQL允许你在运行时构建查询，这使得你的应用更加灵活和强大。 在，收件箱中创建动态查询，，你可以根据用户的需求动态地构建查询，比如根据用户选择的过滤器来检索特定的记录。 ，调用服务器端操作，是Lightning组件与Apex控制器交互的方式。当你在Lightning组件中调用一个服务器端方法时，实际上是在请求Apex控制器执行某些操作，比如保存或检索数据。 为了简化代码，你可以，定义服务器调用的通用助手函数，。这些函数可以在多个地方重复使用，减少代码冗余，提高代码的可维护性。 ，使用继承进行代码共享，是面向对象编程中的一个重要概念。在Apex中，你可以创建一个基类，然后让其他类继承这个基类。这样，子类就可以重用基类中的代码，减少重复代码的编写。 ，定义抽象组件，可以帮助你创建更通用的组件，这些组件可以在不同的上下文中使用。抽象类是不能实例化的类，它们通常用作其他类的基类。 最后，，使用继承属性、事件、帮助者和控制器，，你可以构建更加模块化和可重用的代码结构。这不仅提高了代码的效率，也使得维护和更新变得更加容易。 希望这些内容能帮助你们更好地理解如何在Salesforce中使用Apex类来增强Lightning应用的功能。如果有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 111

  Using the Query Editor

  第 163 页

  同学们，今天我们来聊聊Salesforce中的查询编辑器，特别是在开发人员控制台里的使用。这个工具非常强大，可以帮助我们验证查询语句的正确性，同时也能执行一些基本的数据维护任务。 首先，打开开发人员控制台。你可以通过点击右上角的设置图标，然后选择“开发者控制台”来进入。一旦进入，你会看到界面下方有一个查询编辑器的标签页。 在查询编辑器中，你可以输入SOQL（Salesforce Object Query Language）查询语句。SOQL是Salesforce用来查询数据的语言，类似于SQL。比如，如果你想查询所有联系人的名字和邮箱，你可以输入： ```soql SELECT Name, Email FROM Contact ``` 输入完查询语句后，点击“执行”按钮。系统会立即运行这个查询，并在下方显示结果。这样，你就可以验证你的查询是否正确，数据是否符合预期。 除了查询，查询编辑器还可以用来执行一些基本的数据维护任务。比如，你可以使用DML语句（如INSERT、UPDATE、DELETE）来操作数据。举个例子，如果你想更新某个联系人的邮箱，你可以输入： ```soql UPDATE Contact SET Email = &#39;newemail@example.com&#39; WHERE Id = &#39;003XXXXXXXXXXXX&#39; ``` 执行这个语句后，系统会更新指定联系人的邮箱地址。 总之，查询编辑器是一个非常实用的工具，不仅能帮助你验证查询，还能进行一些简单的数据操作。希望你们能好好利用它，提升工作效率。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 112

  Creating an Apex Class

  第 164 页

  让我们一步一步来，创建一个Apex Class，也就是我们说的Apex类。这个类将作为服务器端控制器，帮助我们处理一些后台的逻辑操作。 首先，打开你的Salesforce开发人员控制台。你可以通过点击右上角的齿轮图标，然后选择“开发者控制台”来打开它。 在开发人员控制台中，你会看到顶部有一个菜单栏。点击“文件”菜单，然后选择“新建”，接着选择“Apex类”。这时候，会弹出一个对话框，让你输入这个类的名称。你可以根据你的需求来命名，比如“MyServerController”。 输入完名称后，点击“确定”按钮。这样，一个新的Apex类文件就会在开发人员控制台中打开，并且已经为你生成了一些基本的代码结构。 现在，你需要在类的主体中为每个服务器端操作定义一个函数。这些函数将包含你希望服务器执行的逻辑。比如，如果你想要一个函数来处理数据的保存，你可以这样写： ```apex public class MyServerController { // 这是一个示例函数，用于保存数据 public static void saveData(String data) { // 这里写保存数据的逻辑 System.debug(&#39;数据已保存: &#39; + data); } } ``` 在这个例子中，`saveData` 是一个公共的静态方法，它接受一个字符串类型的参数 `data`，并在控制台中打印出保存的数据。 你可以根据需要添加更多的函数，每个函数都可以执行不同的服务器端操作。记得，每个函数都应该有明确的职责，这样代码会更加清晰和易于维护。 完成这些步骤后，你就成功地创建了一个Apex服务器端控制器。这个控制器现在可以在你的Salesforce应用中被调用，执行你定义的服务器端逻辑了。 希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 113

  Making Apex Controller Methods Available to a Lightning App

  第 165 页

  让我们一步一步来理解如何使Apex控制器方法在Lightning组件中可用。 首先，我们需要在Apex控制器中定义一个方法，并使用`@AuraEnabled`注解来标记它。这个注解告诉Salesforce，这个方法可以被Lightning组件调用。例如，我们有一个名为`FindAccount`的Apex类，里面有一个方法`getData`，它接受一个账户ID作为参数，并返回该账户的名称列表。 ```apex public class FindAccount { @AuraEnabled public static List getData(Id actID) { return [SELECT Name FROM Account WHERE Id = :actID]; } } ``` 接下来，我们需要在Lightning组件中引用这个Apex控制器。我们通过在组件的``标签中添加`controller`属性来实现这一点，属性值就是我们Apex控制器的名称，这里是`FindAccount`。 ```html ``` 在组件的JavaScript控制器中，我们可以调用Apex控制器中的方法。首先，我们通过`component.get(&quot;c.methodName&quot;)`来获取Apex方法的引用，然后使用`setParams`方法设置参数。接着，我们定义一个回调函数来处理Apex方法的返回结果，并使用`$A.enqueueAction`将动作加入队列执行。 ```javascript ({ retrieveAccount: function(component, event, helper) { var action = component.get(&quot;c.getData&quot;); action.setParams({ actID: component.get(&quot;v.actId&quot;) }); action.setCallback(this, function(response) { var state = response.getState(); if (component.isValid() &amp;&amp; state === &quot;SUCCESS&quot;) { component.set(&quot;v.accountName&quot;, response.getReturnValue()); } }); $A.enqueueAction(action); } }) ``` 这样，当Lightning组件加载或某个事件触发时，`retrieveAccount`函数就会被调用，它会执行Apex控制器中的`getData`方法，并将返回的账户名称设置到组件的属性中，供组件使用。 总结一下，要使Apex控制器方法在Lightning组件中可用，我们需要： 1. 在Apex类中使用`@AuraEnabled`注解标记方法。 2. 在Lightning组件的``标签中指定控制器。 3. 在JavaScript控制器中调用Apex方法，并处理返回结果。 这样，Lightning组件就可以与Apex控制器进行交互，获取或操作Salesforce中的数据了。

  ▶ 播放视频 查看详情
• 114

  Calling a Server-Side Action

  第 166 页

  让我们来聊聊如何在Salesforce的Lightning组件中调用服务器端的操作。这个过程其实就像是你去餐厅点餐，然后等待服务员把菜端上来一样。 首先，你需要创建一个“点餐单”，也就是在代码中创建一个服务器端操作的实例。这个操作可能是获取一些数据，比如学生的信息。你可以这样做： ```javascript var action = component.get(&quot;c.getStudents&quot;); ``` 这里，`getStudents`就是你在服务器端定义的一个方法，用来获取学生数据。 接下来，你可能需要告诉服务员一些特别的指示，比如你想要哪种菜。在代码中，这相当于设置一些参数： ```javascript action.setParams({ instructorId: component.get(&quot;v.instructorId&quot;), courseDeliveryId: component.get(&quot;v.courseDeliveryId&quot;) }); ``` 这些参数会传递给服务器端的方法，帮助它知道你需要哪些具体的数据。 然后，你需要告诉服务员，当菜准备好了之后，应该怎么做。在代码中，这就是设置一个回调函数： ```javascript action.setCallback(this, function(response) { var state = response.getState(); if (component.isValid() &amp;&amp; state === &quot;SUCCESS&quot;) { component.set(&quot;v.students&quot;, response.getReturnValue()); } else if (state === &quot;ERROR&quot;) { var errors = response.getError(); if (errors) { console.error(&quot;Errors&quot;, errors); if (errors[0] &amp;&amp; errors[0].message) { throw new Error(&quot;Error: &quot; + errors[0].message); } } else { throw new Error(&quot;Unknown error&quot;); } } }); ``` 这个回调函数会在服务器返回数据后执行。如果一切顺利，数据会被设置到组件的属性中；如果有错误，就会在控制台打印错误信息。 最后，你需要把点餐单交给服务员，也就是把操作发送到服务器： ```javascript $A.enqueueAction(action); ``` `$A.enqueueAction`这个函数会把你的操作加入到队列中，Salesforce框架会把这些操作打包，一次性发送到服务器，这样可以减少网络流量，提高效率。 这就是整个调用服务器端操作的过程。希望这个比喻能帮助你更好地理解这个过程！

  ▶ 播放视频 查看详情
• 115

  Verifying Security Permissions

  第 167 页

  让我们来聊聊这段代码的作用和逻辑。这段代码主要是用来检查用户对某个Salesforce对象（sObject）及其字段是否有读取或编辑的权限。我们可以把它分成几个步骤来理解。 ### 第一步：获取对象的类型 首先，代码通过`Schema.getGlobalDescribe().get(soName)`来获取对象的类型。`soName`是你传入的对象名称，比如“Account”或“Contact”。这一步的目的是获取这个对象的元数据，也就是它的结构信息。 ### 第二步：获取对象的所有字段 接下来，代码通过`soType.getDescribe().fields.getMap()`获取这个对象的所有字段，并把这些字段的名称和它们的元数据信息存储在一个Map中。这个Map的键是字段名，值是对应的字段元数据。 ### 第三步：检查对象的权限 然后，代码会根据你传入的权限类型（读取或编辑）来检查用户是否有相应的权限。如果是读取权限，代码会调用`soType.getDescribe().isAccessible()`来检查用户是否有权限读取这个对象。如果没有权限，函数会返回`false`，表示用户不能读取这个对象。 ### 第四步：字段级别的权限检查（未完成） 代码中提到了字段级别的权限检查，但这里没有完全展示出来。通常，你还需要遍历传入的字段列表，检查每个字段的权限。比如，对于读取权限，你可以使用`fieldDescribe.isAccessible()`来检查用户是否有权限读取这个字段。 ### 注意事项 代码中还提到了一点，就是在Lightning组件中调用Apex时，字段级别的安全性不会被自动启用。所以如果你在Lightning环境中使用这段代码，需要特别注意字段级别的权限检查。 ### 总结 这段代码的核心逻辑是： 1. 获取对象的元数据。 2. 获取对象的所有字段。 3. 检查用户是否有权限读取或编辑这个对象。 4. （未完成）检查用户是否有权限读取或编辑指定的字段。 希望这个解释能帮助你更好地理解这段代码的作用和逻辑！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 116

  Verifying Security Permissions - 168

  第 168 页

  让我们来聊聊这段代码的作用和背后的逻辑。 首先，这段代码的主要目的是，验证用户是否有权限访问或编辑某个对象的字段，。在Salesforce中，权限管理是非常重要的，尤其是在处理敏感数据时。我们需要确保用户只能访问或修改他们有权限的字段。 ### 代码的逻辑可以分为两部分： 1. ，检查字段的访问权限， 2. ，检查字段的编辑权限， #### 1. 检查字段的访问权限 ```java For(字符串fieldToCheck：字段){ 如果是(！allFields.get(fieldToCheck).getDescribe().isAccessible()){ 返回FALSE； } } ``` - 这段代码会遍历一个字段列表（`字段`），然后检查每个字段是否可以被当前用户，访问，。 - `isAccessible()` 是一个方法，用来判断用户是否有权限查看这个字段。 - 如果某个字段不可访问，代码会直接返回 `FALSE`，表示用户没有权限。 #### 2. 检查字段的编辑权限 ```java Else If(permissionRequired==Permissions.编辑){ //检查对象级别的权限 如果(！soType.getDescribe().isUpdateable()){ 返回False； } //检查每个字段的权限 For(字符串fieldToCheck：字段){ 如果是(！allFields.get(fieldToCheck).getDescribe().isUpdateable()){ 返回FALSE； } } } ``` - 如果用户需要的是，编辑权限，，代码会先检查整个对象是否可以被编辑（`isUpdateable()`）。 - 如果对象不可编辑，直接返回 `False`。 - 如果对象可编辑，代码会继续检查每个字段是否可以被编辑（`isUpdateable()`）。 - 如果某个字段不可编辑，代码会返回 `FALSE`。 #### 最后 如果所有检查都通过了，代码会返回 `TRUE`，表示用户有权限访问或编辑这些字段。 --- ### 重要提醒 在Lightning组件中调用Apex时，，字段级别的安全性不会自动启用，。这意味着即使用户没有权限访问某个字段，Apex代码仍然可以读取或修改它。为了避免这个问题，你可以使用，动态Apex，来在执行查询之前验证用户是否有权限访问字段。 例如，你可以使用 `Schema.DescribeFieldResult` 来动态检查字段的权限： ```java Schema.DescribeFieldResult fieldDescribe = Schema.sObjectType.Account.fields.Name.getDescribe(); if (!fieldDescribe.isAccessible()) { // 用户没有权限访问这个字段 } ``` --- ### 总结 这段代码的核心思想是，确保用户只能操作他们有权限的字段，。通过检查字段的 `isAccessible()` 和 `isUpdateable()`，我们可以避免用户越权操作数据。同时，在Lightning组件中调用Apex时，记得手动检查字段权限，以确保数据安全。 希望这段解释对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 117

  Verifying Security Permissions - 169

  第 169 页

  让我们来聊聊这段代码。这段代码是用在Salesforce平台上的，主要是用来获取一些技术人员的联系信息。我们来看一下它是怎么工作的。 首先，这段代码定义了一个叫做`getTechnicians`的方法。这个方法的作用是从Salesforce数据库中获取一些技术人员的联系信息，比如他们的电子邮件、名字、状态等。 在代码的开头，我们定义了一个列表`fieldsToAccess`，这个列表包含了我们想要获取的字段名称，比如“电子邮件”、“名字”和“状态__c”。 接下来，代码使用了一个叫做`CheckDeliver.checkAllendix`的方法来检查当前用户是否有权限访问这些字段。如果用户没有权限，代码就会抛出一个错误，提示用户“检查失败”。 如果用户有权限，代码就会执行一个查询，从“联系人”对象中获取那些记录类型为“Technician”的记录，并且只选择我们之前定义的字段。最后，这个方法会返回这些技术人员的列表。 在实际使用中，你可以在其他地方调用这个`getTechnicians`方法，来获取你需要的数据。比如，你可能在一个Aura组件中调用这个方法，来显示技术人员的列表。 这就是这段代码的基本工作原理。希望这个解释能帮助你理解这段代码的作用和如何使用它。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 118

  Generating Dynamic SOQL

  第 170 页

  让我们来聊聊动态SOQL查询。想象一下，你有一个魔法盒子，这个盒子可以根据你告诉它的条件，从Salesforce数据库中变出你需要的数据。这个魔法盒子就是动态SOQL查询。 当你使用动态SOQL时，你可以用`select()`这个魔法咒语来告诉盒子你想要什么数据。这个咒语可以在很多地方使用，比如在你写代码的时候，或者在一个循环中。你告诉盒子你想要的数据，盒子就会按照你的要求去数据库里找。 找到数据后，盒子会把数据交给你，你可以把这些数据放在一个具体的对象里，比如一个账户（Account）或者一个你自己定义的对象（比如MyCustomBody__c）。如果你不确定数据会是什么类型，你也可以让盒子把数据放在一个通用的sObject类型里。 但是，这里有个小规则：盒子在给你数据之前，会检查一下你告诉它的类型和它找到的数据类型是不是匹配。如果不匹配，盒子就会生气，抛出一个错误。这样，你就不需要自己再去把数据从一个类型转换成另一个类型了，盒子会帮你搞定。 所以，动态SOQL查询就像是一个聪明的助手，它不仅能帮你找到数据，还能确保数据的类型是正确的，让你的工作更加轻松。

  ▶ 播放视频 查看详情
• 119

  Executing a Dynamic Query at Runtime

  第 171 页

  今天我们来聊聊如何在Salesforce的Apex代码中执行动态SOQL查询，并且如何防止SQL注入攻击。 首先，我们来看一个例子，这个例子是一个名为`StudentBrowser`的类，里面有一个方法`getStudents`。这个方法的作用是根据传入的`CourseDeliveryID`或`InstructorID`来查询相关的学生信息。 在这个方法中，我们首先定义了一个基础的查询字符串`query`，它从`Contact`对象中选择了一些字段，比如`ID`、`Name`、`Email`等。然后，我们根据传入的参数`CourseDeliveryID`或`InstructorID`来动态地添加`WHERE`子句。如果`CourseDeliveryID`不为空，我们就添加一个条件，查询那些参加了特定课程交付的学生。如果`InstructorID`不为空，我们就查询那些由特定讲师授课的学生。 这里需要注意的是，我们在构建查询字符串时，使用了绑定变量（如`:CourseDeliveryID`和`:InstructorID`）来防止SQL注入攻击。绑定变量是Apex提供的一种安全机制，它可以确保用户输入的数据不会被解释为SQL代码的一部分，从而防止恶意用户通过输入特殊字符来篡改我们的查询。 此外，我们还使用了`String.escapeSingleQuotes()`函数来进一步确保安全。这个函数会将字符串中的单引号进行转义，防止它们被误解为SQL语句的一部分。 最后，我们使用`Database.query()`方法来执行这个动态构建的SOQL查询，并返回查询结果。 总结一下，动态SOQL查询非常灵活，但同时也需要注意安全性。通过使用绑定变量和`String.escapeSingleQuotes()`函数，我们可以有效地防止SQL注入攻击，确保我们的应用安全可靠。 希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 120

  Defining a Generic Helper Function for Server Calls

  第 172 页

  让我们来聊聊如何在Salesforce中定义一个通用的帮助器函数来调用服务器端的方法。这个函数可以帮助我们简化代码，让调用服务器端逻辑变得更加容易。 首先，我们来看一下这个帮助器函数的基本结构。这个函数叫做`调用服务器`，它接受四个参数：`组件`、`方法`、`回调`和`参数`。这里的`组件`是指我们正在操作的Lightning组件，`方法`是我们想要调用的服务器端方法，`回调`是当服务器返回数据后我们想要执行的函数，而`参数`则是我们传递给服务器端方法的任何数据。 在函数内部，我们首先通过`Component.get(方法)`来获取服务器端的方法。如果提供了`参数`，我们就会使用`Action.setParams(参数)`来设置这些参数。然后，我们设置一个回调函数，这个函数会在服务器响应后执行。在这个回调函数中，我们首先检查响应的状态。如果状态是“成功”，我们就调用之前传入的`回调`函数，并将服务器返回的值传递给它。如果状态是“错误”，我们就会处理这些错误，可能是打印错误信息或者抛出一个错误。 最后，我们使用`$A.enqueueAction(action)`来将我们的请求加入到队列中，等待执行。 接下来，我们来看一个具体的例子，如何使用这个帮助器函数。假设我们有一个方法叫做`getStudents`，它需要从服务器获取学生列表。我们可以这样调用我们的帮助器函数： ```javascript helper.调用服务器( 组件, &quot;c.getStudents&quot;, 函数(响应){ Component.set(&#39;v.Students&#39;, 响应); }, { 指令ID: Component.get(&#39;v.InductorId&#39;), CourseDeliveryId: Component.get(&#39;v.courseDeliveryId&#39;) } ); ``` 在这个例子中，我们传入了组件、方法名、一个回调函数（这个函数会将返回的学生列表设置到组件的属性中），以及一些参数（比如指令ID和课程交付ID）。 通过这种方式，我们可以将调用服务器端方法的代码简化，使得控制器中的代码更加清晰和易于维护。希望这个解释对你有帮助！如果有任何疑问，随时问我。

  ▶ 播放视频 查看详情
• 121

  Using Inheritance

  第 173 页

  让我们来聊聊如何在Salesforce的Lightning框架中使用继承来实现代码共享。想象一下，你有一个父组件，它就像一个模板，里面定义了一些通用的样式、功能或者结构。然后，你可以创建子组件，这些子组件会继承父组件的所有特性，这样你就不用重复写代码了。 首先，我们来看一个父组件的例子。这个父组件叫做`wrapInBox`，它的作用是在内容周围加一个黑色的边框。为了让其他组件能够继承它，我们需要在父组件的定义中设置`extensible=&quot;true&quot;`，这样它就变成了一个可以被继承的组件。 ```html <div style="border: 1px solid black;"> {!v.body} </div> ``` 在这个父组件中，`{!v.body}`是一个占位符，它表示将来子组件的内容会显示在这里。 接下来，我们创建一个子组件，叫做`UsesWrapInBox`。这个子组件继承了父组件`wrapInBox`的所有特性。在子组件的定义中，我们使用`extends`属性来指定父组件。 ```html 这是一些子内容，将在父标签中显示为v.body。 ``` 在这个子组件中，我们写了一些内容，这些内容会被插入到父组件的`{!v.body}`位置。所以，当你使用这个子组件时，它会自动带上父组件定义的黑色边框。 总结一下，通过继承，我们可以让子组件复用父组件的代码，这样不仅减少了重复代码，还让代码更加模块化和易于维护。希望这个解释能帮助你理解如何在Salesforce中使用继承来实现代码共享。

  ▶ 播放视频 查看详情
• 122

  Defining Abstract Components

  第 174 页

  让我们来聊聊抽象组件这个概念。你可以把抽象组件想象成一个半成品的模板。它提供了一些基础的功能和结构，但并没有完全完成。就像你在做手工时，可能有一个半成品的模型，你需要根据自己的需求去完善它。 在Java这样的面向对象编程语言中，抽象类也是类似的。它们提供了一些基本的实现，但具体的细节需要由继承它的子类来完成。你不能直接创建一个抽象类的实例，因为它不是一个完整的类。 在Lightning组件框架中，抽象组件也是这样的。它们定义了一些基本的布局和功能，但具体的实现细节需要由继承它的子组件来完成。你不能直接在页面上使用抽象组件，因为它不是一个完整的组件。 要定义一个抽象组件，你需要在组件的标签中添加一个属性，叫做`abstract=&quot;true&quot;`。这样，Lightning框架就知道这个组件是一个抽象组件，不能直接使用。你需要创建一个子组件来继承它，并在子组件中完成具体的实现。 举个例子，假设你有一个抽象组件，它定义了一个带有黑色边框的`<div>`，并且预留了一个位置来显示内容。你可以这样定义它： ```html <div style="border: 1px solid black;"> {! v.身体} </div> ``` 在这个例子中，`{! v.身体}` 是一个占位符，表示这里的内容需要由子组件来填充。你可以创建一个子组件来继承这个抽象组件，并在子组件中定义具体的内容。 总结一下，抽象组件就像是一个半成品的模板，它提供了一些基础的功能和结构，但具体的实现需要由子组件来完成。你不能直接使用抽象组件，必须通过继承它来创建一个具体的子组件。</div>

  ▶ 播放视频 查看详情
• 123

  Working with Inherited Attributes, Events, Helpers, and Controllers (1 of 2)

  第 175 页

  让我们来聊聊Salesforce中的组件继承。想象一下，你有一个超级组件，就像一个家族中的长辈，它有一些特性和行为。现在，你创建了一个子组件，这个子组件就像是家族中的年轻一代，它继承了长辈的一些特性和行为。 首先，子组件会继承超级组件的属性。这意味着，如果超级组件有一个属性叫做“家族姓氏”，子组件也会自动拥有这个“家族姓氏”。 接下来，如果你想在子组件中改变这个“家族姓氏”，你可以在子组件的标记中使用``来设置这个属性的值。这就像是你决定给你的孩子取一个不同的名字，但仍然保留家族的姓氏。 子组件不仅可以继承属性，还可以处理超级组件触发的事件。这就像是家族中的长辈发出一个信号，年轻一代能够接收并响应这个信号。 此外，子组件会自动继承超级组件的事件处理程序。这意味着，如果超级组件有一个处理生日派对的方法，子组件也会知道如何在生日派对上表现。 但是，有时候，超级组件和子组件可能想要以不同的方式处理同一个事件。这时，你可以在子组件中添加``标签，来定义子组件如何处理这个事件。这就像是你和你的孩子可能对同一个家庭活动有不同的看法和做法。 最后，需要注意的是，Salesforce框架不保证事件处理的顺序。这就像是在一个大家庭中，每个人对事件的反应可能不会按照你预期的顺序发生。 希望这个比喻能帮助你更好地理解Salesforce中的组件继承。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 124

  Working with Inherited Attributes, Events, Helpers, and Controllers (2 of 2)

  第 176 页

  今天我们来聊聊Salesforce中的组件继承，特别是关于帮助者（Helper）、事件（Event）和控制器（Controller）的使用。 首先，想象一下，你有一个超级组件，就像是一个大家族中的长辈。这个超级组件有一些特定的功能，比如处理数据或者响应用户的操作。这些功能通常写在帮助者（Helper）里面。 现在，假设你创建了一个子组件，就像是这个家族中的年轻一代。这个子组件继承了超级组件的所有特性，包括那些写在帮助者里的功能。这意味着，子组件可以自动使用超级组件中定义的所有帮助者函数。 但是，有时候子组件可能想要做一些与众不同的事情。这时，它可以通过定义一个与超级组件中同名的函数来“重写”那个函数。这就像是年轻一代决定用他们自己的方式来处理某些事情，而不是完全按照长辈的方式。 此外，子组件还可以调用超级组件的客户端控制器中的操作。比如说，如果超级组件有一个叫做“doSomething”的操作，子组件可以通过使用{!c.doSomething}这样的语法来调用它。这就像是年轻一代在需要的时候，可以请求长辈的帮助来完成某些任务。 总结一下，通过继承，子组件不仅继承了超级组件的功能，还可以根据需要重写这些功能，或者在需要时调用超级组件的控制器操作。这种机制使得组件之间的功能共享和扩展变得非常灵活和强大。希望这个解释能帮助你更好地理解Salesforce中的组件继承机制！

  ▶ 播放视频 查看详情
• 125

  Calling Apex

  第 177 页

  让我们来聊聊当用户点击按钮时，Salesforce Lightning组件是如何与Apex控制器进行交互的。这个过程其实就像是一场精心编排的舞蹈，每个步骤都紧密相连，确保数据能够顺利地从用户界面传递到服务器，然后再返回来更新界面。 首先，想象一下，用户在你的应用界面上点击了一个按钮。这个点击动作就像是一个信号，告诉浏览器：“嘿，我需要做点什么！”这个信号会触发一个浏览器事件。 接下来，这个事件会唤醒一个JavaScript控制器。这个控制器就像是一个聪明的助手，它首先会执行一些自定义的逻辑，比如检查用户输入是否有效，或者准备一些数据。然后，它会调用一个帮助器函数。这个帮助器函数的作用是让代码更加整洁和可重用，但在这个例子中，它并不是必须的。 帮助器函数接着会调用Apex控制器中的一个方法。Apex控制器是Salesforce服务器端的代码，它负责处理业务逻辑和数据操作。当Apex方法被调用时，它会执行一些操作，比如保存数据到数据库中。 一旦Apex方法完成了它的任务，它会把结果数据返回给JavaScript。这时，JavaScript会调用一个回调函数。这个回调函数就像是一个信使，它接收Apex方法返回的数据，并根据这些数据来决定如何更新用户界面。 最后，用户界面会根据回调函数的指示进行更新，用户就能看到最新的信息了。这个过程虽然听起来有点复杂，但其实它发生得非常快，用户几乎感觉不到延迟。 总结一下，这个过程就像是一个接力赛：用户点击按钮，JavaScript控制器接棒，帮助器函数传递接力棒，Apex控制器完成关键任务，最后JavaScript回调函数冲刺到终点，更新用户界面。这样，用户就能看到他们操作的结果了。

  ▶ 播放视频 查看详情
• 126

  Call an Apex method from an Aura Component and render the results.

  第 178 页

  今天我们来学习如何从Aura组件调用Apex方法，并将结果渲染到页面上。这个练习的目标是创建一个Apex类和方法，然后通过Aura组件来调用它，最终将一组联系人信息以磁贴的形式展示出来。 ### 第一步：创建Apex类和方法 首先，我们需要创建一个Apex类，这个类将包含一个方法，用于从Salesforce平台获取联系人数据。我们可以把这个方法标记为`@AuraEnabled`，这样Aura组件就可以调用它了。 ```apex public class ContactController { @AuraEnabled public static List getContacts() { return [SELECT Id, Name, Email, Phone FROM Contact LIMIT 10]; } } ``` 在这个例子中，我们定义了一个`getContacts`方法，它会返回最多10个联系人的信息，包括他们的ID、姓名、电子邮件和电话。 ### 第二步：创建Aura组件 接下来，我们需要创建一个Aura组件来调用这个Apex方法，并将结果显示在页面上。我们可以使用`aura:component`来定义这个组件。 ```html <div class="slds-grid slds-wrap"> <div class="slds-col slds-size_1-of-3"> <div class="slds-card"> <div class="slds-card__header"> <h3>{!contact.Name}</h3> </div> <div class="slds-card__body"> <p>Email: {!contact.Email}</p> <p>Phone: {!contact.Phone}</p> </div> </div> </div> </div> ``` 在这个组件中，我们定义了一个`contacts`属性来存储从Apex方法返回的联系人数据。我们还使用了`aura:iteration`来遍历这些联系人，并将它们以磁贴的形式展示出来。 ### 第三步：定义Helper方法 为了以一致的方式调用Apex方法，我们可以定义一个Helper方法。这个方法将负责调用Apex方法，并将结果存储到组件的属性中。 ```javascript ({ doInit: function(component, event, helper) { helper.getContacts(component); } }) ``` ```javascript ({ getContacts: function(component) { var action = component.get(&quot;c.getContacts&quot;); action.setCallback(this, function(response) { var state = response.getState(); if (state === &quot;SUCCESS&quot;) { component.set(&quot;v.contacts&quot;, response.getReturnValue()); } }); $A.enqueueAction(action); } }) ``` 在这个Helper方法中，我们首先获取Apex方法的引用，然后设置一个回调函数来处理返回的结果。如果调用成功，我们将结果存储到组件的`contacts`属性中。 ### 第四步：渲染结果 最后，当组件初始化时，`doInit`方法会被调用，它会触发Helper方法去获取联系人数据。一旦数据返回，`aura:iteration`就会遍历这些数据，并将每个联系人的信息渲染为磁贴。 ### 总结 通过这个练习，我们学会了如何从Aura组件调用Apex方法，并将结果渲染到页面上。我们创建了一个Apex类和方法，定义了Aura组件和Helper方法，最终将联系人信息以磁贴的形式展示出来。整个过程大约需要20分钟，希望你能顺利完成这个练习！ 如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 127

  Unit 2: Getting Started - 179

  第 179 页

  同学们，今天我们来聊聊第2单元的内容。这一单元主要是关于如何利用HTML5和Salesforce的Lightning组件来开发应用程序的。听起来有点技术性，但别担心，我会尽量用简单的话来解释。 首先，我们会回顾一下HTML5应用程序的一些基本特征、功能和限制。HTML5是一个非常强大的工具，它可以帮助我们创建跨平台的应用程序，这意味着你可以在不同的设备上运行同一个应用，比如手机、平板或者电脑。 接下来，我们会学习如何使用Aura Components和Apex来开发Salesforce的移动应用程序。Aura Components是Salesforce提供的一种框架，它可以帮助我们快速构建用户界面。而Apex是Salesforce的一种编程语言，类似于Java，它可以帮助我们处理更复杂的业务逻辑。 在这一单元中，我们还会学习如何使用CSS来美化我们的应用程序。CSS可以帮助我们控制应用程序的外观和感觉，比如颜色、字体和布局等。 然后，我们会学习如何定义和操作组件的属性。这些属性可以控制组件的行为和显示内容。我们还会学习如何处理系统和用户事件，比如点击按钮或者提交表单等。 当然，开发过程中难免会遇到问题，所以我们还会学习如何调试和排查应用程序中的错误。这包括使用开发者工具来检查代码，以及如何阅读错误信息来找到问题的根源。 最后，我们会学习如何与Apex合作，使用基本的Aura组件，提出和处理事件，以及使用Lightning数据服务进行CRUD操作。CRUD操作是指创建(Create)、读取(Read)、更新(Update)和删除(Delete)数据，这是任何应用程序中最基本的操作。 好了，这就是第2单元的主要内容。希望你们能跟上，如果有任何问题，随时提问。我们一起来探索Salesforce的世界吧！

  ▶ 播放视频 查看详情
• 128

  Topics - 180

  第 180 页

  今天我们来聊聊Salesforce Lightning组件中的几个常用元素：``、``、``以及``网格系统。这些组件可以帮助我们快速构建用户界面，并且它们都是开箱即用的，非常方便。 首先，我们来看``。这个组件是用来创建一个下拉菜单的。你可以把它想象成一个选择框，用户可以从多个选项中选择一个。比如，你可以用它来让用户选择他们的国家、产品类型或者其他任何需要选择的选项。它的使用非常简单，你只需要在代码中定义好选项，然后把它放到页面上就可以了。 接下来是``和``。这两个组件都是用来创建按钮的，但它们有一些区别。``是一个普通的按钮，你可以给它添加文字，比如“提交”或者“取消”。而``则是一个带有图标的按钮，通常用于一些常见的操作，比如删除、编辑或者保存。你可以根据需求选择使用哪种按钮。 最后，我们来说说``网格系统。这个组件是用来布局的，它可以帮助你把页面上的元素排列得整整齐齐。你可以把它想象成一个网格，每个网格可以放置一个组件。通过调整网格的大小和位置，你可以轻松地创建出复杂的页面布局。比如，你可以把按钮放在左边，下拉菜单放在右边，或者把多个组件放在同一行。 总结一下，``用于创建下拉菜单，``和``用于创建按钮，而``则用于页面布局。这些组件都是Salesforce Lightning框架的一部分，使用它们可以让你快速构建出美观且功能强大的用户界面。 希望这些内容对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 129

  Using <lightning:select>

  第 181 页

  让我们来聊聊如何在Salesforce中使用``这个组件。这个组件其实就是一个下拉菜单，用户可以从多个选项中选择一个。它和HTML中的``标签很像，但它是专门为Salesforce的Lightning框架设计的。 首先，你需要知道的是，``不支持多选，也就是说，用户一次只能选择一个选项。如果你需要多选功能，你可能需要考虑其他组件。 现在，让我们看看如何创建一个简单的``组件。你需要在你的Lightning组件中这样写： ```html 选项一选项二选项三 ``` 在这个例子中，`name`属性是给这个选择框命名的，`label`是显示在选择框上方的标签，告诉用户这个选择框是用来做什么的。`value`属性则是用来绑定你选择的值的，这里我们绑定了一个变量`selectedValue`，这个变量会保存用户选择的选项的值。 每个``标签代表一个可选的选项，`value`属性是选项的值，而标签内的文本则是显示给用户看的选项名称。 当用户选择一个选项时，`selectedValue`变量会自动更新为所选选项的值。这样，你就可以在控制器或帮助类中使用这个值来进行进一步的处理了。 希望这个解释能帮助你理解如何使用``组件。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 130

  Generating Options Dynamically with <aura:iteration>

  第 182 页

  让我们来一步步理解这段代码。这段代码的目的是使用Salesforce的Aura框架动态生成一个下拉菜单，菜单中的选项是从一个对象数组中提取的。 首先，我们定义了一个名为`captains`的属性，它是一个对象数组。这个数组包含了两个对象，每个对象都有`label`和`value`两个属性。`label`是显示在下拉菜单中的文本，而`value`是选中该选项时返回的值。 ```html ``` 接下来，我们使用``标签来创建一个下拉菜单。这个标签有几个重要的属性： - `name`：为下拉菜单指定一个名称。 - `label`：显示在下拉菜单旁边的标签文本。 - `aura:Id`：为这个组件指定一个唯一的ID。 - `value`：默认选中的选项的值。 ```html ``` 然后，我们使用``标签来遍历`captains`数组中的每个对象。`items`属性指定要遍历的数组，`var`属性指定在每次迭代中当前对象的变量名。 ```html ``` 在每次迭代中，我们创建一个``标签。`value`属性设置为当前对象的`value`属性，而``标签的内容（即显示在下拉菜单中的文本）设置为当前对象的`label`属性。 ```html {!captain.label} ``` 最后，我们关闭所有的标签。 ```html ``` 总结一下，这段代码通过遍历一个对象数组，动态生成下拉菜单的选项。每个选项的显示文本和值都来自数组中的对象。这样，我们就可以轻松地根据数据动态生成用户界面元素。

  ▶ 播放视频 查看详情
• 131

  Handling <lightning:select> Events

  第 183 页

  让我们来聊聊这个``组件以及它的事件处理。 首先，``是一个下拉菜单组件，用户可以从预定义的选项中选择一个值。在这个例子中，我们有一个下拉菜单，用来选择一个船长。 ### 事件解释 1. ，onFocus，: 当用户点击或通过键盘导航到这个下拉菜单时，这个事件会被触发。你可以用它来做一些事情，比如显示一些提示信息。 2. ，onBlur，: 当用户离开这个下拉菜单时，这个事件会被触发。比如，用户点击了其他地方，或者通过键盘导航离开了这个下拉菜单。 3. ，onChange，: 当用户改变了下拉菜单中的选择时，这个事件会被触发。这是最常用的事件，因为通常我们希望在用户做出选择后立即执行一些操作。 ### 代码解析 在这个例子中，我们主要关注`onChange`事件。当用户选择一个不同的船长时，`onCaptChange`函数会被调用。 ```javascript onCaptChange: function(component, event, helper) { var selectedVal = component.find(&quot;idCaptain&quot;).get(&quot;v.value&quot;); alert(&quot;您选择了 &quot; + selectedVal); } ``` - ，component.find(&quot;idCaptain&quot;)，: 这部分代码是用来找到我们之前定义的下拉菜单组件。 - ，get(&quot;v.value&quot;)，: 这个方法用来获取当前选中的值。 - ，alert(&quot;您选择了 &quot; + selectedVal)，: 最后，我们弹出一个提示框，告诉用户他们选择了哪个船长。 ### 总结 - ，onFocus， 和 ，onBlur， 通常用于处理用户与下拉菜单的交互开始和结束时的情况。 - ，onChange， 是最常用的事件，用于在用户改变选择时执行特定的操作。 希望这个解释能帮助你更好地理解如何使用``组件及其事件处理。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 132

  Using <lightning:button> and <lightning:buttonIcon>

  第 184 页

  今天我们来聊聊Salesforce中的两个非常实用的组件：`` 和 ``。这两个组件可以帮助我们在Lightning页面中创建按钮，让用户能够执行各种操作。 首先，我们来看``。这个组件是用来创建一个按钮的，用户可以点击这个按钮来触发一些操作。比如，你可以在按钮上设置一个`onClick`事件，当用户点击按钮时，就会执行你在客户端控制器中定义的函数。 ``支持几种不同的按钮类型： 1. 只有标签的按钮，就是按钮上只有文字。 2. 标签和图标按钮，按钮上既有文字也有图标。 3. 只有图标的按钮，按钮上只有图标。 4. 正文和图标按钮，按钮上有正文和图标。 你还可以通过`VARIANT`属性来指定按钮的样式，让按钮看起来更符合你的需求。 接下来是``。如果你只需要一个图标按钮，并且这个图标来自SLDS SVG库，那么``就是你的好选择。它专门用于创建只包含图标的按钮。 现在，我们来看看``支持的一些常用属性： - `Acceskey`：这是一个字符串，用来设置快捷键，用户可以通过这个快捷键快速聚焦到这个按钮上。 - `Tabindex`：这是一个数字，用来设置按钮在Tab键顺序中的位置。 - `类`：这是一个字符串，用来给按钮添加额外的CSS类。 - `标题`：这是一个字符串，当用户把鼠标悬停在按钮上时，会显示这个字符串作为工具提示。 - `类型`：这是一个字符串，用来指定按钮的类型，比如`BUTTON`、`RESET`或`Submit`，默认是`BUTTON`。 - `名称`：这是一个字符串，用来设置按钮的名称。 - `值`：这是一个字符串，用来设置按钮的值。 - `标签`：这是一个字符串，用来设置按钮上显示的文本。 - `变量`：这是一个字符串，用来设置按钮的SLDS主题。 - `图标名称`：这是一个字符串，用来设置按钮中显示的图标的SLDS名称。 - `图标位置`：这是一个字符串，用来设置图标相对于按钮标签的位置，默认是`Left`。 - `已禁用`：这是一个布尔值，用来设置按钮是否可以被点击。 通过这些属性，你可以非常灵活地定制你的按钮，让它们在你的Lightning页面中发挥最大的作用。希望这些信息对你有帮助，如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 133

  Implementing a Text-Only Button

  第 185 页

  让我们来聊聊如何在Salesforce中创建一个纯文本按钮。首先，你可以使用``这个标签来创建一个按钮。这个标签是Salesforce提供的一个组件，专门用来在Lightning框架中创建按钮。 比如，你可以这样写： ```html ``` 这段代码会生成一个标签为“Submit”的按钮。当用户点击这个按钮时，它会触发一个名为`onButtonPress`的控制器方法。 但是，如果你想要一个更简单的、没有样式的纯文本按钮，你可以使用标准的HTML ``标签，并给它添加一些Salesforce的样式类。比如： ```html 提交 ``` 这段代码会生成一个看起来像是纯文本的按钮，标签是“提交”。这里的`slds-button`和`slds-button_neutral`是Salesforce Lightning Design System (SLDS)提供的样式类，它们帮助按钮保持与Salesforce其他界面元素的一致性。 所以，总结一下，如果你想在Salesforce中创建一个纯文本按钮，你可以选择使用``标签，或者使用标准的HTML ``标签并添加适当的SLDS样式类。这两种方法都可以帮助你实现目标，具体使用哪一种，取决于你的具体需求和偏好。

  ▶ 播放视频 查看详情
• 134

  Implementing a Label and Icon Button

  第 186 页

  同学们，今天我们来聊聊如何在Salesforce中实现标签和图标按钮。这个功能其实很简单，但非常实用，可以让你的界面看起来更专业、更直观。 首先，我们要知道，Salesforce提供了一个非常丰富的图标库，叫做SDDS图标库。你可以通过访问这个网址来查看所有的图标：[SDDS图标库](https://www.lightningdesignsystem.com/icons/)。这里有很多图标供你选择，比如箭头、电话、邮件等等。 接下来，我们要在按钮上添加图标。这里有两个重要的属性：`iconName`和`iconStatus`。`iconName`是用来指定你想要的图标的名称，而`iconStatus`则是用来设置图标的状态，比如是否显示、是否禁用等。 举个例子，如果你想在按钮的左侧添加一个电话图标，你可以这样写代码： ```html ``` 在这个例子中，`iconName=&quot;utility:phone&quot;`表示我们选择了电话图标，`iconPosition=&quot;left&quot;`表示图标会显示在按钮文本的左侧。 如果你想在右侧显示图标，只需要把`iconPosition`改成`right`就可以了。 最后，别忘了给按钮添加一个点击事件的处理函数，比如`onclick={handleClick}`，这样当用户点击按钮时，就会执行你定义的操作。 好了，这就是如何在Salesforce中实现标签和图标按钮的基本方法。希望你们能轻松掌握，并在实际项目中灵活运用。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 135

  Implementing a Body-Only Button

  第 187 页

  让我们来聊聊这个“仅限实体按钮”的概念。想象一下，你有一个按钮，但你只想显示按钮里面的内容，而不是整个按钮本身。这就像是你有一个漂亮的礼物盒，但你只想展示里面的礼物，而不是盒子。 在Salesforce的Lightning组件中，我们可以使用``标签来创建按钮。通常，这个标签会包裹一些内容，比如文字或者图标。但是，如果你只想显示这些内容，而不显示按钮的边框和背景，你可以使用“仅限实体按钮”的方式。 具体来说，你可以在``标签之间放入你想要显示的内容，比如一段文字或者一个图标。然后，通过一些CSS样式或者Lightning组件的属性设置，你可以让按钮的背景和边框消失，只留下你放在按钮里面的内容。 这样，你就可以灵活地设计按钮的外观，让它看起来像是页面上的普通文本或者图标，而不是一个传统的按钮。这种方式非常适合那些需要自定义按钮样式的场景，比如在仪表盘或者报表中。 总结一下，通过“仅限实体按钮”，你可以只显示按钮里面的内容，而不显示按钮的外框，这样你就可以更自由地设计按钮的外观了。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 136

  Implementing a Body and Icon Button

  第 188 页

  让我们来聊聊如何在Salesforce的Lightning组件中创建一个带有图标和文本的按钮。这个按钮不仅看起来漂亮，而且功能也很强大。 首先，我们使用了一个叫做``的标签来创建这个按钮。这个标签是Salesforce提供的一个标准组件，专门用来创建按钮。 在这个按钮中，我们设置了几个属性： 1. ，iconName，：这个属性用来指定按钮上显示的图标。在这里，我们使用了`utility:push`，这是一个内置的图标，表示“上传”的意思。你可以把它想象成一个小图标，告诉用户这个按钮是用来上传东西的。 2. ，iconPosition，：这个属性决定了图标的位置。我们设置为`left`，意思是图标会出现在按钮的左边。你也可以设置为`right`，这样图标就会出现在右边。 3. ，onclick，：这个属性用来指定当用户点击按钮时会发生什么。我们设置为`{! c.handleClick }`，这意味着当用户点击按钮时，会调用一个叫做`handleClick`的JavaScript函数。这个函数可以在你的控制器中定义，用来处理按钮点击后的逻辑。 在按钮的内部，我们使用了`<strong>`标签来包裹文本。这个标签会让文本加粗显示，看起来更醒目。你可以在这里写任何你想显示的文本，比如“上传一些东西！”。 最后，这个按钮的特别之处在于，它允许你在按钮内部放置几乎任何样式的标记，并且可以灵活地调整图标的位置。这样，你就可以根据需要定制按钮的外观和功能。 总结一下，这个按钮不仅外观漂亮，而且功能强大。通过简单的设置，你就可以创建一个带有图标和文本的按钮，并且可以自定义它的点击行为。希望这个解释对你有帮助！</strong>

  ▶ 播放视频 查看详情
• 137

  Theming <lightning:button> with Variant Options

  第 189 页

  同学们，今天我们来聊聊Salesforce中的按钮变体。在Salesforce的Lightning组件中，按钮不仅仅是一个简单的点击工具，它们还可以通过不同的变体来传达不同的信息和情感。让我们一起来看看这些变体吧。 首先，我们有，Base，变体。这是最基础的按钮样式，它去除了所有额外的样式，只保留了最基本的按钮功能。这种按钮通常用于一些不需要特别强调的操作，比如触发一个模式窗口或者显示一个“点赞”的链接。 接下来是，Brand，变体。这个变体是Salesforce的标志性风格，使用了Salesforce的品牌蓝色。当你想要一个按钮看起来非常“Salesforce”时，就可以使用这个变体。 然后是，Destructive，变体。这个变体使用了红色，通常用于表示一些破坏性的操作，比如删除或者取消。红色在这里起到了警示的作用，提醒用户这个操作可能会带来不可逆的后果。 再来看，Inverse，变体。如果你的按钮是放在一个深色背景上的，那么这个变体就非常适合。它的设计是为了在深色背景上也能清晰可见，确保按钮的可用性。 最后，我们还有，Success，变体。这个变体通常用于表示成功的操作，比如提交表单或者完成一个任务。它通常使用绿色，给人一种积极、成功的感觉。 在代码中，你可以通过设置`variant`属性来指定按钮的变体。比如，如果你想要一个品牌风格的按钮，你可以这样写： ```html ``` 这段代码会生成一个蓝色的品牌按钮，点击它会触发`handleClick`方法。 希望这些解释能帮助你们更好地理解和使用Salesforce中的按钮变体。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 138

  Handling <lightning:button> Events

  第 190 页

  让我们来聊聊如何在Salesforce的Lightning组件中处理按钮点击事件。首先，我们有一个``组件，这个组件是用来创建一个按钮的。在这个按钮上，我们可以定义一些事件，比如当用户点击这个按钮时会发生什么。 在这个例子中，我们定义了一个`onclick`事件，这意味着当用户点击这个按钮时，会触发一个特定的动作。这个动作是在我们的JavaScript控制器中定义的。在这个控制器中，我们有一个叫做`handleClick`的函数，这个函数会在按钮被点击时执行。 在这个`handleClick`函数中，我们简单地使用了一个`alert`函数来弹出一个消息框，显示“叮！”。这是一个非常基础的操作，但它展示了如何在Lightning组件中处理用户交互。 需要注意的是，``组件只支持三种事件：`onClick`、`onblur`和`onfocus`。这意味着你不能在这个组件上使用其他类型的事件，比如`onmouseover`或者`onkeydown`。 总结一下，我们通过定义一个`onclick`事件，并在控制器中编写相应的处理函数，来响应用户的点击操作。这是一个非常基础但非常重要的概念，在开发Salesforce Lightning组件时，你会经常用到它。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 139

  Using the <lightning:layout> Grid System

  第 191 页

  今天我们来聊聊Salesforce中的网格系统。这个系统是基于Flexbox的Lightning Design System，它提供了一个非常灵活、移动优先的脚手架系统。这意味着无论你是在手机、平板还是电脑上查看，内容都能很好地适应屏幕大小。 这个网格系统包括了一些帮助器类，你可以用这些类来调整网格的外观和行为。比如，你可以改变内容的对齐方式、顺序、流动方向，甚至是内容的填充方式。 这个网格系统是基于960网格的，这是一个非常流行的网页设计框架。在这个系统中，内容的大小会根据你指定的列数来自动调整。也就是说，列会根据容器的宽度来扩展或收缩，内容也会自动缩放，以适应不同的屏幕尺寸。 简单来说，使用，你可以轻松地创建出既美观又响应式的页面布局，无论用户使用什么设备访问，都能有良好的体验。

  ▶ 播放视频 查看详情
• 140

  Using the <lightning:layout> Grid System - 192

  第 192 页

  今天我们来聊聊Salesforce中的网格系统，特别是192这个布局。 首先，是Salesforce Lightning组件库中的一个布局组件，它可以帮助我们轻松地创建响应式的页面布局。192这个数字代表的是布局的宽度，具体来说，它指的是布局的总宽度为192像素。 在实际使用中，允许我们通过设置不同的属性来控制布局的列数和每列的宽度。比如，我们可以设置`size`属性来定义每列的宽度，或者使用`multiple`属性来指定每行显示的列数。 举个例子，如果我们想要创建一个两列的布局，每列的宽度相等，我们可以这样写： ```html ``` 在这个例子中，`size=&quot;6&quot;`表示每列占据总宽度的一半，因为总宽度是12（这是Salesforce的默认网格系统宽度），所以6就是一半。 192这个宽度通常用于更细致的布局控制，比如在需要精确控制元素位置和大小时。你可以根据需要调整`size`的值，来达到你想要的布局效果。 希望这个解释能帮助你更好地理解和使用网格系统192。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 141

  Using the <lightning:layout> Grid System - 193

  第 193 页

  让我们来聊聊Salesforce中的网格系统。这个系统其实很简单，它主要由两个部分组成：一个是网格的“大盒子”，我们叫它；另一个是放在这个大盒子里的“小盒子”，我们叫它。 想象一下，你有一个大盒子，你想在里面放两个小盒子。这两个小盒子会并排放在大盒子里，而且它们会尽量占据大盒子的空间。这就是和的作用。 在你的代码中，就是那个大盒子，而就是那两个小盒子。你用了`horizontalAlign=&quot;space&quot;`这个属性，意思是让这两个小盒子在大盒子里均匀分布，中间留出一些空间。 然后，你给每个小盒子都加了`flexibility=&quot;grow&quot;`这个属性，意思是让它们尽可能地“长大”，占据更多的空间。所以，第一个小盒子会显示“这是第1列”，第二个小盒子会显示“这是第2列”，它们会在大盒子里均匀分布，并且尽量占据更多的空间。 简单来说，和就是用来在页面上创建灵活的网格布局的。你可以通过调整它们的属性来控制它们的大小和位置，让页面看起来更整齐、更美观。

  ▶ 播放视频 查看详情
• 142

  Manually Sizing Columns

  第 194 页

  让我们来聊聊如何在Salesforce的Lightning组件中手动调整布局的柱子尺寸。你可以把布局想象成一个由12个等宽柱子组成的网格系统。每个柱子的大小可以通过设置`size`属性来调整，这个属性的值可以从1到12。 在这个例子中，我们有一个包含三行的布局： 1. ，第一行，：我们设置了一个`size=&quot;12&quot;`的``，这意味着这个元素会占据整个12个柱子的宽度。这里我们用它来放置“报头”内容。 2. ，第二行，：这里我们有三列： - 第一个``的`size=&quot;3&quot;`，表示它占据3个柱子的宽度，用来放置“NAV”内容。 - 第二个``的`size=&quot;6&quot;`，表示它占据6个柱子的宽度，用来放置“身体”内容。 - 第三个``的`size=&quot;3&quot;`，表示它占据3个柱子的宽度，用来放置“一边”内容。 3. ，第三行，：我们再次设置了一个`size=&quot;12&quot;`的``，这意味着这个元素会占据整个12个柱子的宽度。这里我们用它来放置“底部对齐”内容。 通过这种方式，你可以灵活地调整每个部分的宽度，确保你的页面布局既美观又实用。记住，`size`属性的总和应该不超过12，这样才能确保布局的平衡和一致性。

  ▶ 播放视频 查看详情
• 143

  Implementing Responsive Relative Column Sizing

  第 195 页

  让我们来聊聊如何在Salesforce的Lightning Design System（SLDS）中使用响应式相对列大小来创建适应不同屏幕尺寸的布局。 首先，我们有一个基本的网格布局，使用了`slds-grid`和`slds-wrap`类来创建一个灵活的网格容器。在这个容器里，我们有五个部分：报头、导航、身体、一边和页脚。 ```html <div class="slds-grid slds-wrap"> 报头 NAV <div class="slds-col slds-size_6-of-12 slds-medium-size_3-of-4">身体</div> 一边 页脚 </div> ``` 在这个布局中，我们使用了`slds-size_a-of-b`类来定义列的大小。例如，`slds-size_3-of-12`表示这个列占据12份中的3份，也就是25%的宽度。 为了使其响应不同的屏幕尺寸，我们使用了`slds-medium-size_a-of-b`和`slds-large-size_a-of-b`类。这些类会在视区宽度超过768px和1024px时生效，分别调整列的大小。 - `slds-medium-size_1-of-1`：当屏幕宽度超过768px时，导航列将占据整个宽度。 - `slds-medium-size_3-of-4`：当屏幕宽度超过768px时，身体列将占据四分之三的宽度。 - `slds-medium-size_1-of-4`：当屏幕宽度超过768px时，一边列将占据四分之一的宽度。 这样，当你在不同的设备上查看这个布局时，它会自动调整列的大小和位置，以适应屏幕的宽度。 希望这个解释能帮助你理解如何在Salesforce中使用响应式相对列大小来创建灵活的布局。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 144

  Using the <lightning:layout> Grid System - 196

  第 196 页

  今天我们来聊聊Salesforce中的网格系统。这个系统非常灵活，可以帮助我们在页面上创建响应式的布局。 首先，是一个组件，它允许我们定义页面的布局结构。你可以把它想象成一个网格，这个网格可以根据页面的宽度自动调整布局。 在Salesforce中，我们有两种主要的页面宽度：宽页面和窄页面。宽页面通常用于桌面视图，而窄页面则适用于移动设备或较小的屏幕。 组件会根据页面的宽度自动调整布局。例如，如果你在一个宽页面上设置了多个列，当页面宽度变窄时，这些列可能会自动堆叠成多行，以适应较小的屏幕空间。 这种动态响应的特性使得非常适合创建适应不同设备和屏幕尺寸的用户界面。无论用户是在桌面电脑上查看，还是在手机上浏览，布局都能自动调整，确保内容的可读性和易用性。 总结一下，网格系统是一个强大的工具，可以帮助我们创建灵活、响应式的页面布局。通过理解宽页面和窄页面的概念，我们可以更好地利用这个系统，为用户提供一致且友好的体验。

  ▶ 播放视频 查看详情
• 145

  Implementing Responsive Relative Column Sizing - 197

  第 197 页

  让我们来聊聊如何在Salesforce的Lightning组件中使用响应式布局。想象一下，你正在设计一个网页，这个网页需要在不同的设备上都能很好地显示，比如手机、平板和电脑。这就是响应式设计的魅力所在。 在这个例子中，我们使用了``和``来创建一个灵活的布局。``是一个容器，它包裹着所有的布局项，也就是``。每个``代表页面上的一个部分，比如报头、导航、身体内容、侧边栏和页脚。 现在，关键的部分来了：如何让这些部分在不同的设备上显示得恰到好处呢？这里我们用到了`size`、`smallDeviceSize`、`mediumDeviceSize`和`largeDeviceSize`这些属性。 - `size`属性定义了默认情况下每个布局项占用的列数。在这个例子中，报头和页脚都占据了12列，这意味着它们会占据整个宽度。 - `smallDeviceSize`、`mediumDeviceSize`和`largeDeviceSize`则分别定义了在小屏幕设备（如手机）、中等屏幕设备（如平板）和大屏幕设备（如电脑）上每个布局项应该占用的列数。 例如，导航和身体内容在默认情况下各占6列，但在中等屏幕设备上，它们各占4列。这样，当用户在不同的设备上查看页面时，布局会自动调整，确保内容的可读性和布局的美观。 总结一下，通过使用这些属性，我们可以轻松地创建一个响应式的布局，让页面在不同的设备上都能提供良好的用户体验。这就是Salesforce Lightning组件中响应式设计的强大之处！

  ▶ 播放视频 查看详情
• 146

  Define the Filter Students form as a set of dynamically populated select boxes.

  第 198 页

  同学们，今天我们来做一个有趣的练习。我们要创建一个学生浏览器表单，这个表单里有两个选择框，一个是讲师选择器，另一个是课程交付选择器。这两个选择框是动态填充的，也就是说，当你选择一个讲师时，课程交付选择框会根据你选择的讲师自动更新。 首先，我们需要使用Lightning的layout组件来定义一个两列的水平布局。这个布局会帮助我们更好地组织表单中的内容，让表单看起来更整洁、更专业。 接下来，我们需要创建一个Apex Class。这个类将包含一个方法，这个方法可以从Salesforce平台读取数据。这个数据就是我们需要的讲师和课程交付的信息。 然后，我们要创建一个Aura组件。这个组件会调用我们刚才创建的Apex Class中的方法，获取数据，并将这些数据动态地填充到我们的选择框中。 具体来说，当你在讲师选择器中选择一个讲师时，Aura组件会调用Apex Class中的方法，获取这个讲师所教授的课程，然后将这些课程动态地填充到课程交付选择器中。 这个练习大约需要20分钟来完成。通过这个练习，你将学会如何使用Lightning组件来创建动态表单，以及如何通过Apex Class和Aura组件从Salesforce平台读取数据。这将帮助你更好地理解Salesforce的开发流程，并提高你的开发技能。现在，让我们开始吧！

  ▶ 播放视频 查看详情
• 147

  Unit 2: Getting Started - 199

  第 199 页

  同学们，今天我们来聊聊第2单元的内容。这一单元主要是关于如何使用HTML5和Salesforce的Lightning组件来开发应用程序。听起来有点技术性，但别担心，我会用简单的方式来解释。 首先，我们会回顾一下HTML5应用程序的一些基本特征、功能和限制。HTML5是一种非常流行的网页技术，它让网页更加动态和互动。然后，我们会学习如何使用Aura Components和Apex来开发Salesforce的移动应用程序。Aura Components是Salesforce提供的一种强大的工具，可以帮助我们快速构建用户界面。 接下来，我们会学习如何入门Lightning开发。Lightning是Salesforce的一个开发框架，它让开发更加快速和高效。我们还会学习如何使用CSS来美化我们的组件，让它们看起来更漂亮。 然后，我们会学习如何定义和操作组件的属性。属性就像是组件的设置，我们可以通过改变属性来改变组件的行为和外观。我们还会学习如何处理系统和用户的事件。事件就是用户与应用程序交互时发生的事情，比如点击按钮或输入文本。 调试和故障排除也是开发中非常重要的一部分。我们会学习一些技巧，帮助我们找到并修复代码中的错误。 最后，我们会学习如何与Apex合作。Apex是Salesforce的一种编程语言，它让我们可以在Salesforce平台上编写更复杂的逻辑。我们还会学习如何使用基本的Aura组件，提出和处理事件，以及使用Lightning数据服务进行CRUD操作。CRUD操作就是创建、读取、更新和删除数据的基本操作。 好了，这就是第2单元的主要内容。希望你们能跟上，如果有任何问题，随时问我。我们开始吧！

  ▶ 播放视频 查看详情
• 148

  Topics - 200

  第 200 页

  今天我们来聊聊Salesforce中的自定义事件。想象一下，你正在搭建一个乐高城堡，每个乐高块就像是一个组件，而自定义事件就是这些乐高块之间传递消息的小纸条。 首先，，定义自定义事件，，就像是你决定要传递什么样的信息。你可以创建一个事件，告诉其他组件“嘿，我刚刚完成了一个任务”。 接下来是，注册和引发自定义组件事件，。这就像是你告诉城堡里的其他乐高块：“如果你们收到这种小纸条，就按照上面的指示行动。”然后，当某个动作发生时，比如点击一个按钮，你就可以“引发”这个事件，发送小纸条。 ，处理来自父组件的引发组件事件，，就像是父组件（城堡的主塔）发送了一个指令给子组件（城堡的小塔），子组件需要知道怎么响应这个指令。 然后是，注册和引发应用程序事件，。这就像是整个城堡的广播系统，任何角落的乐高块都能听到。你可以在一个地方注册这个事件，然后在任何需要的时候引发它。 ，收听应用程序事件，，就是让每个乐高块都装上一个小喇叭，当广播响起时，它们都能听到并做出反应。 ，冲击力活动，，这就像是在城堡里放了一个烟花，所有的乐高块都能看到并为之兴奋。 最后，，使用活动最佳实践，，就是确保你的小纸条和广播系统都设计得既高效又不会造成混乱。 记住，Salesforce提供了一些现成的Lightning组件，比如``、``和``，它们就像是预先设计好的乐高块，可以帮助你更快地搭建你的城堡。 好了，这就是关于Salesforce自定义事件的基础知识。希望这能帮助你在搭建自己的Salesforce应用时，像搭建乐高城堡一样有趣又高效！

  ▶ 播放视频 查看详情
• 149

  Raising and Handling Events

  第 201 页

  今天我们来聊聊Salesforce中的事件驱动编程，特别是Lightning框架中的事件处理。这个概念在很多编程语言和框架中都很常见，比如JavaScript和Swing。它的核心思想是，当某些特定的事情发生时，比如用户点击了一个按钮，系统会自动调用一段代码来处理这个事件。 在Lightning框架中，事件主要分为两种类型：组件事件和应用程序事件。 首先，我们来看组件事件。这种事件是由组件本身或者包含这个组件的其他组件来处理的。比如说，你有一个按钮组件，当用户点击这个按钮时，按钮组件会触发一个事件，然后这个事件会被按钮组件自己或者它的父组件捕获并处理。 接下来是应用程序事件。这种事件更像是一种广播机制。当一个应用程序事件被触发时，所有订阅了这个事件的组件都会收到通知，并可以执行相应的处理程序。这就像是你在一个房间里喊了一声，所有听到的人都会做出反应。 这两种事件处理方式在Lightning框架中都非常有用，它们帮助我们构建响应迅速、交互丰富的用户界面。理解它们的工作原理，对于开发高效的Salesforce应用是非常重要的。希望这个解释能帮助你更好地理解事件驱动编程在Lightning框架中的应用。

  ▶ 播放视频 查看详情
• 150

  Creating, Raising, and Handling a Custom Event

  第 202 页

  今天我们来聊聊如何在Salesforce的Lightning组件中创建、引发和处理自定义事件。这个过程其实就像是在一个大家庭里传递消息一样，非常有趣。 首先，我们需要定义一个自定义事件。这就像是你决定要传递一个特定的消息类型，比如“家庭聚会通知”。这个定义告诉系统，我们要传递的是什么样的信息。 接下来，我们需要在组件中使用``标签来注册这个自定义事件。这就像是在家庭中宣布：“嘿，我们有一个新的消息类型，叫做‘家庭聚会通知’，大家请注意接收。” 然后，当某个特定的情况发生时，比如你决定要举办一个家庭聚会，你就可以通过调用`event.fire()`函数来引发这个自定义事件。这就像是你拿起电话，给家里的每个人打电话，告诉他们聚会的消息。 最后，我们需要在客户端的控制器中为这个引发的事件定义一个事件监听器。这就像是家里的每个人都有一个电话，他们都在等待接听你的聚会通知。当事件被引发时，监听器就会接收到这个事件，并做出相应的反应，比如准备参加聚会。 总结一下，创建、引发和处理自定义事件的过程就是定义消息类型、注册消息、发送消息和接收消息。这个过程确保了信息能够在组件之间有效地传递和处理。希望这个比喻能帮助你更好地理解这个过程！

  ▶ 播放视频 查看详情
• 151

  Defining a Custom Event in VS Code

  第 203 页

  让我们来聊聊如何在VS Code 203中定义自定义事件。这个过程其实很简单，我会一步步带你走一遍。 首先，打开你的VS Code。找到左侧的“练习|主要|默认”这个项目。在这个项目里，你会看到一个叫“aura”的文件夹。右键点击这个“aura”文件夹，然后你会看到一个选项叫“SFDX：创建闪电事件”。点击这个选项。 接下来，系统会提示你输入一个事件名称。你可以根据你的需求来命名这个事件。比如，如果你想要创建一个处理用户点击的事件，你可以命名为“UserClickEvent”。 输入完名称后，按下回车键。这时，你会看到一个屏幕，上面有一些代码模板。这些模板是系统自动生成的，用来帮助你快速开始编写事件代码。 现在，你已经成功创建了一个自定义事件！你可以在这个模板的基础上，添加你需要的逻辑和功能。比如，你可以定义一些属性，或者添加一些方法来处理事件触发时的行为。 整个过程就是这样，简单吧？希望你能顺利创建你的自定义事件！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 152

  Defining a Custom Event in Developer Console

  第 204 页

  让我们来聊聊如何在Salesforce的开发人员控制台中定义自定义事件。这个过程其实挺简单的，我会一步一步地告诉你。 首先，你需要打开Salesforce的开发人员控制台。你可以通过点击右上角的设置图标，然后选择“开发者控制台”来打开它。 打开之后，你会看到顶部有一个菜单栏。在这个菜单栏里，找到“文件”这个选项，点击它。然后，你会看到一个下拉菜单，选择“新建”，接着选择“闪电事件”。 这时候，系统会弹出一个窗口，让你输入事件的名称和描述。名称就是你给这个事件起的名字，比如“MyCustomEvent”，而描述则是关于这个事件的简短说明，比如“这是一个用于处理用户点击的自定义事件”。 输入完名称和描述后，点击“确定”或“保存”，你就会看到一个类似于你刚才描述的屏幕。这个屏幕就是用来定义和编辑你的自定义事件的地方。 在这个屏幕上，你可以添加事件属性、定义事件的触发条件等等。你可以根据自己的需求来定制这个事件。 总的来说，定义自定义事件的过程并不复杂，只要你按照步骤来，很快就能完成。希望这个解释对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 153

  Defining a Custom Event

  第 205 页

  让我们来聊聊Salesforce中的自定义事件，特别是你提到的这个“Studentselect”事件。 首先，想象一下，你在使用一个应用程序，比如一个学生管理系统。在这个系统中，你可能需要处理一些特定的动作，比如选择一个学生。这时候，自定义事件就派上用场了。 自定义事件就像是一个信号，告诉应用程序：“嘿，这里发生了一些事情，你可能需要关注一下！”在这个例子中，我们定义了一个名为“Studentselect”的事件，它会在用户选择一个学生时被触发。 这个事件有一个属性，叫做“contactId”。这个属性就像是事件的一个小标签，它告诉我们哪个学生被选中了。在事件被触发之前，我们可以设置这个属性，比如把被选中学生的ID放进去。然后，当事件被处理时，我们可以读取这个属性，知道是哪个学生被选中了。 在代码中，我们是这样定义这个事件的： ```xml ``` 这段代码的意思是，我们创建了一个组件类型的事件，描述为“Selected Student”，并且给它添加了一个属性“contactId”，这个属性的类型是“Id”，也就是Salesforce中的记录ID。 当这个事件被触发时，处理这个事件的组件可以通过调用`server.getParam(&quot;contactId&quot;)`来获取这个“contactId”属性的值，也就是被选中学生的ID。 简单来说，自定义事件就是让应用程序知道发生了什么，并且可以传递一些有用的信息，比如在这个例子中，就是哪个学生被选中了。这样，应用程序就可以根据这些信息做出相应的反应，比如显示学生的详细信息或者进行其他操作。

  ▶ 播放视频 查看详情
• 154

  Component vs. Application Event

  第 206 页

  今天我们来聊聊Salesforce中的组件与应用程序事件，特别是事件206。这个话题听起来可能有点技术性，但我会尽量用简单的方式来解释，让你能轻松理解。 首先，想象一下Salesforce的界面是由很多小块组成的，这些小块就是组件。每个组件都有自己的任务，比如显示数据、收集用户输入等。组件之间需要交流信息，这时候就需要用到事件了。 事件就像是组件之间的信使。当一个组件发生了某些事情，比如用户点击了一个按钮，它就会发出一个事件，告诉其他组件：“嘿，我这边有事情发生了！”其他组件如果对这个事件感兴趣，就可以做出相应的反应。 现在，我们来说说事件206。在Salesforce中，事件206通常指的是一个特定的错误事件。当你在使用Lightning组件时，如果遇到了问题，比如数据加载失败或者某个操作没有按预期执行，系统就会发出一个206事件来告诉你：“出问题了，需要检查一下。” 处理事件206的关键是理解它的原因。可能的原因有很多，比如网络问题、数据格式不对、或者权限不足等。你需要根据具体的错误信息来排查问题。 总的来说，组件与应用程序事件是Salesforce中非常重要的概念，它们帮助组件之间进行有效的沟通。而事件206则是一个常见的错误事件，提醒我们注意并解决问题。希望这个解释能帮助你更好地理解这些概念！

  ▶ 播放视频 查看详情
• 155

  Registering and Raising a Custom Component Event

  第 207 页

  让我们来聊聊如何在Salesforce的Lightning组件中注册和引发自定义事件。这个过程其实很简单，就像你在家里设置一个闹钟，当时间到了，闹钟就会响起来提醒你。 首先，我们需要告诉系统，我们的组件可能会引发一个特定的事件。这就像是在说：“嘿，我可能会发出一个信号，你们要注意听哦！”我们通过使用``标签来做到这一点。比如，如果我们想要注册一个名为“onStudentSelected”的事件，我们可以这样写： ```html ``` 这里，`name`属性是我们给这个事件起的名字，而`type`属性则是这个事件的类型，它指向了我们定义的事件类型。 接下来，当某个动作发生时，比如用户点击了一个按钮，我们就需要引发这个事件。这就像是你按下闹钟的按钮，让它响起来。在JavaScript中，我们首先需要获取到这个事件的引用，这可以通过`component.getEvents(&quot;evtName&quot;)`来实现，其中`evtName`就是我们之前注册事件时使用的名字。 然后，我们可以选择性地为这个事件设置一些数据，这就像是你可以设置闹钟的铃声大小或者铃声类型。我们使用`setParams`方法来设置这些数据。最后，我们调用`fire()`方法来真正地引发这个事件。 来看一个具体的例子： ```javascript ({ onTileClick: function(component, event, helper) { var compEvents = component.getEvents(&quot;onStudentSelected&quot;); // 可选：为事件设置一些数据 compEvents.setParams({&quot;contactId&quot;: component.get(&quot;v.Student&quot;).Id}); compEvents.fire(); } }) ``` 在这个例子中，当用户点击某个元素时，`onTileClick`函数会被调用。我们首先获取到“onStudentSelected”事件的引用，然后设置了一个参数`contactId`，最后通过`fire()`方法引发了事件。 这样，当事件被引发时，任何监听这个事件的组件都会收到通知，并可以根据传递的数据做出相应的反应。这就是如何在Salesforce的Lightning组件中注册和引发自定义事件的基本过程。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 156

  Handling a Raised Component Event from a Parent Component

  第 208 页

  让我们来聊聊如何在Salesforce的Lightning组件中处理来自父对象的事件。想象一下，你有一个组件，它就像一个大家庭中的一个小孩子。这个小孩子（子组件）有时候会做一些事情，比如选择了一个学生，这时候它需要告诉它的父母（父组件）：“嘿，我选了一个学生！” 在Salesforce的Lightning框架中，我们可以通过事件冒泡来实现这个功能。事件冒泡就像是一个消息从子组件传递到父组件的过程。当子组件触发一个事件时，这个事件会像泡泡一样，从子组件“冒”到父组件。 在你的代码片段中，我们看到了一个``标签。这个标签就像是父组件的一个耳朵，专门用来监听子组件发来的事件。在这个例子中，父组件正在监听一个叫做`onStudentSelected`的事件，这个事件是由一个叫做`c:StudentSelected`的事件类型触发的。 当这个事件被触发时，父组件会执行一个叫做`handleBubbling`的控制器方法。这个方法就像是父组件的反应，它会根据事件的内容做出相应的处理。 所以，简单来说，这个代码片段的意思是：当子组件触发了一个选择学生的事件时，父组件会通过`handleBubbling`方法来处理这个事件。这就是事件冒泡和事件监听器在Salesforce Lightning组件中的基本用法。希望这个解释能帮助你更好地理解这个过程！

  ▶ 播放视频 查看详情
• 157

  Handling a Raised Component Eventfrom a Parent Component

  第 209 页

  让我们来聊聊如何在Salesforce的Lightning组件中处理事件，特别是当事件从子组件“冒泡”到父组件时。 首先，想象一下你有一个子组件，比如一个学生选择器（StudentSelector），当用户选择一个学生时，这个组件会触发一个事件。你希望父组件能够捕捉到这个事件，并做出相应的反应，比如显示一个提示框告诉用户选择了哪个学生。 在Salesforce的Lightning框架中，你可以直接在子组件的标签中指定一个事件处理函数。这个函数会在事件发生时被调用。比如，你可以这样写： ```html ``` 这里，`onStudentSelected`是子组件触发的事件，而`handleBubbling`是父组件中定义的一个控制器函数，用来处理这个事件。 接下来，我们来看看这个`handleBubbling`函数内部应该怎么写。在这个函数中，你可以通过`event.getParams()`来获取事件传递过来的参数。这些参数通常包含了事件相关的数据，比如用户选择的学生ID。 ```javascript handleBubbling: function(component, event, helper) { var params = event.getParams(); alert(&quot;您选择的：&quot; + params.pk); } ``` 在这个例子中，`params.pk`假设是用户选择的学生ID。当事件发生时，这个函数会被调用，然后弹出一个提示框，显示用户选择的学生ID。 总结一下，处理子组件的事件并让父组件响应，主要就是两个步骤：一是在子组件标签中指定事件处理函数，二是在父组件的控制器中定义这个函数，并通过`event.getParams()`获取事件参数，然后根据这些参数执行相应的操作。 希望这个解释能帮助你理解如何在Salesforce中处理组件事件！如果有任何疑问，随时问我哦！

  ▶ 播放视频 查看详情
• 158

  Handling a Raised Component Eventfrom a Parent Component - 210

  第 210 页

  今天我们来聊聊Salesforce中的事件处理，特别是关于如何处理凸起组件事件。这个知识点对于开发交互性强的组件非常重要。 首先，什么是凸起组件事件呢？简单来说，当你在一个组件上点击或者进行其他操作时，这个动作会生成一个事件。这个事件就像是一个小信使，它会从你点击的地方开始，向上“冒泡”到更高级别的组件。这个过程我们称之为事件冒泡。 但是，有时候我们可能不希望这个事件继续向上冒泡。比如，你可能在一个按钮上点击了，但是你不希望这个点击事件影响到按钮所在的更大范围的组件。这时候，你就可以使用`evision.stopPropagation()`这个方法。调用这个方法后，事件就会在当前位置停止，不再向上冒泡。这就像是你告诉那个小信使：“好了，你到这里就可以了，不用再往上跑了。” 接下来，我们来看看`Event.getSource()`这个方法。这个方法非常有用，它可以告诉你事件是从哪个组件发起的。想象一下，如果你在一个页面上有很多按钮，每个按钮点击后都会触发同一个事件处理函数。那么在这个函数里，你怎么知道是哪个按钮被点击了呢？这时候，`Event.getSource()`就派上用场了。它会返回引发事件的组件，这样你就可以根据不同的组件来执行不同的操作了。 总结一下，处理凸起组件事件时，你可以使用`evision.stopPropagation()`来控制事件的冒泡，使用`Event.getSource()`来获取事件的来源组件。这两个方法结合起来，可以帮助你更精确地控制组件的行为，让你的应用更加灵活和强大。 希望这个解释对你有帮助，如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 159

  Registering and Raising an Application Event

  第 211 页

  让我们来聊聊如何在Salesforce中注册和提出申请事件211。这个过程其实和定义组件事件很相似，但有一些小区别。 首先，当你定义一个应用程序事件时，你需要在``标签中指定类型为`APPLICATION`。这就像是在告诉Salesforce：“嘿，这是一个应用程序级别的事件，不是组件级别的。” 你可以在这个事件中添加属性，比如一个联系人的ID，这样当事件被触发时，你可以传递这个ID。 接下来，注册这个应用程序事件。这里你不需要在``标签中指定`name`属性。你只需要告诉Salesforce这个事件是什么类型的，比如`c:AppStudentSelected`。这样，Salesforce就知道在应用程序中监听这个事件。 最后，使用``组件确保Salesforce平台已经下载了事件元数据。这就像是确保所有的准备工作都做好了，事件可以顺利地被触发和处理。 简单来说，定义和注册应用程序事件就是告诉Salesforce：“这是一个应用程序级别的事件，当它发生时，请按照我定义的规则来处理。” 这样，当事件被触发时，Salesforce就知道该怎么做了。

  ▶ 播放视频 查看详情
• 160

  Registering and Raising an Application Event - 212

  第 212 页

  让我们来聊聊如何在Salesforce的Lightning组件中注册和触发应用程序事件。这个过程其实挺简单的，我会尽量用通俗的语言来解释。 首先，想象一下你有一个按钮，当用户点击这个按钮时，你想要触发一个事件，告诉其他组件：“嘿，有人点击了按钮，你们该做点什么了！”这个事件就是我们要说的应用程序事件。 ### 注册事件 在Lightning组件中，首先你需要注册这个事件。这就像是在告诉系统：“我这儿有个事件，名字叫‘AppStudentselect’，你们可以监听它。”你会在组件的定义文件中使用``标签来注册这个事件。比如： ```html ``` 这里，`name`属性是你给事件起的名字，`type`属性是事件的具体类型。 ### 触发事件 接下来，当用户点击按钮时，你需要在JavaScript控制器中触发这个事件。你可以这样做： ```javascript ({ onTileClick: function(component, event, helper) { // 获取对事件的引用 var appEvents = $A.get(&quot;e.c:AppStudentselect&quot;); // 设置一些数据，比如传递一个学生的ID appEvents.setParams({ &quot;contactId&quot;: component.get(&quot;v.Student&quot;).Id }); // 触发事件 appEvents.fire(); } }) ``` 在这段代码中，`$A.get(&quot;e.c:AppStudentselect&quot;)`是用来获取你之前注册的事件的引用。然后，你可以通过`setParams`方法给事件传递一些数据，比如这里我们传递了一个学生的ID。最后，调用`fire()`方法来真正触发这个事件。 ### 总结 简单来说，注册事件就像是在告诉系统：“我这儿有个事件，你们可以监听它。”而触发事件则是在某个动作发生时（比如点击按钮），告诉系统：“事件发生了，你们该做点什么了！”通过这种方式，不同的组件之间就可以进行通信了。 希望这个解释能帮助你理解如何在Salesforce中注册和触发应用程序事件。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 161

  Listening for an Application Event

  第 213 页

  今天我们来聊聊如何在Salesforce的Lightning组件中监听应用程序事件。应用程序事件是一种非常强大的工具，它允许你在不同的组件之间传递信息，而不需要这些组件之间有直接的父子关系。 首先，我们来看一下如何使用``来监听一个应用程序事件。假设我们有一个名为`c:AppStudentSelected`的应用程序事件，我们想要在某个组件中监听这个事件，并在事件触发时执行一些操作。 在Lightning组件的标记中，你可以这样写： ```html ``` 这里有几个关键点需要注意： 1. ，`event`属性，：这个属性指定了你想要监听的事件。在这个例子中，我们监听的是`c:AppStudentSelected`事件。注意，事件名称前面有一个`c:`，这表示这个事件是在你的自定义命名空间中定义的。 2. ，`action`属性，：这个属性指定了当事件被触发时，你想要执行的控制器方法。在这个例子中，我们指定了`{!c.onStudentSelected}`，这意味着当`c:AppStudentSelected`事件被触发时，`onStudentSelected`方法会被调用。 3. ，没有`name`属性，：与处理组件事件不同，应用程序事件的``不需要指定`name`属性。这是因为应用程序事件是全局的，任何组件都可以监听它们，而不需要知道事件的来源。 接下来，你需要在你的控制器中定义`onStudentSelected`方法。这个方法会接收一个事件参数，你可以从这个参数中获取事件传递的数据，并执行相应的逻辑。 例如： ```javascript ({ onStudentSelected: function(cmp, event, helper) { var selectedStudent = event.getParam(&quot;student&quot;); // 在这里处理选中的学生信息 } }) ``` 在这个方法中，`event.getParam(&quot;student&quot;)`用于获取事件传递的`student`参数。你可以根据这个参数的值来更新组件的状态或执行其他操作。 总结一下，使用``监听应用程序事件是一个非常直接的过程。你只需要指定事件名称和对应的控制器方法，然后在控制器中处理事件传递的数据即可。希望这个解释对你有帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 162

  Invoking Force Events

  第 214 页

  今天我们来聊聊Salesforce中的Aura组件和它们如何与Salesforce移动设备及Lightning Experience进行互动。首先，Aura组件是Salesforce中用于构建用户界面的强大工具，它们可以在Salesforce的移动应用和Lightning Experience中自动处理一些特定的事件。 但是，如果你在Salesforce移动设备或Lightning Experience之外的Lightning应用程序或组件中触发这些事件，那么你就需要自己来处理这些事件了。这里有几个关键的事件你需要了解： 1. ，force:closeQuickAction，：这个事件是用来关闭当前打开的快速动作的。在Salesforce中，一次只能打开一个快速动作，所以当你需要关闭它时，就可以使用这个事件。 2. ，force:DeliverRecord，：这个事件用于打开一个新页面，为指定的实体（比如“账户”或自定义对象如“myDeliverpace__MyTarget__c”）创建新记录。你可以通过指定实体的ApiName来触发这个事件。 3. ，force:editRecord，：这个事件则是用来打开一个页面，以便编辑由recordId指定的记录。这对于需要快速修改记录信息的场景非常有用。 理解这些事件的处理方式，可以帮助你更好地控制Aura组件在不同环境下的行为，确保你的应用在各种设备上都能提供一致且高效的用户体验。希望这些信息对你有所帮助！如果有任何疑问，随时欢迎提问。

  ▶ 播放视频 查看详情
• 163

  Invoking Force Events - 215

  第 215 页

  今天我们来聊聊Salesforce中的一些常用事件和功能，特别是那些带有“force”和“lightning”前缀的。这些功能可以帮助我们在Salesforce平台上更高效地导航和管理数据。 首先，我们来看几个“force”开头的事件： 1. ，force:navigateToList， - 这个事件可以帮助你导航到一个特定的列表视图。你只需要提供列表视图的ID，它就会带你到那里。 2. ，force:navigateToObjectHome， - 这个事件是用来导航到一个对象的主页的。你需要指定一个“scope”属性，这个属性会告诉系统你要去哪个对象的主页。 3. ，force:navigateToRelatedList， - 如果你想查看某个记录的关联列表，这个事件就派上用场了。你需要提供一个“parentRecordId”，它就会带你去看这个记录的关联列表。 4. ，force:navigateToSObject， - 这个事件是用来导航到一个特定的记录页面的。你只需要提供记录的ID，它就会带你到那个记录的详细页面。 5. ，force:navigateToURL， - 这个事件很简单，就是导航到一个指定的URL。你可以用它来跳转到任何网页。 6. ，force:recordSave， - 这个事件是用来保存记录的。当你完成编辑后，触发这个事件，记录就会被保存。 7. ，force:recordSaveSuccess， - 这个事件是用来告诉你记录已经成功保存了。它通常在你保存记录后自动触发。 8. ，force:recordUpdate， - 这个事件表示记录已经被更改了。它可以帮助你跟踪记录的变化。 9. ，force:refreshView， - 这个事件是用来刷新当前视图的。如果你做了更改，想要立即看到效果，就可以用这个事件。 10. ，force:showToast， - 这个事件是用来显示一个弹出消息的。你可以用它来给用户一些提示信息。 接下来是“lightning”开头的事件： 1. ，lightning:openFile， - 这个事件是用来打开一个或多个文件记录的。它会根据设备的不同，触发文件预览器或者直接下载文件。 这些事件和功能在Salesforce中非常常用，掌握它们可以帮助你更高效地使用Salesforce平台。希望这些解释对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 164

  Checking for Event Support

  第 216 页

  让我们来聊聊如何在Salesforce中检查活动是否支持216，以及如何使用`$A.get()`函数来确认客户端是否支持强制事件。 首先，`$A.get()`是一个非常有用的函数，它可以帮助我们获取特定的资源或服务。在这个例子中，我们用它来检查客户端是否支持`force:showToast`事件。这个事件通常用于在Salesforce移动应用中显示一个短暂的提示消息，也就是我们常说的“Toast”。 接下来，我们来看一下代码片段： ```javascript 显示Toast：函数（组件、事件、助手）{ var toast = $A.get(&quot;Events.force:showToast&quot;); if（toast）{ //在Salesforce移动设备中启动祝酒活动 toast.setParams({ &quot;标题&quot;：&quot;成功！&quot;, &quot;Message&quot;：&quot;组件加载成功。&quot; }); toast.fire(); } else { //您的吐司实现 //对于此处的独立应用程序 } } ``` 在这个函数中，我们首先使用`$A.get(&quot;Events.force:showToast&quot;)`来尝试获取`force:showToast`事件。如果这个事件存在，说明客户端支持这个功能，我们就可以继续设置Toast的参数，比如标题和消息内容，然后调用`toast.fire()`来显示这个Toast。 如果`$A.get()`返回的是`null`或者`undefined`，那就说明客户端不支持这个事件。这时候，我们可以在`else`块中实现自己的Toast逻辑，或者处理不支持的情况。 总结一下，通过`$A.get()`函数，我们可以轻松地检查客户端是否支持某个特定的事件或功能，并根据结果采取相应的行动。这在开发跨平台的Salesforce应用时非常有用，可以确保我们的应用在不同环境下都能正常运行。

  ▶ 播放视频 查看详情
• 165

  Using Best Practices for Events

  第 217 页

  让我们来聊聊在Salesforce中使用事件的一些最佳实践。首先，如果你可以选择的话，尽量使用组件事件而不是应用程序事件。为什么呢？因为组件事件只能被它们所在的组件层次结构中上层的组件处理，这样它们的用途就更局限，只有那些真正需要知道这些事件的组件才会处理它们。而应用程序事件则更适合那些需要在应用级别处理的事情，比如导航到一个特定的记录，或者如果你在设计一系列可以在Lightning App Builder中部署的松散耦合的组件。 接下来，一个很好的做法是在事件处理程序中处理一些低级的事件，比如点击事件，然后将它们重新引发为更高级的事件，比如ApprovalChange事件，或者任何适合你业务逻辑的事件。在接下来的练习中，你就会用到这种技术。 最后，如果你有很多监听同一个事件的组件实例，你可以考虑设置一个Dispatcher组件来监听这个事件。这个Dispatcher组件可以执行一些逻辑来决定哪些组件实例应该接收进一步的信息，并且可以激发另一个以这些组件实例为目标的组件或应用程序事件。这样做可以帮助你更有效地管理和分发事件，确保只有真正需要响应的组件才会接收到事件。

  ▶ 播放视频 查看详情
• 166

  Unit 2: Getting Started - 219

  第 219 页

  同学们，今天我们来聊聊第2单元的内容。这个单元主要是关于如何使用HTML5和Salesforce的Lightning组件来开发应用程序。听起来有点技术性，但别担心，我会尽量用简单的语言来解释。 首先，我们会回顾一下HTML5应用程序的一些基本特征、功能和限制。HTML5是一种非常流行的网页技术，它让网页更加动态和互动。了解它的特点，可以帮助我们更好地使用它来开发应用。 接下来，我们会学习如何使用Aura Components和Apex来开发Salesforce的移动应用程序。Aura Components是Salesforce提供的一种强大的工具，它可以帮助我们快速构建用户界面。而Apex是Salesforce的一种编程语言，类似于Java，可以用来编写业务逻辑。 我们还会学习如何使用CSS来美化我们的应用程序。CSS是一种样式表语言，它可以控制网页的布局和外观。通过使用CSS主题组件，我们可以让应用程序看起来更加专业和一致。 在开发过程中，我们还需要定义和操作组件的属性，处理系统和用户的事件。这些都是开发应用程序时非常基础但又非常重要的部分。 当然，开发过程中难免会遇到问题，所以我们也会学习如何调试和排查应用程序中的错误。这就像是给应用程序做体检，找出问题并解决它。 最后，我们会学习如何与Apex合作，使用基本的Aura组件，提出和处理事件，以及使用Lightning数据服务进行CRUD操作。CRUD操作是指创建（Create）、读取（Read）、更新（Update）和删除（Delete）数据，这是任何应用程序都需要的功能。 好了，这就是第2单元的概述。希望你们能跟上我的节奏，如果有任何问题，随时提问。我们接下来会一步步深入这些内容，确保你们都能掌握。加油！

  ▶ 播放视频 查看详情
• 167

  Topics - 220

  第 220 页

  同学们，今天我们来聊聊Salesforce中的Lightning数据服务和服务器端的Apex。这两个工具在Salesforce开发中非常重要，它们帮助我们更高效地处理数据。 首先，我们来看看，加载记录，。在Lightning组件中，我们可以使用Lightning数据服务来加载记录。这个服务非常强大，它可以直接从Salesforce数据库中获取数据，而不需要编写复杂的Apex代码。你只需要指定你想要加载的记录类型和ID，数据服务就会帮你搞定。 接下来是，创建记录，。同样地，使用Lightning数据服务，你可以轻松地创建新的记录。你只需要定义好记录的字段和值，然后调用数据服务的创建方法，新的记录就会被添加到数据库中。 然后是，重传对记录的更改，。有时候，你可能需要更新已经存在的记录。使用Lightning数据服务，你可以轻松地获取记录，修改它，然后保存更改。这个过程非常直观，就像你在使用一个普通的表单一样。 最后是，删除记录，。如果你需要从数据库中删除某个记录，Lightning数据服务也提供了相应的方法。你只需要指定要删除的记录ID，数据服务就会帮你处理剩下的工作。 当然，所有这些操作也可以通过服务器端的Apex代码来实现。Apex是Salesforce的一种编程语言，它允许你编写更复杂的逻辑来处理数据。虽然Apex功能强大，但使用Lightning数据服务可以让你更快地实现功能，特别是在处理简单的数据操作时。 好了，今天的课程就到这里。希望大家能够理解Lightning数据服务和Apex在处理数据时的不同方式。记得查看学生指南中的幻灯片，那里有更多的细节和示例代码可以帮助你更好地理解这些概念。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 168

  Intro to Lightning Data Service

  第 221 页

  今天我们来聊聊Lightning Data Service，简称LDS。这是一个非常强大的工具，它可以帮助我们在Salesforce的Lightning组件中直接加载、创建、编辑或删除记录，而且不需要编写任何Apex代码。听起来是不是很方便？ 首先，LDS的一个大优点是它自动处理了共享规则和字段级别的安全性。这意味着你不需要担心数据的安全问题，LDS会帮你搞定。这样，你就可以更专注于构建用户界面和提升用户体验了。 其次，使用LDS还可以提高应用的性能和用户界面的一致性。因为LDS是在客户端缓存数据的，所以它可以减少服务器的请求次数，让应用运行得更快。同时，由于LDS提供了一种标准化的方式来访问数据，所以你的应用界面也会更加一致，给用户更好的体验。 最后，建议你在开发Lightning组件时，尽可能使用LDS来读取和修改Salesforce中的数据。这样不仅可以减少代码量，还能让你的应用更加高效和安全。 总之，Lightning Data Service是一个非常实用的工具，它让数据操作变得更简单、更安全、更高效。希望你能在开发中充分利用它，提升你的应用性能！

  ▶ 播放视频 查看详情
• 169

  Intro to Lightning Data Service - 222

  第 222 页

  今天我们来聊聊Salesforce中的Lightning Data Service，简称LDS。这是一个非常强大的工具，它可以帮助我们更简单地访问和操作数据。 首先，LDS的一个大优点是，它比使用服务器端的Apex控制器来访问数据要简单得多。这意味着，如果你想要从Salesforce中获取数据，使用LDS可以让这个过程更加直接和高效。 对于只需要读取数据的场景，你甚至可以在组件的标记中完全声明性地完成，不需要写任何额外的代码。这大大简化了开发流程，让你可以更专注于业务逻辑的实现。 而对于需要修改数据的场景，虽然你可能需要编写一些JavaScript代码，但相比使用Apex，代码量大致相同，甚至更少。更重要的是，使用LDS，你完全不需要编写Apex代码，所有的数据访问逻辑都可以整合到你的组件中。这不仅减少了代码的复杂性，也使得维护和更新变得更加容易。 总的来说，Lightning Data Service是一个非常实用的工具，它通过简化数据访问和操作，帮助我们更高效地构建Salesforce应用。希望这个简短的介绍能帮助你更好地理解LDS的优势和使用场景。

  ▶ 播放视频 查看详情
• 170

  Intro to Lightning Data Service - 223

  第 223 页

  今天我们来聊聊Salesforce中的Lightning Data Service，简称LDS。这个工具非常强大，不仅可以帮助我们减少代码量，还能带来很多其他的好处。 首先，LDS是基于一个高效的本地存储系统构建的。这个存储系统是共享的，意味着所有使用LDS的组件都可以访问同一个存储空间。这样做的好处是，当你在一个组件中加载了一条记录，这条记录会被缓存起来。如果其他组件也需要访问同一条记录，它们可以直接从缓存中获取，而不需要再次从服务器加载。 这样一来，无论有多少个组件在使用同一条记录，这条记录都只会被加载一次。这大大提高了应用的性能，因为减少了不必要的数据加载和网络请求。 此外，LDS还能提高用户界面的一致性。想象一下，如果一个组件更新了某条记录，其他使用这条记录的组件会立即收到通知，并且在大多数情况下会自动刷新显示最新的数据。这样，用户看到的信息总是最新的，不会出现数据不一致的情况。 总结一下，Lightning Data Service不仅让我们的代码更简洁，还通过共享缓存和自动刷新机制，提升了应用的性能和用户体验。希望这个解释能帮助你更好地理解LDS的强大之处。

  ▶ 播放视频 查看详情
• 171

  Intro to Lightning Data Service - 224

  第 224 页

  今天我们来聊聊Salesforce中的Lightning Data Service，简称LDS。这是一个非常强大的工具，可以帮助我们在Salesforce的Lightning平台上更高效地处理数据。 首先，LDS主要用于读取和写入单个记录。如果你需要操作多个记录，比如批量更新或者删除，那么你可能还是需要依赖Apex代码来完成这些操作。 LDS可以在多个Salesforce环境中使用，包括Lightning Experience、Salesforce移动版、Lightning Communities、Lightning Out、以及为Visualforce和独立Lightning应用程序设计的Lightning组件。这意味着无论你是在桌面、手机，还是在社区中使用Salesforce，LDS都能派上用场。 LDS支持处理记录集合或查询，但需要注意的是，它只能处理有记录ID的记录。没有记录ID的记录，LDS是无法处理的。 LDS还有一个很酷的功能，就是它共享一个数据存储，并且能够提供通知。这意味着，如果一个组件更改了某个记录，那么所有使用这个记录的组件都会收到通知，从而可以更新显示的数据。不过，如果记录在服务器上被更改了，LDS是不会通知组件的，这一点需要注意。 总的来说，LDS是一个非常实用的工具，可以帮助我们在Salesforce的Lightning平台上更高效地处理数据。希望这个简短的介绍能帮助你更好地理解和使用LDS。

  ▶ 播放视频 查看详情
• 172

  Loading a Record

  第 225 页

  今天我们来聊聊如何在Salesforce的Lightning组件中使用Lightning Data Service来加载记录。这个方法非常强大，因为它可以帮助我们直接从Salesforce数据库中获取数据，而不需要编写复杂的Apex代码。 首先，你需要在你的Lightning组件中添加一个叫做`force:recordData`的标签。这个标签是专门用来处理记录数据的。在这个标签里，你需要指定几个关键的属性： 1. ，记录的ID，：这是你想要加载的那条记录的唯一标识。就像你去图书馆找书，需要知道书的编号一样。 2. ，组件属性，：这是你希望将加载的记录数据存储在组件的哪个属性中。你可以把它想象成一个容器，用来存放你从数据库里取出来的数据。 3. ，字段列表，：这是你希望从记录中获取的具体字段。比如，如果你只对客户的名称和账单城市感兴趣，你就可以指定只加载这些字段。你可以通过`fields`属性来明确列出这些字段，例如`fields=&quot;Name, BillingCity, BillingState&quot;`。 举个例子，如果你想要加载一个客户的记录，并且只关心客户的名称和账单城市，你可以这样设置你的`force:recordData`标签： ```html ``` 在这个例子中，`recordId`是你想要加载的记录的ID，`fields`指定了你想要获取的字段，而`targetRecord`则是你希望将加载的记录数据存储在组件的`customerRecord`属性中。 通过这种方式，你就可以轻松地在你的Lightning组件中加载和使用Salesforce的记录数据了。希望这个解释对你有帮助！如果有任何疑问，随时问我哦。

  ▶ 播放视频 查看详情
• 173

  Loading a Record - 226

  第 226 页

  今天我们来聊聊如何在Salesforce中加载记录数据，特别是通过使用`layoutType`属性来指定布局。这个方法非常实用，因为它可以让你的组件自动适应管理员定义的布局变化。 首先，`layoutType`属性有两个有效的值：`full`和`compact`。这两个值分别代表了两种不同的布局类型。`full`布局会加载记录的所有字段，而`compact`布局则只会加载记录的部分字段，通常是那些最常用或最重要的字段。 使用`layoutType`的好处是，无论管理员如何调整布局，你的组件都能自动适应这些变化。这意味着，如果管理员在布局中添加或删除了某些字段，你的组件不需要做任何修改，就能正确地显示这些字段。 举个例子，假设你正在开发一个自定义的Lightning组件，用来显示客户的详细信息。你可以通过设置`layoutType`为`full`，来确保组件加载并显示客户记录的所有字段。这样，无论管理员如何调整客户记录的布局，你的组件都能正确地显示所有信息。 总结一下，通过使用`layoutType`属性，你可以轻松地让你的组件适应Salesforce中的布局变化，而不需要手动调整代码。这不仅提高了开发效率，也增强了组件的灵活性和可维护性。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 174

  Loading a Record - 227

  第 227 页

  让我们来一起看看这段代码。这段代码是用Salesforce的Aura框架编写的，它的主要功能是加载一个联系人的记录，并显示这个联系人的姓名和电子邮件。 首先，我们定义了几个属性（`aura:attribute`）。`contactId`是用来存储我们想要加载的联系人记录的ID。`contact`是用来存储加载的联系人记录的数据。`recordError`是用来存储加载记录时可能出现的错误信息。 接下来，我们使用了`force:recordData`组件。这个组件是Salesforce提供的一个强大的工具，它可以帮助我们从数据库中加载记录。我们通过`recordId`属性告诉它我们要加载哪个记录，通过`targetFields`属性告诉它把加载的数据存到哪里，通过`targetError`属性告诉它如果出错把错误信息存到哪里。我们还通过`fields`属性指定了我们想要加载的字段，这里我们选择了姓名、电子邮件、电话和描述。 最后，我们在页面上显示了加载的联系人记录的姓名和电子邮件。如果加载记录时出现了错误，我们也会显示这个错误信息。 这就是这段代码的主要功能。希望这个解释能帮助你理解这段代码的工作原理。如果你有任何问题，欢迎随时提问。

  ▶ 播放视频 查看详情
• 175

  Loading a Record - 228

  第 228 页

  让我们来聊聊这段代码的作用和它是如何工作的。 首先，这段代码是用来处理Salesforce Lightning组件中的记录加载和更新的。想象一下，你有一个应用程序，里面有一个联系人列表。当你点击一个联系人时，应用程序需要显示这个联系人的详细信息。但是，如果你点击了另一个联系人，应用程序需要知道如何更新显示的信息。 在这段代码中，我们有两个主要的函数：`onContactIdChange` 和 `收件箱记录已更新`。 1. ，onContactIdChange，：这个函数的作用是当用户选择了一个新的联系人时，它会告诉应用程序去重新加载这个新联系人的数据。它通过调用 `cmp.find(&#39;recordMail&#39;).reloadRecord()` 来实现这一点。这里的 `recordMail` 是一个占位符，代表了你想要重新加载的记录。`reloadRecord()` 是 Lightning Data Service 提供的一个方法，它会强制重新加载记录的数据。 2. ，收件箱记录已更新，：这个函数是一个简单的日志记录器。当记录被更新后，它会在控制台中打印出“记录已更新！”这条消息。这可以帮助开发者确认记录确实被更新了。 总的来说，这段代码确保了当用户选择不同的联系人时，应用程序能够正确地更新显示的信息，并且开发者可以通过控制台日志来确认这一过程是否成功。希望这能帮助你更好地理解这段代码的工作原理！

  ▶ 播放视频 查看详情
• 176

  Creating a Record

  第 229 页

  今天我们来聊聊如何在Salesforce的Lightning框架中使用Lightning数据服务来创建记录。这个过程其实很简单，我会一步步带你了解。 首先，我们需要使用一个叫做`force:recordData`的组件。这个组件非常强大，它可以帮助我们处理记录的数据。但是，在创建新记录的时候，我们不需要给它分配`recordId`，因为这是一个全新的记录，还没有ID呢。 接下来，我们要调用`force:recordData`上的一个函数，叫做`getNewRecord()`。这个函数的作用是加载一个记录模板。你可以把它想象成一张空白的表格，等待你填写信息。 填写信息的过程就是给这个新记录赋值。你可以设置各种字段的值，比如名字、日期、金额等等。这些值会根据你的业务需求来定。 最后，当你填好了所有需要的信息，就可以调用`force:recordData`上的另一个函数，叫做`saveRecord()`。这个函数的作用就是保存你刚刚创建的新记录。一旦保存成功，这个记录就会被存储在Salesforce的数据库中，以后你就可以随时查看或修改它了。 总结一下，创建记录的过程就是：加载模板、填写信息、保存记录。是不是很简单呢？希望这个解释能帮助你更好地理解如何在Salesforce中使用Lightning数据服务来创建记录。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 177

  Creating a Record - 230

  第 230 页

  让我们一步一步来理解这段代码。这段代码是用来在Salesforce的Lightning组件中创建一个新的联系人记录的。我会尽量用简单的语言来解释每一部分的作用。 1. ，定义属性，： - ``：这里我们定义了一个名为`newContact`的属性，它的类型是`Object`，也就是一个对象。这个属性将用来存储我们要创建的新联系人的信息。 - ``：这个属性`impleNewContact`也是一个对象，它用来存储新联系人的具体字段值，比如名字、姓氏等。 - ``：这个属性`newContactError`是一个字符串，用来存储创建联系人时可能出现的错误信息。 2. ，初始化处理程序，： - ``：这段代码定义了一个初始化处理程序。当组件加载时，它会调用控制器中的`doInit`函数。这个函数通常用来做一些初始化设置，比如设置默认值。 3. ，使用`force:recordData`组件，： - ``：这个组件是Salesforce提供的，用来处理记录的创建、读取、更新和删除操作。在这里，我们用它来创建一个新的联系人记录。`layoutType=&quot;Full&quot;`表示我们希望获取完整的记录布局，`targetRecord`指向我们要创建的新记录，`targetFields`指向我们要填充的字段，`targetError`则用来捕获任何错误信息。 4. ，显示错误信息，： - ``：这段代码用来检查是否有错误信息。如果有错误信息（即`newContactError`不为空），就会显示一个错误消息。 - `{!v.newContactError}`：这是一个UI组件，用来显示错误消息。`severity=&quot;error&quot;`表示这是一个错误消息，`closable=&quot;true&quot;`表示用户可以关闭这个消息。 5. ，显示表单，： - `<div class="slds-form_stacked">`：这是一个包含表单的容器，使用了Salesforce Lightning Design System (SLDS) 的样式。 - ``：这是一个输入框，用来输入联系人的名字。`value`属性绑定到`impleNewContact.FirstName`，表示这个输入框的值会存储在这个字段中。`required=&quot;true&quot;`表示这个字段是必填的。 - ``：这是一个按钮，点击它会调用控制器中的`handleSaveContact`函数，用来保存联系人。`variant=&quot;brand&quot;`表示这是一个品牌风格的按钮，`class=&quot;slds-m-top_medium&quot;`表示按钮上方有一定的间距。 总结一下，这段代码的主要功能是创建一个新的联系人记录。它定义了一些属性来存储联系人的信息和可能的错误，使用`force:recordData`组件来处理记录的创建，并提供了一个表单让用户输入联系人的信息。如果有错误发生，它会显示一个错误消息。 希望这个解释对你有帮助！如果有任何问题，随时问我。</div>

  ▶ 播放视频 查看详情
• 178

  Creating a Record - 231

  第 231 页

  让我们来聊聊这段代码。这段代码是在Salesforce的Lightning组件中使用的，主要是用来初始化一个新的联系人记录。我们可以把它想象成在Salesforce中准备一张空白的联系人表格，等待用户填写。 首先，我们有一个叫做`doInit`的函数。这个函数是在组件初始化的时候自动调用的，就像你打开一个新的Excel表格时，表格会自动准备好一样。 在这个函数里，我们使用了一个叫做`component.find`的方法来找到一个特定的组件，这里叫做`contactRecordCreator`。这个组件的作用是帮助我们创建一个新的联系人记录。 接下来，我们调用了`getNewRecord`方法。这个方法需要几个参数： 1. 第一个参数是对象的类型，这里我们传入的是“联系人”，表示我们要创建一个新的联系人记录。 2. 第二个参数是记录类型ID，这里我们传入的是`null`，表示我们不指定任何特定的记录类型。 3. 第三个参数是一个布尔值，表示是否跳过缓存。这里我们传入的是`false`，表示我们不跳过缓存。 然后，我们使用了一个回调函数来处理创建记录后的结果。这个回调函数会在记录创建完成后被调用。在这个回调函数里，我们首先获取了新创建的记录和可能出现的错误信息。 如果出现了错误，或者记录没有成功创建，我们会在控制台中打印出错误信息。如果一切顺利，我们会在控制台中打印出记录的类型，表示记录已经成功初始化。 总的来说，这段代码的作用就是在组件加载时，自动准备一个新的联系人记录，方便用户进行填写和保存。希望这个解释能帮助你更好地理解这段代码的作用！

  ▶ 播放视频 查看详情
• 179

  Uploading Changes to a Record

  第 232 页

  让我们来聊聊如何在Salesforce中保存记录的更改。想象一下，你正在编辑一个联系人的信息，现在你想把这些更改上传到Salesforce平台。这里有一个简单的步骤和代码示例来帮助你理解这个过程。 首先，我们需要一个函数来处理保存操作。这个函数叫做`HandleSaveContact`。在这个函数里，我们会找到负责创建或更新记录的服务，然后调用它的`saveRecord`方法来保存记录。 ```javascript HandleSaveContact: function(component, event, helper) { var service = component.find(&quot;contactRecordCreator&quot;); service.saveRecord(function(saveResult) { if (saveResult.state === &quot;SUCCESS&quot; || saveResult.state === &quot;DRAFT&quot;) { // 记录保存成功 alert(&quot;Record Saved&quot;); } else if (saveResult.state === &quot;INCOMPLETE&quot;) { // 处理不完整状态 alert(&quot;用户处于离线状态，设备不支持草稿。&quot;); } else if (saveResult.state === &quot;ERROR&quot;) { alert(&#39;保存联系人时出现问题，错误：&#39; + JSON.stringify(saveResult.error)); } else { alert(&#39;未知问题，状态：&#39; + saveResult.state); } }); } ``` 在这段代码中，我们首先通过`component.find`方法找到了一个名为`contactRecordCreator`的服务。这个服务是用来处理记录保存的。然后，我们调用了这个服务的`saveRecord`方法，并传入了一个回调函数。这个回调函数会在保存操作完成后被调用，并且会接收到一个`saveResult`对象，这个对象包含了保存操作的结果。 在回调函数中，我们检查`saveResult.state`的值来确定保存操作是否成功。如果状态是`SUCCESS`或`DRAFT`，我们就会弹出一个提示框告诉用户记录已经保存成功。如果状态是`INCOMPLETE`，我们就会提示用户他们可能处于离线状态，设备不支持保存草稿。如果状态是`ERROR`，我们就会显示一个错误信息，告诉用户保存时出现了问题。最后，如果状态是其他未知状态，我们也会弹出一个提示框，告诉用户遇到了未知问题。 这就是如何在Salesforce中保存记录更改的基本流程。希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 180

  Deleting a Record

  第 233 页

  让我们来聊聊如何在Salesforce中删除记录。首先，我们需要使用一个叫做`force:recordData`的组件，这个组件可以帮助我们处理记录的创建、读取、更新和删除操作。 在你的代码中，你首先通过`component.find(&quot;recordSYS&quot;)`找到了这个`force:recordData`组件，并把它赋值给了一个变量`service`。这个`service`对象就是我们用来操作记录的工具。 接下来，你调用了`service.deleteRecord()`方法来删除记录。这个方法需要一个回调函数，这个回调函数会在删除操作完成后被调用。在这个回调函数里，你可以检查删除操作的结果。 在回调函数里，你首先检查了`deleteReport.State`的值。如果这个值是`SUCCESS`或者`DRAFT`，那就表示记录已经成功删除了，你可以弹出一个提示框告诉用户“记录已删除”。 如果`deleteReport.State`的值是`INCOMPLY`，那就表示用户可能离线了，或者设备不支持草稿模式，这时候你可以弹出一个提示框告诉用户“用户离线，设备不支持草稿”。 如果`deleteReport.State`的值是`WRIGHT`，那就表示在删除记录时遇到了一些问题，你可以弹出一个提示框，显示具体的错误信息。 最后，如果`deleteReport.State`的值是其他情况，那就表示遇到了未知的问题，你可以弹出一个提示框，显示状态和错误信息。 总结一下，要删除记录，你需要使用`force:recordData`组件的`deleteRecord()`方法，并在回调函数中处理删除操作的结果。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 181

  Handling Record Changes

  第 234 页

  让我们来聊聊这段代码。这段代码主要是用来处理记录变更的。想象一下，你有一个记录，这个记录可能会被改变、加载、删除或者保存。这段代码就是用来检测这些变化的。 首先，我们有一个变量叫做`eventParams`，它通过`server.getParams()`方法获取了一些参数。这些参数会告诉我们记录发生了什么变化。 接下来，我们有一个`if`语句，它会检查`eventParams.changeType`的值。这个值会告诉我们记录发生了什么类型的变化。 - 如果`changeType`是`&quot;Changed&quot;`，那就意味着记录被更改了。你可以在这里写一些代码来处理记录被更改的情况。 - 如果`changeType`是`&quot;LOADED&quot;`，那就意味着记录被加载到了缓存中。你可以在这里写一些代码来处理记录被加载的情况。 - 如果`changeType`是`&quot;REMOVED&quot;`，那就意味着记录被删除了。这里有一个`alert`函数，它会弹出一个提示框，告诉你“记录收件箱”。你可以在这里写一些代码来处理记录被删除的情况。 - 如果`changeType`是`&quot;WRIGHT&quot;`，那就意味着记录被加载、保存或者删除了。你可以在这里写一些代码来处理这些操作。 总的来说，这段代码就是用来根据记录的不同变化类型，执行不同的操作。你可以根据你的需求，在每个`if`语句里面添加你想要的代码。

  ▶ 播放视频 查看详情
• 182

  App Review – Custom Components

  第 236 页

  今天我们来聊聊Salesforce中的自定义组件，特别是关于“应用程序评论”这个功能。想象一下，你正在使用一个Salesforce应用程序，这个应用程序有一个页面，页面上有主要区域和右侧边栏。主要区域是用来展示重要信息的，而右侧边栏则可以用来放一些辅助信息或者工具。 在这个页面上，我们有一个叫做“学生浏览器”的自定义组件。这个组件的作用是让学生能够浏览和查找信息。它可能包含了一些搜索框、筛选条件或者列表视图，帮助学生快速找到他们需要的信息。 接下来，我们有一个“Chatter信息源”的标准件。Chatter是Salesforce的一个社交功能，允许用户在一个类似于社交媒体的环境中分享信息、文件和更新。这个标准件会显示与当前页面相关的Chatter活动，比如评论、点赞或者新的帖子。 然后，我们有一个“学生详情”的自定义组件。这个组件会展示特定学生的详细信息，比如他们的课程、成绩、出勤记录等。这个组件是高度定制的，可以根据需要展示不同的信息。 最后，我们有一个“StudentBrowserForm”自定义组件。这个组件可能是一个表单，用来收集学生的信息或者进行某些操作，比如注册课程、提交作业等。这个表单是专门为学生设计的，确保他们能够轻松地完成所需的操作。 总的来说，这些自定义组件和标准件共同工作，为学生提供了一个功能丰富、易于使用的应用程序页面。通过这种方式，Salesforce不仅能够满足基本的业务需求，还能够提供高度定制化的用户体验。希望这个解释能帮助你更好地理解Salesforce中的自定义组件和它们的应用。

  ▶ 播放视频 查看详情
• 183

  App Review – OOTB components

  第 237 页

  今天我们来聊聊Salesforce中的一些自定义组件和标准组件。这些组件可以帮助我们更高效地构建用户界面，提升用户体验。 首先，我们有一个叫做，StudentBrowserForm，的自定义组件。这个组件的主要作用是让学生能够通过一个表单来浏览信息。你可以把它想象成一个搜索框，学生可以在这里输入一些条件，然后系统会根据这些条件筛选出相关的学生信息。 接下来是，StudentTile，自定义组件。这个组件通常用来展示学生的基本信息，比如姓名、照片、班级等。你可以把它想象成一个小卡片，每个卡片代表一个学生，点击卡片可以看到更多详细信息。 然后我们有一个叫做，StudentDetails，的自定义组件。这个组件是用来展示学生的详细信息的。当你在，StudentTile，上点击某个学生时，这个组件就会显示出来，告诉你这个学生的更多细节，比如成绩、联系方式等。 接下来我们来看一些标准的Lightning组件。首先是，lightning:tabset，和，lightning:tab，。这两个组件通常一起使用，用来创建一个选项卡式的界面。你可以把不同的内容放在不同的选项卡里，用户可以通过点击选项卡来切换内容。 然后是，lightning:button，，这是一个标准的按钮组件。你可以用它来触发一些操作，比如提交表单、保存数据等。 ，lightning:card，是一个卡片组件，通常用来展示一些信息。你可以把图片、文字、按钮等内容放在卡片里，形成一个完整的信息展示单元。 ，lightning:select，是一个下拉选择框组件。用户可以通过它来选择不同的选项，比如选择班级、年级等。 最后，我们有一个叫做，force:recordData，的组件。这个组件是用来获取和操作记录数据的。你可以用它来查询、创建、更新或删除记录。 总结一下，今天我们介绍了几个自定义组件和标准组件。这些组件可以帮助我们快速构建出功能丰富、用户友好的界面。希望这些内容对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 184

  App Review - Events

  第 238 页

  让我们来聊聊这个应用程序评论，特别是关于“Events 238”的部分。我会尽量用简单的话来解释，这样你听起来会更容易理解。 首先，我们来看一下“学生浏览器”这部分。这里有两个主要的事件处理： 1. ，处理Studentselect-fire Aw讲师Studentselect应用事件，：这个事件是在学生被选中时触发的。想象一下，当你在一个列表中选择了一个学生，这个事件就会告诉系统：“嘿，这个学生被选中了，我们需要做一些事情。”然后，系统会根据这个事件来更新或显示相关的信息。 2. ，处理StudentFilterChange-刷新学生列表，：这个事件是在学生筛选条件改变时触发的。比如，如果你改变了筛选条件，比如年级或者班级，这个事件就会告诉系统：“筛选条件变了，我们需要重新加载学生列表。”这样，系统就会根据新的筛选条件来更新显示的学生列表。 接下来是“更改：火灾组件 活动学生滤镜更改”。这里的“火灾组件”可能是一个打字错误，应该是“触发组件”。这个部分的意思是，当学生筛选条件改变时，会触发一个组件来更新学生列表。 然后是“学生详细信息”部分： 1. ，处理Aw讲师学生已选择-重新加载记录，：这个事件是在讲师选择了一个学生后触发的。系统会重新加载这个学生的详细信息，以便讲师可以看到最新的数据。 2. ，onClick：消防应用程序 事件力量：RST记录，：这里的“消防应用程序”可能也是一个打字错误，应该是“触发应用程序”。这个事件是在点击某个按钮或链接时触发的，系统会根据这个事件来执行一些操作，比如加载或更新记录。 3. ，onClick：Fire组件 活动学生选择，：这个事件是在点击选择学生时触发的。系统会根据这个事件来更新或显示被选中的学生的详细信息。 总的来说，这些事件和操作都是为了确保当用户（比如讲师）在应用程序中进行选择或更改筛选条件时，系统能够及时地更新和显示正确的信息。希望这个解释能帮助你更好地理解这些事件的作用和流程。如果还有任何疑问，随时问我哦！

  ▶ 播放视频 查看详情
• 185

  Unit Summary

  第 239 页

  让我们来聊聊这个单元的内容。首先，HTML5应用程序真的很酷，因为它们允许开发者编写一套代码，这套代码可以在很多不同的设备上运行，比如手机、平板或者电脑。这意味着开发者不需要为每种设备单独编写代码，节省了很多时间和精力。 接下来，我们来看看Salesforce的Lightning组件框架。这个框架是基于Web标准的，也就是说，它使用了大家都熟悉的网络技术来构建应用。Lightning组件，特别是Aura Components，是由多个文件组成的。这些文件包括声明性的标记、处理客户端事件的JavaScript代码、样式文件、文档说明，以及通过Lightning App Builder来展示的组件。 Aura Components的一个亮点是它们可以通过声明性标记来定义用户界面，这使得开发过程更加直观和高效。同时，JavaScript用于处理用户的交互事件，比如点击按钮或者输入数据。样式文件则用来美化组件，让它们看起来更吸引人。 最后，Aura Components还支持不同范围的属性，包括全局、公共和私有属性。这些属性使得组件更加灵活，可以根据不同的需求来调整组件的行为和显示。通过使用这些属性，开发者可以创建出既强大又易于维护的组件。 总的来说，这个单元介绍了如何利用HTML5和Salesforce的Lightning框架来开发跨设备的应用程序，以及如何通过Aura Components来构建灵活且功能丰富的用户界面。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 186

  Unit Summary (CONTINUED)

  第 240 页

  让我们继续聊聊Salesforce的Aura组件。今天我们要讲的是关于Aura组件的一些关键点，这些知识点对于理解和开发Aura组件非常重要。 首先，每次当你修改Aura组件的属性时，比如改变一个表情符号，整个组件都会重新绘制。这意味着组件的界面会更新，以反映最新的属性值。这是一个自动的过程，确保用户界面总是最新的。 接下来，Lightning框架支持大多数DOM级别的事件。DOM是文档对象模型的缩写，它代表了网页的结构。在Lightning框架中，你可以监听和处理这些事件，比如点击、滚动等，这使得你的组件可以响应用户的交互。 Aura组件不仅生成HTML，它们还能引发自己的事件。这意味着你的组件可以与其他组件通信，或者触发特定的行为。这是构建动态和交互式用户界面的关键。 使用Helper函数是一个好习惯。Helper函数可以帮助你重用代码，减少重复，并且可以简化客户端控制器的逻辑。这样，你的代码会更加整洁，也更容易维护。 最后，你的自定义Aura组件会自动包含在Salesforce的文档系统中。你可以向组件的文档页面添加更多的详细信息和示例，这样其他开发者在使用你的组件时，可以更容易地理解和使用它。 这些就是今天的主要内容。希望这些信息能帮助你更好地理解和使用Aura组件。如果你有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 187

  Unit Summary (CONTINUED) - 241

  第 241 页

  让我们继续聊聊Salesforce中的Aura组件和相关的开发技巧。首先，Aura组件是Salesforce提供的一种强大的工具，它可以帮助我们构建动态和交互式的用户界面。Salesforce自带了许多现成的Aura组件，这些组件可以直接用于处理用户的输入和输出，非常方便。 当你开发这些组件时，可能会遇到一些客户端错误。这时候，Google Chrome浏览器就派上用场了。你可以使用Chrome的开发者工具来调试这些错误，找出问题所在。同时，Salesforce还提供了一个开发人员控制台，这个控制台可以帮助你调试和解决Apex控制器中的问题。Apex控制器是Aura组件与Salesforce平台通信的桥梁，确保它们能够正常工作是非常重要的。 此外，Salesforce还提供了一个叫做Lightning数据服务的功能。这个功能可以让你更容易地在应用程序中添加CRUD（创建、读取、更新、删除）操作。这意味着你可以更轻松地管理数据，而不需要编写大量的代码。 总的来说，Aura组件和Apex控制器是Salesforce开发中非常重要的部分，而使用Chrome和Salesforce开发人员控制台可以帮助你更有效地调试和解决问题。Lightning数据服务则让数据管理变得更加简单。希望这些信息对你有所帮助！

  ▶ 播放视频 查看详情
• 188

  Unit Review

  第 242 页

  让我们来聊聊Salesforce中的一些关键概念，特别是关于Lightning组件的部分。首先，我们得明白，Salesforce的Lightning框架是一个非常强大的工具，它允许开发者创建动态、响应式的用户界面。 1. ，单元审阅组件、控制器、辅助对象、样式、文档、渲染器、设计、SVG，：这些都是构建Lightning组件时需要考虑的部分。组件是用户界面的构建块，控制器处理用户交互，辅助对象包含可重用的逻辑，样式负责组件的外观，文档和设计帮助开发者理解和规划组件，渲染器控制组件如何渲染，而SVG用于创建矢量图形。 2. ，错误处理，：在开发过程中，错误是不可避免的。Salesforce提供了多种错误处理机制，比如使用`try-catch`块来捕获和处理异常。 3. ，Component.find()，：这是一个用于查找组件实例的方法。它允许你在控制器或辅助对象中引用特定的组件实例。 4. ，Lightning Locker，：这是一个安全架构，它通过隔离不同命名空间的组件来增强安全性。这意味着一个命名空间的组件不能直接访问另一个命名空间的组件，从而防止潜在的安全风险。 5. ，自定义事件，：在Lightning组件中，你可以创建自定义事件来在组件之间传递信息。这些事件需要使用`aura:handler`来处理，并且通常在与激发事件的组件不同的组件中进行处理。 6. ，重用函数，：为了提高代码的可维护性和重用性，你应该将想要重用的函数放在辅助对象中。这样，你可以在多个组件中调用这些函数，而不需要重复编写代码。 7. ，Lightning Data Service (LDS)，：这是一个用于访问和操作记录数据的服务。它的优点是代码更少，性能更好，因为它只需要加载一次记录，无论有多少组件在使用它。缺点是它仅适用于单个记录。 希望这些解释能帮助你更好地理解Salesforce中的这些概念。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 189

  Lab: Phase 1 Using Lightning Data Service

  第 243 页

  今天我们来聊聊Salesforce中的Lightning数据服务。这个工具非常强大，能帮助我们在Salesforce Lightning组件中轻松地获取和操作数据。 首先，Lightning数据服务是Salesforce提供的一个内置服务，它允许我们在不编写Apex代码的情况下，直接从Lightning组件中访问和操作Salesforce的数据。这意味着我们可以更快地构建应用，而不需要担心后端逻辑。 使用Lightning数据服务，我们可以执行几种常见的操作，比如查询记录、创建新记录、更新现有记录以及删除记录。所有这些操作都可以通过简单的JavaScript代码来完成，这使得开发过程更加高效和直观。 举个例子，如果我们想要在Lightning组件中显示一个客户的详细信息，我们可以使用Lightning数据服务来查询这个客户的记录，然后将数据显示在组件中。这样，我们就可以在不刷新页面的情况下，实时更新和显示数据。 总的来说，Lightning数据服务是一个非常实用的工具，它简化了数据操作的过程，让我们能够更专注于构建用户界面和提升用户体验。希望这个简单的介绍能帮助你理解Lightning数据服务的基本概念和用途。接下来，我们可以通过一些实际的例子来更深入地探索它的功能。

  ▶ 播放视频 查看详情
• 190

  Objectives

  第 244 页

  让我们来聊聊这个单元的内容。首先，这个单元的目标是让你能够自信地实现一个基于制表符的界面。这是什么意思呢？简单来说，就是你会学会如何在Salesforce中创建一个有多个标签页的界面，用户可以通过点击不同的标签来查看不同的内容。 接下来，你会学习如何调用Apex函数。Apex是Salesforce的一种编程语言，你可以用它来从Salesforce平台读取多个记录。想象一下，你有一个数据库，里面有很多客户信息，你可以用Apex来获取这些信息，并在你的界面上显示出来。 然后，你会使用Lightning Data Service。这是一个非常强大的工具，它可以帮助你将数据写入Salesforce.com的自定义字段。也就是说，你不仅可以从Salesforce读取数据，还可以将新的数据写回去。 最后，你会学习如何使用Aura Components来格式化数据。Aura Components是Salesforce的一种UI框架，你可以用它来创建漂亮的、用户友好的界面。通过Aura Components，你可以确保你的数据在界面上看起来整洁、易读。 总结一下，这个单元会让你掌握如何创建一个有多个标签页的界面，如何从Salesforce读取数据，如何将数据写回Salesforce，以及如何格式化这些数据。听起来是不是很有趣？让我们开始吧！

  ▶ 播放视频 查看详情
• 191

  Lab Phase 1: Output Data from Lightning Data Service

  第 245 页

  让我们来聊聊这个实验阶段的内容。这个实验主要是关于Lightning Data Service的，特别是如何在一个自定义组件中使用它来显示学生详情。 首先，我们有一个按钮，叫做“学生详情”。这个按钮的作用是，当你点击它的时候，它会显示一个自定义组件，这个组件会展示一些关于学生的详细信息。 但是，这里有一个条件：如果你没有选择一个学生（也就是说，如果你没有点击一个叫做StudentTile的东西），那么这个“学生详情”按钮是不可见的。这意味着，只有当你在页面上选择了一个学生之后，这个按钮才会出现，你才能点击它来查看学生的详细信息。 这个设置是为了确保只有当有学生被选中时，相关的详细信息才会被展示出来，这样可以避免显示不必要的信息，保持页面的整洁和用户界面的友好性。 所以，总结一下，这个实验的目的是教你如何使用Lightning Data Service来动态地控制页面上元素的可见性，以及如何根据用户的选择来展示相关的数据。这是一个非常实用的技能，可以帮助你创建更加动态和响应式的Salesforce应用。

  ▶ 播放视频 查看详情