Skip to content

J
jbt-zh

OpenDocCN / jbt-zh
9 个月 前同步成功

通知 0
Star 8
Fork 1
J
jbt-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 6bf5daa3 编写于 作者: W wizardforcel
浏览文件
操作

2020-06-13 19:17:44

上级 7ced9b49
展开全部 隐藏空白更改
内联 并排
Showing with 2555 addition and 2555 deletion
docs/10.md
浏览文件 @ 6bf5daa3
# 使用Eclipse编写Hello World程序
# 使用 Eclipse 编写 Hello World 程序
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/write-hello-world-application-using-eclipse/](https://javabeginnerstutorial.com/core-java-tutorial/write-hello-world-application-using-eclipse/)
在本教程中，我们将学习使用Eclipse IDE创建Hello World应用程序。 要了解以下材料，您应该熟悉如何使用Eclipse来获得有关Eclipse [的说明，请单击此处](https://javabeginnerstutorial.com/eclipse-2/eclipse-beginners-tutorial-2/)。
在本教程中，我们将学习使用 Eclipse IDE 创建 Hello World 应用程序。 要了解以下材料，您应该熟悉如何使用 Eclipse 来获得有关 Eclipse [的说明，请单击此处](https://javabeginnerstutorial.com/eclipse-2/eclipse-beginners-tutorial-2/)。
## 创建项目
要创建我们的项目，请从菜单中选择 ***文件> >新建> > Java Project*** 。 如果找不到“ Java项目”作为选项，请单击“其他”，如下所示。
要创建我们的项目，请从菜单中选择 ***文件> >新建> > Java Project*** 。 如果找不到“ Java 项目”作为选项，请单击“其他”，如下所示。
![1](img/e7d9fc1772e8c1c27fcf36aefc4041bf.png)
从下一个窗口中选择Java项目，然后单击 ***下一步*** 。 提供一个项目名称，如下所示。
从下一个窗口中选择 Java 项目，然后单击 ***下一步*** 。 提供一个项目名称，如下所示。
![3](img/32b060afa9b923ccc6971614ca91eaea.png)
单击 ***完成*** 。 Eclipse将要求您将透视图更改为Java Perspective。 单击是。 如您所见，一个新的Java项目将出现在 **Java Perspective** 的 **Package Explorer视图**中。
单击 ***完成*** 。 Eclipse 将要求您将透视图更改为 Java Perspective。 单击是。 如您所见，一个新的 Java 项目将出现在 **Java Perspective** 的 **Package Explorer 视图**中。
![4](img/a9ce9baa74bb4e80e4361fe07fe5155f.png)
## 创建一个包
现在，我们将为我们的Java项目创建一个程序包。 **软件包**用于避免*命名冲突*，以便*控制访问*（访问修饰符）和*来捆绑相关类型*的组。
现在，我们将为我们的 Java 项目创建一个程序包。 **软件包**用于避免*命名冲突*，以便*控制访问*（访问修饰符）和*来捆绑相关类型*的组。
要创建包，请在Java项目（ **JBTProject** ）中选择 ***src*** 文件夹，右键单击该文件夹并选择 ***新的> >软件包*** 。
要创建包，请在 Java 项目（ **JBTProject** ）中选择 ***src*** 文件夹，右键单击该文件夹并选择 ***新的> >软件包*** 。
![6](img/4b5ed46224997e82dcb1c4ebc6955164.png)
在对话框中输入软件包名称，然后单击“完成”。
## 创建Java类的步骤
## 创建 Java 类的步骤
创建包后，我们可以在包内创建Java类。 右键单击要在其中创建Java类的包，然后选择 ***新> >类。***
创建包后，我们可以在包内创建 Java 类。 右键单击要在其中创建 Java 类的包，然后选择 ***新> >类。***
![7](img/6d4e87c0b4ff2d17e794eb61e35da4e9.png)
......@@ -38,27 +38,27 @@
在对话框中提供类名称，然后单击完成。 其他选项可供选择。 选择其他选项以创建您的主要方法。
创建Class后，项目的结构将如下所示。
创建 Class 后，项目的结构将如下所示。
![9](img/9fac88764f8ae64a67757f40365fd1d3.png)
## 编译&运行Java应用程序
## 编译&运行 Java 应用程序
创建Java应用程序之后，下一步就是编译并运行代码。
创建 Java 应用程序之后，下一步就是编译并运行代码。
### 编译代码
要编译代码，请使用键盘快捷键“ CTRL + B”。 它将构建Java应用程序。 如果要构建单个应用程序，请单击该应用程序，然后从菜单中选择 ***项目> >构建项目*** 。
要编译代码，请使用键盘快捷键“ CTRL + B”。 它将构建 Java 应用程序。 如果要构建单个应用程序，请单击该应用程序，然后从菜单中选择 ***项目> >构建项目*** 。
### 运行代码
要运行代码，您可以使用键盘快捷键“ ALT + SHIFT + X”和J。
要运行代码，您可以使用键盘快捷键“ ALT + SHIFT + X”和 J。
或者，您可以单击文件，然后从菜单中选择 ***运行> >运行为> > Java应用程序*** 。
或者，您可以单击文件，然后从菜单中选择 ***运行> >运行为> > Java 应用程序*** 。
单击“运行”后，将执行Hello World应用程序，并且您的输出将显示在 ***控制台视图*** 中。
单击“运行”后，将执行 Hello World 应用程序，并且您的输出将显示在 ***控制台视图*** 中。
现在我们已经学会了在Eclipse中创建Hello World应用程序。 在下一篇文章中，我们将讨论Eclipse提供的一些其他功能，这些功能使编码更容易。
现在我们已经学会了在 Eclipse 中创建 Hello World 应用程序。 在下一篇文章中，我们将讨论 Eclipse 提供的一些其他功能，这些功能使编码更容易。
<noscript><iframe allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" frameborder="0" height="360" src="https://www.youtube.com/embed/79l5QSuI4ko?feature=oembed" title="Hello world program in java eclipse" width="640"></iframe></noscript>
......
docs/100.md
浏览文件 @ 6bf5daa3
# 7河。 Selenium IDE –暂停和反射
# 7 河。 Selenium IDE –暂停和反射
> 原文： [https://javabeginnerstutorial.com/selenium/7r-ide-pause-reflect/](https://javabeginnerstutorial.com/selenium/7r-ide-pause-reflect/)
Hiya测试人员！ 欢迎来到我们有关Selenium IDE的最终文章。 摇一摇，列出我们到目前为止所学的功能！
Hiya 测试人员！ 欢迎来到我们有关 Selenium IDE 的最终文章。 摇一摇，列出我们到目前为止所学的功能！
我想借此机会向您介绍另一个出色的BrainBell。
我想借此机会向您介绍另一个出色的 BrainBell。
***BrainBell*** – *想想！* 不要仿佛错过了航班。 暂停，思考和思考。 您越用脑去思考，您就会越记得。
戴上 *FeatureBelt* 。 也就是说，到目前为止，您已经在Selenium IDE中学习了有关功能的所有新技能。 **您**（是的，您没听错！您）现在将所有内容放在一起，并针对您自己的不同场景创建新的测试用例。 如果您在执行过程中遇到任何问题，请在评论部分给我大喊。
戴上 *FeatureBelt* 。 也就是说，到目前为止，您已经在 Selenium IDE 中学习了有关功能的所有新技能。 **您**（是的，您没听错！您）现在将所有内容放在一起，并针对您自己的不同场景创建新的测试用例。 如果您在执行过程中遇到任何问题，请在评论部分给我大喊。
我们涵盖了很多领域； 您几乎已经到达 *Magic Meadows的边界。*
我们涵盖了很多领域； 您几乎已经到达 *Magic Meadows 的边界。*
下一个是什么？ ***现在该到南方旅行了！***
......
docs/101.md
浏览文件 @ 6bf5daa3
# 8.给Freebie惊喜
# 8.给 Freebie 惊喜
> 原文： [https://javabeginnerstutorial.com/selenium/8-surprise-freebie/](https://javabeginnerstutorial.com/selenium/8-surprise-freebie/)
朋友！ 希望您通过本博客系列学习Selenium IDE感到很愉快。 在进入我们的下一个工具Selenium WebDriver之前，我想给您一个免费赠品。
朋友！ 希望您通过本博客系列学习 Selenium IDE 感到很愉快。 在进入我们的下一个工具 Selenium WebDriver 之前，我想给您一个免费赠品。
既然您已经在某种程度上目睹了Selenium工具的强大功能，则可能需要将此工具套件引入您的项目中以实现自动化。 要克服这里最困难的障碍就是说服您的客户。 大多数客户并没有真正了解您要介绍的工具的技术性，但会涉及成本和回报。
既然您已经在某种程度上目睹了 Selenium 工具的强大功能，则可能需要将此工具套件引入您的项目中以实现自动化。 要克服这里最困难的障碍就是说服您的客户。 大多数客户并没有真正了解您要介绍的工具的技术性，但会涉及成本和回报。
因此，如果您可以集中精力并强调Selenium Tool Suite在这些方面的积极方面，那么您一定会品尝到成功的。 而这正是我要令您惊讶的地方。
因此，如果您可以集中精力并强调 Selenium Tool Suite 在这些方面的积极方面，那么您一定会品尝到成功的。 而这正是我要令您惊讶的地方。
每个人都喜欢听与故事相关的故事。 同意吗 因此，让我们以故事的形式解释Selenium的超凡魅力，而不是使用传统的无聊的Power Point演示文稿，让我们激动不已。 这将使他们一直充满吸引力和说服力。 我强烈建议您使用 [prezi](https://prezi.com/) 创建业务演示，因为它超出了上述所有期望。 请注意，这是我根据我的专业经验提出的个人建议。
每个人都喜欢听与故事相关的故事。 同意吗 因此，让我们以故事的形式解释 Selenium 的超凡魅力，而不是使用传统的无聊的 Power Point 演示文稿，让我们激动不已。 这将使他们一直充满吸引力和说服力。 我强烈建议您使用 [prezi](https://prezi.com/) 创建业务演示，因为它超出了上述所有期望。 请注意，这是我根据我的专业经验提出的个人建议。
我已经使用prezi做了一个简单的演示，并以相同的场景作为示例。 这是 [vimeo链接](https://vimeo.com/188186769)，显示了我在幻灯片中浏览的视频。
我已经使用 prezi 做了一个简单的演示，并以相同的场景作为示例。 这是 [vimeo 链接](https://vimeo.com/188186769)，显示了我在幻灯片中浏览的视频。
您一定在想我是怎么想到这个好主意的。 正如小兵曾经说过的，我当然会自言自语！ 有时我需要专家的建议。 （好吧，明白了，别那样看着我！）继续…
......@@ -18,27 +18,27 @@
该视频首先向您展示演示的整体情况。 我们的大脑更喜欢视觉而不是文字。 因此，始终要畅所欲言，并在幻灯片上显示相关图像，而不是数百个单词，这始终是一个好习惯。
* *<u>幻灯片1：</u>* 'WOW'。 用**爆炸**打开演示文稿！ 首先要引起您对样式的“迷恋”。 可能是*现实生活中的事件，假想的场景，发人深省的报价或问题*
* *<u>幻灯片 1：</u>* 'WOW'。 用**爆炸**打开演示文稿！ 首先要引起您对样式的“迷恋”。 可能是*现实生活中的事件，假想的场景，发人深省的报价或问题*
* *<u>幻灯片2：</u>* 面临的挑战。 简单介绍一下我们在没有自动化的情况下面临的挑战/问题。 允许客户**考虑**。 这也应该作为介绍的介绍。 例如，显示简单场景的图形。 对于每个发行版，测试用例数量都会增加（回归套件+发行用例），从而增加了总体开发成本。 这最终减少了产品的上市时间，这可能会对总收入/销售额造成重大打击。
* *<u>幻灯片 2：</u>* 面临的挑战。 简单介绍一下我们在没有自动化的情况下面临的挑战/问题。 允许客户**考虑**。 这也应该作为介绍的介绍。 例如，显示简单场景的图形。 对于每个发行版，测试用例数量都会增加（回归套件+发行用例），从而增加了总体开发成本。 这最终减少了产品的上市时间，这可能会对总收入/销售额造成重大打击。
* *<u>幻灯片3：</u>* 现在是时候在他们的脑海中植入**创意**了。 引入**硒**！
* *<u>幻灯片 3：</u>* 现在是时候在他们的脑海中植入**创意**了。 引入**硒**！
* *<u>幻灯片4：</u>* 高亮显示2至3个关键点。 “ **FREE** ”是当今的流行语，因为客户担心金钱和数字。 现在，您甚至可以在他们的脸上看到微笑。
* *<u>幻灯片 4：</u>* 高亮显示 2 至 3 个关键点。 “ **FREE** ”是当今的流行语，因为客户担心金钱和数字。 现在，您甚至可以在他们的脸上看到微笑。
* *<u>幻灯片5：</u>* 简要介绍Selenium Suite的**概述**，涵盖每分钟工具。 切记不要听起来太技术性，并尽量避免使用专业术语。
* *<u>幻灯片 5：</u>* 简要介绍 Selenium Suite 的**概述**，涵盖每分钟工具。 切记不要听起来太技术性，并尽量避免使用专业术语。
* *<u>幻灯片6：</u>* 讨论**优势**。 这些内容应涵盖幻灯片2中突出显示的挑战。请保持内容的吸引力。
* *<u>幻灯片 6：</u>* 讨论**优势**。 这些内容应涵盖幻灯片 2 中突出显示的挑战。请保持内容的吸引力。
* *<u>幻灯片7：</u>* 谢谢。 现在是时候总结“ **要点**”并用**结束“钩子”** 结束演示的时候了。 您可以使用*讲义，轶事，演示，音频/视频效果，助记符和标语*最好将其链接到开幕式！
* *<u>幻灯片8：</u>* **问题**。 花一些时间来澄清客户之间可能出现的疑问或疑虑，并确保他们带着满意的表情离开房间。
* *<u>幻灯片 7：</u>* 谢谢。 现在是时候总结“ **要点**”并用**结束“钩子”** 结束演示的时候了。 您可以使用*讲义，轶事，演示，音频/视频效果，助记符和标语*最好将其链接到开幕式！
* *<u>幻灯片 8：</u>* **问题**。 花一些时间来澄清客户之间可能出现的疑问或疑虑，并确保他们带着满意的表情离开房间。
## *提示：*
* 带着**微笑**出现。
* 合适的**衣服** –必须穿着舒适，整洁的衣服。
* **肢体语言** –避免将手放在口袋中或握在固定装置上，在讲话时以轻微的身体移动或手势来表达您的感觉。
* 取悦**语音** –使用适当的调制，在必要时重复，请尽量减少使用uh，um等填充物，实际上，您知道等等。
* 取悦**语音** –使用适当的调制，在必要时重复，请尽量减少使用 uh，um 等填充物，实际上，您知道等等。
* **传送信息的速度**也起着重要作用。
* **眼神交流** –使用眼动横扫听众，营造出个人化注意力的印象。
* 最重要的是：说话时，请勿在投影**的前面挡住**的视图。
......@@ -49,7 +49,7 @@
Like the presentation I created and looking to make a copy of it and edit according to your requirements? Here is my **[prezi link](https://prezi.com/t23nditffrdy/?utm_campaign=share&utm_medium=copy&rc=ex0share)**. I have kept it ‘*public and reusable*’. Please click the like button before you make a copy of it 🙂 Hope you enjoy this freebie.
在评论部分让我知道您的想法和经验。 即将在我们即将推出的，期待已久的WebDriver系列中与您见面！
在评论部分让我知道您的想法和经验。 即将在我们即将推出的，期待已久的 WebDriver 系列中与您见面！
###### 下一篇文章
......
docs/102.md
浏览文件 @ 6bf5daa3
......@@ -2,42 +2,42 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9a-webdriver-architecture/](https://javabeginnerstutorial.com/selenium/9a-webdriver-architecture/)
学习WebDriver的方法很有趣，而且常常使人弯腰，所以请做好准备……在 *Southern Surprises* 的土地上跋涉，我们将遇到一些奇妙，荒唐和古怪的事物。
学习 WebDriver 的方法很有趣，而且常常使人弯腰，所以请做好准备……在 *Southern Surprises* 的土地上跋涉，我们将遇到一些奇妙，荒唐和古怪的事物。
您将发现Selenium WebDriver为什么将使您的生活变得如此好-从质量保证的角度来看，以及为什么我们将其称为“统治冠军”！ 为了掌握该工具并构建测试自动化框架，对我们正在处理的内容进行更深入的了解非常重要。 那么，我们还等什么呢？ 现在让我们开始打好基础！
您将发现 Selenium WebDriver 为什么将使您的生活变得如此好-从质量保证的角度来看，以及为什么我们将其称为“统治冠军”！ 为了掌握该工具并构建测试自动化框架，对我们正在处理的内容进行更深入的了解非常重要。 那么，我们还等什么呢？ 现在让我们开始打好基础！
哪种方式比图形表示更容易理解？ 这就是我们的大脑喜欢记住事物的方式，这也是我们将要前进的方式。
![WebDriver Architecture](img/a771b70e8626ad97f91b67946b0c8f69.png)
从这张图片中我们可以看出，这个架构有3层，
从这张图片中我们可以看出，这个架构有 3 层，
1. 绑定
2. WebDriver API和
2. WebDriver API 和
3. 车手
让我们一次讨论这一步骤。 *大字警报！* **绑定** –根据Wikipedia，这意味着将一件事映射到另一件事。 只要记住这两个词，*粘合代码*即可。
让我们一次讨论这一步骤。 *大字警报！* **绑定** –根据 Wikipedia，这意味着将一件事映射到另一件事。 只要记住这两个词，*粘合代码*即可。
有很多高级编程语言，您可能想使用C＃，但其他人可能更喜欢Python。 每个人都希望利用通用的WebDriver API来以自己舒适的语言自动化浏览器。 这是语言级别绑定进入图片的地方。 这些就像用相应语言编写的*粘合代码/包装库*与WebDriver API进行通信。 除了Java，C＃，Ruby，Python绑定外，还有更多。 也很容易添加新的。
有很多高级编程语言，您可能想使用 C＃，但其他人可能更喜欢 Python。 每个人都希望利用通用的 WebDriver API 来以自己舒适的语言自动化浏览器。 这是语言级别绑定进入图片的地方。 这些就像用相应语言编写的*粘合代码/包装库*与 WebDriver API 进行通信。 除了 Java，C＃，Ruby，Python 绑定外，还有更多。 也很容易添加新的。
接下来到**驱动程序**上。 WebDriver API使我们可以拥有一些驱动程序，这些驱动程序知道如何驱动与之对应的特定浏览器。 我们有Chrome驱动程序，IE驱动程序，Microsoft Edge驱动程序，Firefox驱动程序（内置）等。还有移动专用驱动程序，例如iOS驱动程序，Selendriod（适用于Android的硒）等。例如，Chrome驱动程序知道如何 驱动Chrome浏览器执行低级活动，例如操纵Web元素，导航到网页，从中获取用户输入等等。
接下来到**驱动程序**上。 WebDriver API 使我们可以拥有一些驱动程序，这些驱动程序知道如何驱动与之对应的特定浏览器。 我们有 Chrome 驱动程序，IE 驱动程序，Microsoft Edge 驱动程序，Firefox 驱动程序（内置）等。还有移动专用驱动程序，例如 iOS 驱动程序，Selendriod（适用于 Android 的硒）等。例如，Chrome 驱动程序知道如何 驱动 Chrome 浏览器执行低级活动，例如操纵 Web 元素，导航到网页，从中获取用户输入等等。
我们在代码中提到了所需的驱动程序。 该驱动程序服务器作为可执行文件提供。 当我们运行测试时，驱动程序服务器会侦听本地计算机上的端口。 它将解释从WebDriver API接收的命令，在实际的浏览器上执行，并将结果通过API返回给我们的代码。
我们在代码中提到了所需的驱动程序。 该驱动程序服务器作为可执行文件提供。 当我们运行测试时，驱动程序服务器会侦听本地计算机上的端口。 它将解释从 WebDriver API 接收的命令，在实际的浏览器上执行，并将结果通过 API 返回给我们的代码。
## *放大并将其放在一起：*
在本系列中，我们将使用Java编写测试程序。 可以将其视为用于使浏览器自动化的脚本语言。 相应的Java绑定代码向WebDriver API发出命令。 与浏览器通信的WebDriver的所有实现都使用通用的有线协议。 有线协议基本上是基于HTTP的RESTful Web服务，以“命令”和“响应”的请求/响应对实现。 因此，我们可以将HTTP请求（例如GET，POST，PUT等）发送到驱动程序服务器。 该服务器是运行RemoteWebDriver的计算机。 例如，ChromeDriver服务器是指直接实现有线协议的Chrome浏览器。 运行Java测试时，此服务器将侦听并等待这些命令。 它会相应地解释它们，执行低级浏览器活动，然后以HTTP响应消息进行响应。
在本系列中，我们将使用 Java 编写测试程序。 可以将其视为用于使浏览器自动化的脚本语言。 相应的 Java 绑定代码向 WebDriver API 发出命令。 与浏览器通信的 WebDriver 的所有实现都使用通用的有线协议。 有线协议基本上是基于 HTTP 的 RESTful Web 服务，以“命令”和“响应”的请求/响应对实现。 因此，我们可以将 HTTP 请求（例如 GET，POST，PUT 等）发送到驱动程序服务器。 该服务器是运行 RemoteWebDriver 的计算机。 例如，ChromeDriver 服务器是指直接实现有线协议的 Chrome 浏览器。 运行 Java 测试时，此服务器将侦听并等待这些命令。 它会相应地解释它们，执行低级浏览器活动，然后以 HTTP 响应消息进行响应。
## *缩小：*
语言级别绑定（发出命令）**->** WebDriver通用有线协议（基于HTTP的基于REST的Web服务）**->** 驱动程序服务器（解释HTTP请求并以HTTP响应进行响应 讯息）
语言级别绑定（发出命令）**->** WebDriver 通用有线协议（基于 HTTP 的基于 REST 的 Web 服务）**->** 驱动程序服务器（解释 HTTP 请求并以 HTTP 响应进行响应 讯息）
如果您没有获得完整的图像，请不要惊慌。 休息片刻，因为有很多帖子可以跟进，随着我们的前进，您一定会获得清晰的了解。
注意，在Eclipse中设置WebDriver时，您将看到实际的Java语言绑定。 很快我们将下载驱动程序服务器可执行文件，将它们包含在我们的代码中，并使浏览器操作也自动执行。 因此，加油并注意即将发布的帖子！
注意，在 Eclipse 中设置 WebDriver 时，您将看到实际的 Java 语言绑定。 很快我们将下载驱动程序服务器可执行文件，将它们包含在我们的代码中，并使浏览器操作也自动执行。 因此，加油并注意即将发布的帖子！
很快见，祝您有美好的一天。
###### 下一篇文章
##### [9b。 WebDriver –在Eclipse中设置](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/ "9b. WebDriver – Set Up in Eclipse")
\ No newline at end of file
##### [9b。 WebDriver –在 Eclipse 中设置](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/ "9b. WebDriver – Set Up in Eclipse")
\ No newline at end of file
docs/103.md
浏览文件 @ 6bf5daa3
# 9b。 WebDriver –在Eclipse中设置
# 9b。 WebDriver –在 Eclipse 中设置
> 原文： [https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)
欢迎来到我们的第一篇关于WebDriver系列的*探索*帖子。 建议您密切注意并共同努力，以使设置过程更加简单！
欢迎来到我们的第一篇关于 WebDriver 系列的*探索*帖子。 建议您密切注意并共同努力，以使设置过程更加简单！
## 先决条件：
1. 拥有有效的互联网连接。
2. 在系统上下载并安装Java SE Development Kit（JDK）。 （http://www.oracle.com/technetwork/java/javase/downloads/index.html）
3. 下载Eclipse IDE。 不需要安装。 只需将所有内容提取到一个文件夹中，然后双击可执行文件即可。 （http://www.eclipse.org/downloads/）
2. 在系统上下载并安装 Java SE Development Kit（JDK）。 （http://www.oracle.com/technetwork/java/javase/downloads/index.html）
3. 下载 Eclipse IDE。 不需要安装。 只需将所有内容提取到一个文件夹中，然后双击可执行文件即可。 （http://www.eclipse.org/downloads/）
是时候按照3个步骤来设置环境了，
是时候按照 3 个步骤来设置环境了，
### <u>步骤1：</u>
### <u>步骤 1：</u>
转到 [http://www.seleniumhq.org/download/](http://www.seleniumhq.org/download/) 。 在“ Selenium Client & WebDriver语言绑定”部分下，单击“ Java”语言的下载链接。 （请注意，您看到的版本号可能与此处快照中的版本号不同，因为创建此文章时，最新的版本是3.0.0-beta2。）
转到 [http://www.seleniumhq.org/download/](http://www.seleniumhq.org/download/) 。 在“ Selenium Client & WebDriver 语言绑定”部分下，单击“ Java”语言的下载链接。 （请注意，您看到的版本号可能与此处快照中的版本号不同，因为创建此文章时，最新的版本是 3.0.0-beta2。）
![WebDriver Download](img/0b73e11622eb81a47c315a5dfca2bd33.png)
### <u>步骤2：</u>
### <u>步骤 2：</u>
将下载的文件解压缩到系统上所需的位置。 切换到Eclipse并选择所需的工作空间目录。
将下载的文件解压缩到系统上所需的位置。 切换到 Eclipse 并选择所需的工作空间目录。
创建一个新的Java项目，如下所示：File-> new-> Java Project。 我已将项目命名为“ WebDriver测试”。
创建一个新的 Java 项目，如下所示：File-> new-> Java Project。 我已将项目命名为“ WebDriver 测试”。
### <u>步骤3：</u>
### <u>步骤 3：</u>
右键单击创建的项目。 选择“构建路径”->“配置构建路径...”
![Set up in eclipse](img/0c13bbcf5a6e7496910ffb5dc4aeff5e.png)
现在有**两种方式**可以将外部JAR添加到我们的项目中。
现在有**两种方式**可以将外部 JAR 添加到我们的项目中。
## 方法1：
## 方法 1：
确保已选择“库”标签。 单击“添加外部JAR ...”按钮。 “ JAR选择”窗口将打开。 浏览至seleniumhq.org站点（Selenium Client和WebDriver语言绑定）中的文件的下载和提取位置。
确保已选择“库”标签。 单击“添加外部 JAR ...”按钮。 “ JAR 选择”窗口将打开。 浏览至 seleniumhq.org 站点（Selenium Client 和 WebDriver 语言绑定）中的文件的下载和提取位置。
确保选择所有类型为“可执行Jar文件”的文件。 目前，我在“ selenium-java-3.0.0-beta2”文件夹中有一个文件，在selenium-java-3.0.0-beta2 \ lib文件夹中有16个文件。
确保选择所有类型为“可执行 Jar 文件”的文件。 目前，我在“ selenium-java-3.0.0-beta2”文件夹中有一个文件，在 selenium-java-3.0.0-beta2 \ lib 文件夹中有 16 个文件。
点击“打开”，将它们添加到“库”标签中。
![set up - adding jars](img/880ea8dae2b40384dc07196fdbad4411.png)
## 方法2：
## 方法 2：
当您出于各种目的添加大量外部JAR文件（例如WebDriver，JUnit，Ant等）时，这确实非常方便。如果遵循方法1，则区分为每种目的添加的JAR可能会变得非常困难。 在方法2中，我们将相应地创建一个单独的文件夹和名称，以便于识别和记录文档。
当您出于各种目的添加大量外部 JAR 文件（例如 WebDriver，JUnit，Ant 等）时，这确实非常方便。如果遵循方法 1，则区分为每种目的添加的 JAR 可能会变得非常困难。 在方法 2 中，我们将相应地创建一个单独的文件夹和名称，以便于识别和记录文档。
确保选择了“库”标签。 单击，添加库…->用户库->接下来。
......@@ -54,36 +54,36 @@
![User library custom name](img/cecbd5cf7bdbab42d44db3cebb5143d1.png)
单击“添加外部JAR ...”按钮。 “ JAR选择”窗口将打开。 浏览至seleniumhq.org站点（Selenium Client和WebDriver语言绑定）中的文件的下载和提取位置。
单击“添加外部 JAR ...”按钮。 “ JAR 选择”窗口将打开。 浏览至 seleniumhq.org 站点（Selenium Client 和 WebDriver 语言绑定）中的文件的下载和提取位置。
Make sure that you select all the files with type, ‘Executable Jar File’.  Currently I have one file in ‘selenium-java-3.0.0-beta2’ folder and 16 files in selenium-java-3.0.0-beta2\lib folder.
点击“打开”，将它们添加到“用户库”窗口下创建的文件夹中。 点击“确定”，现在您将在“添加库”窗口中看到带有复选框的用户库。 确保选中此复选框，然后单击“完成”。 创建的用户库将在项目属性窗口的“库”选项卡中提供所有添加的外部JAR。
点击“打开”，将它们添加到“用户库”窗口下创建的文件夹中。 点击“确定”，现在您将在“添加库”窗口中看到带有复选框的用户库。 确保选中此复选框，然后单击“完成”。 创建的用户库将在项目属性窗口的“库”选项卡中提供所有添加的外部 JAR。
![set up - jars](img/9b17625febb72772c5a42b94205880b2.png)
单击“确定”按钮后，新添加的JAR将在“包资源管理器”窗格中的项目下显示。
单击“确定”按钮后，新添加的 JAR 将在“包资源管理器”窗格中的项目下显示。
![Eclipse package explorer](img/47b2fc334fea0ad2428f1895376e5580.png)
***<u>即时贴：</u>*** *（这只是告诉您做一个注释）*
*此设置可与Selenium 2版本完美配合（我已经使用了很长时间了，一切都很好）。 但是，如果您使用的是Selenium 3 beta版本（如上面的屏幕快照所示），则需要执行一些其他步骤。*
*此设置可与 Selenium 2 版本完美配合（我已经使用了很长时间了，一切都很好）。 但是，如果您使用的是 Selenium 3 beta 版本（如上面的屏幕快照所示），则需要执行一些其他步骤。*
* *从“ https://github.com/mozilla/geckodriver/releases”下载“ geckodriver.exe”。*
![set up - gecko driver](img/ea1465c979004461a1cb631d319582fe.png)
* *编写测试脚本时，请确保包括以下行（还要确保系统中的Firefox浏览器版本为48 +），*
* *编写测试脚本时，请确保包括以下行（还要确保系统中的 Firefox 浏览器版本为 48 +），*
```java
System.setProperty("webdriver.gecko.driver", "<path_to_geckodriver.exe>");
```
你猜怎么了？！ 您已经准备就绪，很快我们将通过启动Firefox浏览器来创建和运行我们的第一个测试脚本。
你猜怎么了？！ 您已经准备就绪，很快我们将通过启动 Firefox 浏览器来创建和运行我们的第一个测试脚本。
在另一篇文章中再见。 祝你今天愉快！
###### 下一篇文章
##### [9c。 WebDriver –启动Firefox](https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/ "9c. WebDriver – First test script by launching Firefox") 的第一个测试脚本
\ No newline at end of file
##### [9c。 WebDriver –启动 Firefox](https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/ "9c. WebDriver – First test script by launching Firefox") 的第一个测试脚本
\ No newline at end of file
docs/104.md
浏览文件 @ 6bf5daa3
# 9c。 WebDriver –启动Firefox的第一个测试脚本
# 9c。 WebDriver –启动 Firefox 的第一个测试脚本
> 原文： [https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/](https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/)
Hiya everyone! Time to grab a cup of Java, I mean coffee 😉
事不宜迟，让我们开始使用WebDriver中的第一个测试脚本。 在我们根据[上一篇文章](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)（添加了WebDriver JAR文件）创建的同一项目下，我创建了一个名为com.blog.tests的新程序包。
事不宜迟，让我们开始使用 WebDriver 中的第一个测试脚本。 在我们根据[上一篇文章](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)（添加了 WebDriver JAR 文件）创建的同一项目下，我创建了一个名为 com.blog.tests 的新程序包。
接下来，右键单击包-> New-> Class。
......@@ -16,13 +16,13 @@ Hiya everyone! Time to grab a cup of Java, I mean coffee 😉
我们将在第一个测试脚本中考虑的场景是：
1. 打开Firefox浏览器。
1. 打开 Firefox 浏览器。
2. 导航到“ https://www.google.com/”
3. 将页面标题声明为“ Google”。
4. 根据声明结果在控制台上显示一条消息。
5. 关闭浏览器。
***<u>便笺</u>* ：** *我们有一整篇文章专门用于声明和验证。 由于第一个脚本的主要座右铭是查看WebDriver的工作原理，因此让我们使用简单的if-else语句来比较实际和预期的页面标题。*
***<u>便笺</u>* ：** *我们有一整篇文章专门用于声明和验证。 由于第一个脚本的主要座右铭是查看 WebDriver 的工作原理，因此让我们使用简单的 if-else 语句来比较实际和预期的页面标题。*
**代码如下，**
......@@ -73,39 +73,39 @@ System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\Selenium\\
geckodriver-v0.10.0-win64\\geckodriver.exe");
```
Selenium 3 Beta版本不像Selenium 2\. *版本那样支持直接启动Firefox。 因此，必须通过“ webdriver.gecko.driver”系统属性设置驱动程序可执行文件“ geckodriver.exe”的路径。 指定在系统中相应保存可执行文件的路径。
Selenium 3 Beta 版本不像 Selenium 2\. *版本那样支持直接启动 Firefox。 因此，必须通过“ webdriver.gecko.driver”系统属性设置驱动程序可执行文件“ geckodriver.exe”的路径。 指定在系统中相应保存可执行文件的路径。
#### 2.接下来，为了实例化Firefox浏览器，我们将必须导入两个软件包。
#### 2.接下来，为了实例化 Firefox 浏览器，我们将必须导入两个软件包。
键入后，“ **WebDriver驱动程序=新的FirefoxDriver（）;** ”，在“ WebDriver”和“ FirefoxDriver（）”下方会出现一条波浪线。 悬停时，蚀将建议所有可能的快速修复。 单击建议导入相应程序包的第一个修复程序。
键入后，“ **WebDriver 驱动程序=新的 FirefoxDriver（）;** ”，在“ WebDriver”和“ FirefoxDriver（）”下方会出现一条波浪线。 悬停时，蚀将建议所有可能的快速修复。 单击建议导入相应程序包的第一个修复程序。
![test script - import packages](img/2a99d6b6cbb982884a90b4dbcb9b30ff.png)
* 以下软件包指定了WebDriver接口，该接口用于根据需要实例化新的浏览器窗口。
* 以下软件包指定了 WebDriver 接口，该接口用于根据需要实例化新的浏览器窗口。
```java
import org.openqa.selenium.WebDriver
```
***<u>即时贴：</u>*** *我们**不要**说，* *WebDriver* *驱动程序* *=* ***新的*** *WebDriver（）；* *因为WebDriver是一个接口，并且只包含已定义但未实现的空方法。 因此无法实例化。*
***<u>即时贴：</u>*** *我们**不要**说，* *WebDriver* *驱动程序* *=* ***新的*** *WebDriver（）；* *因为 WebDriver 是一个接口，并且只包含已定义但未实现的空方法。 因此无法实例化。*
* FirefoxDriver是特定于Firefox浏览器的类。 它具有根据接口WebDriver定义和实现的方法。 因此，这可以实例化。
* FirefoxDriver 是特定于 Firefox 浏览器的类。 它具有根据接口 WebDriver 定义和实现的方法。 因此，这可以实例化。
```java
import org.openqa.selenium.firefox.FirefoxDriver
```
因此，以下声明有点像我们的甘道夫。 （不要告诉我您还没有阅读或观看“指环王”系列！！）SeleniumVille历来最强大，最受尊敬的台词。 因为它为FirefoxDriver类创建了一个对象。 现在，根据WebDriver接口的约定，通过调用FirefoxDriver类中已经实现的方法，我们现在可以使用此对象（在这种情况下为“驱动程序”）自动执行Firefox浏览器上的各种操作。
因此，以下声明有点像我们的甘道夫。 （不要告诉我您还没有阅读或观看“指环王”系列！！）SeleniumVille 历来最强大，最受尊敬的台词。 因为它为 FirefoxDriver 类创建了一个对象。 现在，根据 WebDriver 接口的约定，通过调用 FirefoxDriver 类中已经实现的方法，我们现在可以使用此对象（在这种情况下为“驱动程序”）自动执行 Firefox 浏览器上的各种操作。
```java
WebDriver driver = new FirefoxDriver();
```
将启动的Firefox浏览器将具有默认配置文件。 它不会随Firefox实例一起加载任何扩展程序和插件，并且会在安全模式下运行。 如果您想了解有关Firefox配置文件的更多信息，请访问“ https://support.mozilla.org/en-US/kb/profiles-where-firefox-stores-user-data”。
将启动的 Firefox 浏览器将具有默认配置文件。 它不会随 Firefox 实例一起加载任何扩展程序和插件，并且会在安全模式下运行。 如果您想了解有关 Firefox 配置文件的更多信息，请访问“ https://support.mozilla.org/en-US/kb/profiles-where-firefox-stores-user-data”。
同样，对于其他浏览器（例如Chrome，IE，Safari等），我们按照WebDriver接口中指定的相同协定（即，实现接口中定义的方法）编写特定的类。 在下一篇文章中，我们将通过特定示例了解如何使用其他浏览器。
同样，对于其他浏览器（例如 Chrome，IE，Safari 等），我们按照 WebDriver 接口中指定的相同协定（即，实现接口中定义的方法）编写特定的类。 在下一篇文章中，我们将通过特定示例了解如何使用其他浏览器。
#### 3.现在，声明String类型的必要变量。
#### 3.现在，声明 String 类型的必要变量。
```java
String baseUrl = "https://www.google.com";
......@@ -113,15 +113,15 @@ String pageTitle = "";
String expectedTitle = "Google";
```
我猜很简单，自我解释。 我们只是声明String类型的变量并为其分配值。 **baseUrl** 是我们希望在Firefox浏览器窗口中为测试场景调用的URL。 目前， **pageTitle** 保持为空，因为这将是我们将从浏览器中获取的实际值。 **ExpectedTitle** 是将与实际值进行比较的期望值。
我猜很简单，自我解释。 我们只是声明 String 类型的变量并为其分配值。 **baseUrl** 是我们希望在 Firefox 浏览器窗口中为测试场景调用的 URL。 目前， **pageTitle** 保持为空，因为这将是我们将从浏览器中获取的实际值。 **ExpectedTitle** 是将与实际值进行比较的期望值。
#### 4.导航到Google页面。
#### 4.导航到 Google 页面。
```java
driver.get(baseUrl);
```
这是我们要做的第一件事。 “获取”方法用于导航到指定的URL。 在这种情况下为 [https://www.google.com](https://www.google.com) 。
这是我们要做的第一件事。 “获取”方法用于导航到指定的 URL。 在这种情况下为 [https://www.google.com](https://www.google.com) 。
***<u>即时贴：</u>*** *驱动程序* *.navigate（）。to（* *baseUrl* *）; 也达到相同的结果。 试试看！*
......@@ -131,7 +131,7 @@ driver.get(baseUrl);
pageTitle = driver.getTitle();
```
页面标题的实际值可以使用getTitle（）方法获得。 然后将标题保存到变量pageTitle中，以供进一步声明。
页面标题的实际值可以使用 getTitle（）方法获得。 然后将标题保存到变量 pageTitle 中，以供进一步声明。
#### 6.比较页面标题并在控制台中显示结果。
......@@ -143,7 +143,7 @@ if(pageTitle.equals(expectedTitle)){
}
```
检查存储在pageTitle中的实际值是否等于辅助值的期望值。 System.out.println（）打印指定的参数和换行符。 这里只是纯Java！
检查存储在 pageTitle 中的实际值是否等于辅助值的期望值。 System.out.println（）打印指定的参数和换行符。 这里只是纯 Java！
#### 7.关闭浏览器窗口。
......@@ -151,7 +151,7 @@ if(pageTitle.equals(expectedTitle)){
driver.quit();
```
quit（）方法关闭所有浏览器窗口，并完全结束WebDriver会话。 这样可以避免在未正确清除任何相关文件的情况下可能发生的内存泄漏。
quit（）方法关闭所有浏览器窗口，并完全结束 WebDriver 会话。 这样可以避免在未正确清除任何相关文件的情况下可能发生的内存泄漏。
***<u>便签</u>*** **：** *驱动程序* *.close（）; 也可以使用* *。 不同之处在于，它将关闭当前关注的浏览器窗口。*
......
docs/105.md
浏览文件 @ 6bf5daa3
......@@ -4,19 +4,19 @@
如果您无法执行并查看输出，那么逐行代码遍历有什么好处？ 因此，不必再大惊小怪了，让我们运行代码！！
Eclipse使我们能够通过3种方式来完成相同的任务，
Eclipse 使我们能够通过 3 种方式来完成相同的任务，
* **方法1：**单击Eclipse中的“运行”快捷方式图标。
* **方法2：**右键单击类文件，运行方式-> Java应用程序。
* **方法3：**使用组合键CTRL + F11。
* **方法 1：**单击 Eclipse 中的“运行”快捷方式图标。
* **方法 2：**右键单击类文件，运行方式-> Java 应用程序。
* **方法 3：**使用组合键 CTRL + F11。
![Test execution](img/c351fb5a9a535fca616a318ec05a50be.png)
### *散布一些视觉效果：*
执行我们的测试将打开一个新的Firefox浏览器窗口，并按照代码执行测试步骤。 如上面的屏幕快照所示，输出显示在控制台中。
执行我们的测试将打开一个新的 Firefox 浏览器窗口，并按照代码执行测试步骤。 如上面的屏幕快照所示，输出显示在控制台中。
WebDriver系列的第一个 ***BrainBell*** 的时间：*回忆！* 您知道吗，在记住事物的过程中，我们甚至还添加了新的想法？ 回忆是对大脑中散布的元素的动态重建-称之为创造性的重新想象。 您记得的越多，就越记得！
WebDriver 系列的第一个 ***BrainBell*** 的时间：*回忆！* 您知道吗，在记住事物的过程中，我们甚至还添加了新的想法？ 回忆是对大脑中散布的元素的动态重建-称之为创造性的重新想象。 您记得的越多，就越记得！
因此，回想一下我们是如何为刚刚执行的拳头场景编写代码的，而您都可以尝试自己的一些简单场景。 如果您在旅途中遇到任何颠簸，请在评论部分给我大喊。
......
docs/106.md
浏览文件 @ 6bf5daa3
......@@ -2,30 +2,30 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9e-webdriver-code-launching-browsers/](https://javabeginnerstutorial.com/selenium/9e-webdriver-code-launching-browsers/)
如果您只能使用Selenium（即Firefox）在一个浏览器中自动化测试，但您的Web应用程序也支持Chrome和IE，该怎么办？ 这意味着所有三个浏览器都需要测试！ 如果是这种情况，那么硒就像把头埋在沙子里一样有用。
如果您只能使用 Selenium（即 Firefox）在一个浏览器中自动化测试，但您的 Web 应用程序也支持 Chrome 和 IE，该怎么办？ 这意味着所有三个浏览器都需要测试！ 如果是这种情况，那么硒就像把头埋在沙子里一样有用。
哦，不要惊慌！ 我们的统治冠军WebDriver在这里为我们提供帮助。 这是我们今天的主题。 让我们潜入吧！
哦，不要惊慌！ 我们的统治冠军 WebDriver 在这里为我们提供帮助。 这是我们今天的主题。 让我们潜入吧！
**第1步：**首先！ 让我们下载所需的可执行文件。 转到“ www.seleniumhq.org/download”。
**第 1 步：**首先！ 让我们下载所需的可执行文件。 转到“ www.seleniumhq.org/download”。
* *InternetExplorerDriver* 在“ Internet Explorer驱动程序服务器”部分下可用。
* *ChromeDriver，Opera和SafariDriver* 位于“第三方浏览器驱动程序”部分下。
* *InternetExplorerDriver* 在“ Internet Explorer 驱动程序服务器”部分下可用。
* *ChromeDriver，Opera 和 SafariDriver* 位于“第三方浏览器驱动程序”部分下。
在本文中，我们将仅讨论 *InternetExplorerDriver* 和 *ChromeDriver* 。 设置其他浏览器也应遵循类似的步骤。
![Browser download](img/10655a5d16771e9ca93d13474f7932c7.png)
**步骤2：**下载可执行文件后，解压缩并将它们保存在所需的路径中。 我在Eclipse IDE的项目中创建了一个名为“浏览器驱动程序”的文件夹（右键单击软件包->新建->文件夹），并复制了下载的文件以便于访问。
**步骤 2：**下载可执行文件后，解压缩并将它们保存在所需的路径中。 我在 Eclipse IDE 的项目中创建了一个名为“浏览器驱动程序”的文件夹（右键单击软件包->新建->文件夹），并复制了下载的文件以便于访问。
**步骤3：**现在，让我们通过“右键单击包-> New-> Class”并将它们命名为“ **HelloWorld_IE.java** ”，创建两个新类。 和“ **HelloWorld_Chrome.java** ”。
**步骤 3：**现在，让我们通过“右键单击包-> New-> Class”并将它们命名为“ **HelloWorld_IE.java** ”，创建两个新类。 和“ **HelloWorld_Chrome.java** ”。
包浏览器窗格现在如下所示，
![Eclipse window](img/ebd69f7cfb885357926bbf804e51ae73.png)
让我们考虑一个非常简单的情况，因为我们的主要目标是查看是否可以启动IE和Chrome浏览器，
让我们考虑一个非常简单的情况，因为我们的主要目标是查看是否可以启动 IE 和 Chrome 浏览器，
1. 根据测试用例打开IE / Chrome浏览器。
1. 根据测试用例打开 IE / Chrome 浏览器。
2. 导航到“ https://www.google.com/”
3. 在控制台中显示“ Hello World”消息。
4. 关闭浏览器。
......@@ -58,7 +58,7 @@ public class HelloWorld_IE {
}
```
如果注意到的话，此代码与我们在上一篇文章“ **第一个测试脚本–通过启动Firefox** ”中看到的代码非常相似。
如果注意到的话，此代码与我们在上一篇文章“ **第一个测试脚本–通过启动 Firefox** ”中看到的代码非常相似。
这些其他浏览器需要设置系统属性，因为不支持直接启动该属性。
......@@ -68,7 +68,7 @@ System.setProperty("webdriver.ie.driver", "browser-drivers\\IEDriverServer.exe")
要求驱动程序可执行文件“ IEDriverServer.exe”的路径必须由“ webdriver.ie.driver”系统属性设置。 指定在系统中相应保存可执行文件的路径。
为了实例化IE浏览器，需要进行的另一项主要更改是，
为了实例化 IE 浏览器，需要进行的另一项主要更改是，
```java
WebDriver driver = new InternetExplorerDriver();
......@@ -81,7 +81,7 @@ import org.openqa.selenium.WebDriver;
import org.openqa.selenium.ie.InternetExplorerDriver;
```
根据提供的注释，以下代码看起来很不言自明。 IE浏览器启动后，它便导航到google页面，将“ Hello World”消息打印到控制台并关闭浏览器窗口。
根据提供的注释，以下代码看起来很不言自明。 IE 浏览器启动后，它便导航到 google 页面，将“ Hello World”消息打印到控制台并关闭浏览器窗口。
执行此测试后的控制台窗口如下所示，
......@@ -118,18 +118,18 @@ public class HelloWorld_Chrome {
如果将此代码与“ HelloWorld_IE.java”进行比较，则只有两个值得注意的变化。
1. 系统属性设置
2. ChromeDriver类实例化
2. ChromeDriver 类实例化
因此，我们可以得出结论，通过指定相应的系统属性并提供准确的驱动程序类实例化，可以借助WebDriver轻松启动和自动化相应的浏览器。
因此，我们可以得出结论，通过指定相应的系统属性并提供准确的驱动程序类实例化，可以借助 WebDriver 轻松启动和自动化相应的浏览器。
在执行Chrome浏览器的代码后，控制台窗口如下所示，
在执行 Chrome 浏览器的代码后，控制台窗口如下所示，
![ConsoleOutput](img/dc6554a9843a4bed5594a69c7ae71c0d.png)
我猜想，WebDriver终于慢慢地在阳光下崭露头角了！ 如果您在启动各种浏览器时遇到任何问题，欢迎大家在评论部分中表达自己的意见。
我猜想，WebDriver 终于慢慢地在阳光下崭露头角了！ 如果您在启动各种浏览器时遇到任何问题，欢迎大家在评论部分中表达自己的意见。
在那之前，在另一篇文章中再见！ 祝你今天愉快！
###### 下一篇文章
##### [9f。 WebDriver – JUnit环境设置](https://javabeginnerstutorial.com/selenium/9f-webdriver-junit-environment-setup/ "9f. WebDriver – JUnit Environment Set-up")
\ No newline at end of file
##### [9f。 WebDriver – JUnit 环境设置](https://javabeginnerstutorial.com/selenium/9f-webdriver-junit-environment-setup/ "9f. WebDriver – JUnit Environment Set-up")
\ No newline at end of file
docs/107.md
浏览文件 @ 6bf5daa3
# 9f。 WebDriver – JUnit环境设置
# 9f。 WebDriver – JUnit 环境设置
> 原文： [https://javabeginnerstutorial.com/selenium/9f-webdriver-junit-environment-setup/](https://javabeginnerstutorial.com/selenium/9f-webdriver-junit-environment-setup/)
大家好！ 带出隐藏在您体内的测试忍者，因为今天我们将为JUnit框架设置环境。
大家好！ 带出隐藏在您体内的测试忍者，因为今天我们将为 JUnit 框架设置环境。
### 跳入：
#### 步骤1：
#### 步骤 1：
转到 [http://junit.org/junit4/](http://junit.org/junit4/) ，然后点击“下载并安装”链接。
![Junit download link](img/2ebeaa310c0820cf2a30387c19b8deca.png)
#### 第2步：
#### 第 2 步：
以下几点将使该过程更加容易理解，
1. 您将被重定向到GitHub。 在“普通的JAR”下，可以使用junit和hamcrest-core罐子。
2. 点击“ junit.jar”会将您重定向到包含下载链接的页面。 点击最新版本的“ jar”链接（撰写本文时为v4.12）。 它将自动下载到您的系统。
3. 接下来，点击“ hamcrest-core.jar”。 与上述类似，单击最新的“ jar”下载链接（截至本帖子发布之日起为v1.3）。
4. 这样，两个必需的jar都立即下载到您的系统中。
1. 您将被重定向到 GitHub。 在“普通的 JAR”下，可以使用 junit 和 hamcrest-core 罐子。
2. 点击“ junit.jar”会将您重定向到包含下载链接的页面。 点击最新版本的“ jar”链接（撰写本文时为 v4.12）。 它将自动下载到您的系统。
3. 接下来，点击“ hamcrest-core.jar”。 与上述类似，单击最新的“ jar”下载链接（截至本帖子发布之日起为 v1.3）。
4. 这样，两个必需的 jar 都立即下载到您的系统中。
下图是突出显示步骤的图像，
......@@ -27,26 +27,26 @@
#### 第三步：
下一个工作是在Eclipse IDE中将这两个jar添加到我们的项目中。 该过程与我们在“ [**9b”中遵循的过程非常相似。 设置WebDriver（在Eclipse中）**](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/) ”。 请参考该指南以获取分步说明以及屏幕截图。
下一个工作是在 Eclipse IDE 中将这两个 jar 添加到我们的项目中。 该过程与我们在“ [**9b”中遵循的过程非常相似。 设置 WebDriver（在 Eclipse 中）**](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/) ”。 请参考该指南以获取分步说明以及屏幕截图。
1. 打开Eclipse IDE并导航到相应的工作区。
2. 右键单击设置了Selenium的项目->构建路径->配置构建路径…
1. 打开 Eclipse IDE 并导航到相应的工作区。
2. 右键单击设置了 Selenium 的项目->构建路径->配置构建路径…
3. 确保选择了“库”选项卡。 点击“添加库...”
4. 选择“用户库”->接下来->单击“用户库...”
5. 单击“新建...”，并为库“ JUnit4”命名，然后单击“确定”。
6. 在“用户库”弹出窗口中，确保选择了新创建的Junit4库。 点击“添加外部JAR ...”
7. 导航到本地系统中下载的与junit相关的jar的保存路径。 选择junit和hamcrest-core罐子，然后单击“打开”
6. 在“用户库”弹出窗口中，确保选择了新创建的 Junit4 库。 点击“添加外部 JAR ...”
7. 导航到本地系统中下载的与 junit 相关的 jar 的保存路径。 选择 junit 和 hamcrest-core 罐子，然后单击“打开”
![Junit user library](img/5318192c9c52bb98d287d05ae4b99628.png)
相应地单击OK和Finish按钮，新创建的JUnit4库将添加到项目构建路径，如下所示，
相应地单击 OK 和 Finish 按钮，新创建的 JUnit4 库将添加到项目构建路径，如下所示，
![Junit jars added](img/5fce1a98eaa6e98717f5e7813ae4307d.png)
这样，JUnit 4的环境就设置好了！ 在我们的下一篇文章中，让我们在JUnit框架中编写WebDriver测试并执行它们以查看结果。
这样，JUnit 4 的环境就设置好了！ 在我们的下一篇文章中，让我们在 JUnit 框架中编写 WebDriver 测试并执行它们以查看结果。
在另一个帖子中再见！ 祝你今天愉快！
###### 下一篇文章
##### [9克。 WebDriver –在JUnit4](https://javabeginnerstutorial.com/selenium/9g-webdriver-running-tests-junit4/ "9g. WebDriver – Running WebDriver tests in JUnit4") 中运行WebDriver测试
\ No newline at end of file
##### [9 克。 WebDriver –在 JUnit4](https://javabeginnerstutorial.com/selenium/9g-webdriver-running-tests-junit4/ "9g. WebDriver – Running WebDriver tests in JUnit4") 中运行 WebDriver 测试
\ No newline at end of file
docs/108.md
浏览文件 @ 6bf5daa3
# 9克 WebDriver –在JUnit4中运行WebDriver测试
# 9 克 WebDriver –在 JUnit4 中运行 WebDriver 测试
> 原文： [https://javabeginnerstutorial.com/selenium/9g-webdriver-running-tests-junit4/](https://javabeginnerstutorial.com/selenium/9g-webdriver-running-tests-junit4/)
欢迎来到我们的WebDriver系列中的另一篇有趣的文章！ 今天它会很有趣（可能比吃自己喜欢的巧克力要有趣得多）。
欢迎来到我们的 WebDriver 系列中的另一篇有趣的文章！ 今天它会很有趣（可能比吃自己喜欢的巧克力要有趣得多）。
您准备好将帽子戴上戒指了吗？ 如果是，那就开始吧！
展望未来，我们所有的测试都将使用JUnit框架。 因此，是时候通过右键单击项目（已设置硒和junit）创建新程序包了->新建->程序包。 我已将程序包命名为“ com.blog.junitTests”。
展望未来，我们所有的测试都将使用 JUnit 框架。 因此，是时候通过右键单击项目（已设置硒和 junit）创建新程序包了->新建->程序包。 我已将程序包命名为“ com.blog.junitTests”。
我们的下一步是创建一个类。 右键单击新创建的包-> New-> Class。 给它起一个名字“ FirstJunitTest.java”，然后单击“完成”。 您的IDE现在看起来应该与此类似，
我们的下一步是创建一个类。 右键单击新创建的包-> New-> Class。 给它起一个名字“ FirstJunitTest.java”，然后单击“完成”。 您的 IDE 现在看起来应该与此类似，
![JUnit implementation](img/ac2ffc78ad525227b36a8a3fa84ed450.png)
现在我们已经准备好上课的文件了，让我们采用与“ [**第一个测试脚本–通过启动Firefox**](https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/) ”帖子中相同的方案。
现在我们已经准备好上课的文件了，让我们采用与“ [**第一个测试脚本–通过启动 Firefox**](https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/) ”帖子中相同的方案。
1. 打开Firefox浏览器。
1. 打开 Firefox 浏览器。
2. 导航到“ https://www.google.com/”
3. 将页面标题声明为“ Google”。
4. 根据声明结果在控制台上显示一条消息。
5. 关闭浏览器。
选择相同方案的原因是代码说明保持不变。 无论有没有JUnit框架，这都将帮助您清楚地看到代码中的更改。
选择相同方案的原因是代码说明保持不变。 无论有没有 JUnit 框架，这都将帮助您清楚地看到代码中的更改。
***<u>便笺</u>*** **：** *这不是JUnit教程。 但是，将在需要时提供基本的解释，以使您有一个全面的了解。 有关详细和完整的信息，请参考* [http://junit.org/junit4/](http://junit.org/junit4/) *。*
***<u>便笺</u>*** **：** *这不是 JUnit 教程。 但是，将在需要时提供基本的解释，以使您有一个全面的了解。 有关详细和完整的信息，请参考* [http://junit.org/junit4/](http://junit.org/junit4/) *。*
**代码**如下，
......@@ -77,36 +77,36 @@ public class FirstJunitTest {
}
```
如果将此代码与实施JUnit之前的代码进行比较，将会有明显的变化，
如果将此代码与实施 JUnit 之前的代码进行比较，将会有明显的变化，
1. 注释：@ Before，@ Test和@After
1. 注释：@ Before，@ Test 和@After
2. 方法：setUp（），testPageTitle（），tearDown（）
3. 类开头的私有变量声明
4. 在新创建的方法下，将相同的代码分为几部分
这会使视力模糊吗？ 不要担心！ 让我们立即清除雾气！！
大字警报！ **注释：**这些将特定的含义传达给JUnit。 他们告诉JUnit，应该附加到它的*公共无效*方法，
大字警报！ **注释：**这些将特定的含义传达给 JUnit。 他们告诉 JUnit，应该附加到它的*公共无效*方法，
**@Test** –被当作测试方法运行。
**@Before** –在指定的每种测试方法之前运行。 这用于各种目的。 读取或分配数据，初始化或如果多个测试需要先创建相似的对象才能执行，则最好在之前注释的方法下进行指定。
**@After** –在执行每种测试方法之后运行。 通常，会指定与环境清理相关的命令，例如，关闭打开的资源/数据库连接，删除临时数据，释放内存等。即使@Before或@Test方法引发异常，也可以保证运行带after注释的方法。
**@After** –在执行每种测试方法之后运行。 通常，会指定与环境清理相关的命令，例如，关闭打开的资源/数据库连接，删除临时数据，释放内存等。即使@Before 或@Test 方法引发异常，也可以保证运行带 after 注释的方法。
键入这些注释，在它们下方会出现一条弯曲的线。 悬停时，日食将建议所有可能的快速修复。 单击建议导入 *org.junit* 程序包的第一个修复程序。
![JUnit import packages](img/ce8da4202841e9f631539ef66816bcfb.png)
在这三个注释下的**方法**是*公共*，返回类型为 *void* 。 在 *junit.framework.TestCase* 类下，我们有 **setUp（）**和 **tearDown（）**方法。 最佳实践是重写这些方法，以分别编写初始化代码和清除代码。 这不仅可以防止内存泄漏，还可以使代码更易于阅读。 JUnit首先调用setUp（）方法，然后调用test方法，最后调用tearDown（）方法。 对于附加到@Test的每个测试方法，都会发生这种情况。
在这三个注释下的**方法**是*公共*，返回类型为 *void* 。 在 *junit.framework.TestCase* 类下，我们有 **setUp（）**和 **tearDown（）**方法。 最佳实践是重写这些方法，以分别编写初始化代码和清除代码。 这不仅可以防止内存泄漏，还可以使代码更易于阅读。 JUnit 首先调用 setUp（）方法，然后调用 test 方法，最后调用 tearDown（）方法。 对于附加到@Test 的每个测试方法，都会发生这种情况。
#### 要运行测试，
右键单击类->运行方式-> JUnit测试。
右键单击类->运行方式-> JUnit 测试。
![JUnit4 test execution](img/61ab82ac961722bbfc27358cad1b2faf.png)
将打开一个新的Firefox浏览器窗口，并按照代码执行测试步骤。 结果将在Eclipse IDE的JUnit视图中打开，其中显示**成功**的*绿色*条和**错误**的*红色*条。
将打开一个新的 Firefox 浏览器窗口，并按照代码执行测试步骤。 结果将在 Eclipse IDE 的 JUnit 视图中打开，其中显示**成功**的*绿色*条和**错误**的*红色*条。
![JUnit4 test success](img/d2b038f920d9e74a856f23a7d6a9d228.png)
......@@ -114,10 +114,10 @@ public class FirstJunitTest {
![JUnit4 test error](img/088bcc21e786b7be7f5496d288cdea44.png)
我们到了这篇文章的结尾。 现在轮到您尝试一些实现JUnit框架的方案，并在注释部分大声疾呼，以防您遇到问题或得到澄清。
我们到了这篇文章的结尾。 现在轮到您尝试一些实现 JUnit 框架的方案，并在注释部分大声疾呼，以防您遇到问题或得到澄清。
在另一个帖子中再见！ 祝你今天愉快！
###### 下一篇文章
##### [9小时。 WebDriver –隐式等待](https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/ "9h. WebDriver – Implicit Waits")
\ No newline at end of file
##### [9 小时。 WebDriver –隐式等待](https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/ "9h. WebDriver – Implicit Waits")
\ No newline at end of file
docs/109.md
浏览文件 @ 6bf5daa3
# 9小时 WebDriver –隐式等待
# 9 小时 WebDriver –隐式等待
> 原文： [https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/](https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/)
它说：“时间具有向我们展示真正重要内容的绝妙方式”。 但是，等到一切变为现实，这一点同样重要。 如今，网页大多使用javascript和ajax技术开发。 结果，页面上的不同元素在不同的时间加载。 当我们使用selenium WebDriver自动化我们的手动测试并将其作为测试套件运行时，是时候提防您了，因为您可能会遇到Selenium的怪异行为。
它说：“时间具有向我们展示真正重要内容的绝妙方式”。 但是，等到一切变为现实，这一点同样重要。 如今，网页大多使用 javascript 和 ajax 技术开发。 结果，页面上的不同元素在不同的时间加载。 当我们使用 selenium WebDriver 自动化我们的手动测试并将其作为测试套件运行时，是时候提防您了，因为您可能会遇到 Selenium 的怪异行为。
您的测试用例可以成功运行，并且一次执行一行时可以按预期工作，但是作为套件/批处理运行时，它可能会失败。 挠头以了解其背后的原因？ 让我们潜入更多！
当我们使用 *driver.get（“ url_we_wish_to_access”）*， *driver.navigate（）。to（“ url”）*或单击超链接等时，这些调用将启动页面 在该加载活动完成之前加载并返回。 因此，如果页面的加载线程尚未填充Web元素，而您尝试使用 *driver.findElement（“ locating_strategy”）*找到它，则得到的只是**异常** 即NoSuchElementException，ElementNotVisibleException等。
当我们使用 *driver.get（“ url_we_wish_to_access”）*， *driver.navigate（）。to（“ url”）*或单击超链接等时，这些调用将启动页面 在该加载活动完成之前加载并返回。 因此，如果页面的加载线程尚未填充 Web 元素，而您尝试使用 *driver.findElement（“ locating_strategy”）*找到它，则得到的只是**异常** 即 NoSuchElementException，ElementNotVisibleException 等。
所有这些意味着我们必须找到一种告诉Selenium的方法，我们希望它等待一定的时间，或者直到Web元素变得可访问/可单击/显示为止，然后再引发可怕的异常。 在那里，不要惊慌。 我看到一些汗珠滴到你的额头上！ 那么，如何使这种压力成为我们自己的大力水手菠菜的版本呢？ 感谢 ***隐式，显式和流畅的等待*** 。
所有这些意味着我们必须找到一种告诉 Selenium 的方法，我们希望它等待一定的时间，或者直到 Web 元素变得可访问/可单击/显示为止，然后再引发可怕的异常。 在那里，不要惊慌。 我看到一些汗珠滴到你的额头上！ 那么，如何使这种压力成为我们自己的大力水手菠菜的版本呢？ 感谢 ***隐式，显式和流畅的等待*** 。
是时候去拜访每一个了。
### 隐式等待
了解我们使用findElement或findElements命令在WebDriver中定位Web元素非常重要（后面的文章将详细介绍该主题以及各种定位策略）。 因此，当尝试在页面上查找特定的Web元素时，如果该Web元素不是立即可用的，则隐式等待告诉WebDriver在指定的时间内轮询DOM。 万一在指定的等待时间内找到该元素，测试将继续执行。 如果不是，则抛出NoSuchElementException。
了解我们使用 findElement 或 findElements 命令在 WebDriver 中定位 Web 元素非常重要（后面的文章将详细介绍该主题以及各种定位策略）。 因此，当尝试在页面上查找特定的 Web 元素时，如果该 Web 元素不是立即可用的，则隐式等待告诉 WebDriver 在指定的时间内轮询 DOM。 万一在指定的等待时间内找到该元素，测试将继续执行。 如果不是，则抛出 NoSuchElementException。
下面是带有隐式等待命令的代码片段，以使您更好地理解，
......@@ -41,20 +41,20 @@
driver.manage().timeouts().implicitlyWait(3, TimeUnit.SECONDS);
```
隐式等待有两个参数。 在此示例中，我们的第一个参数为 **3** ，这是它必须等待的时间，第二个参数为 *TimeUnit.SECONDS* 。 这是时间测量。 可以指定为DAYS，HOURS，MINUTES，SECONDS，MILLISECONDS，MICROSECONDS，NANOSECONDS等。
隐式等待有两个参数。 在此示例中，我们的第一个参数为 **3** ，这是它必须等待的时间，第二个参数为 *TimeUnit.SECONDS* 。 这是时间测量。 可以指定为 DAYS，HOURS，MINUTES，SECONDS，MILLISECONDS，MICROSECONDS，NANOSECONDS 等。
此外，在键入此语句时，“ TimeUnit”下方会出现一条弯曲的线。 悬停时，蚀将建议所有可能的快速修复。 单击建议*导入java.util.concurrent.TimeUnit* 包的第一个修复程序。
此外，在键入此语句时，“ TimeUnit”下方会出现一条弯曲的线。 悬停时，蚀将建议所有可能的快速修复。 单击建议*导入 java.util.concurrent.TimeUnit* 包的第一个修复程序。
1. 隐式等待只需要初始化一次。 设置后，它将适用于WebDriver对象实例的寿命。 换句话说，它将在浏览器打开的整个过程中就位。 因此，WebDriver将等待该额外时间，然后对所有 [findElement](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriver.html#findElement(org.openqa.selenium.By)) 和 [findElements](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriver.html#findElements(org.openqa.selenium.By)) 抛出异常
2. 默认时间设置为0。
3. 隐式等待仅影响finddElement（s），它不影响其他WebDriver方法，例如driver.getCurrentUrl（）等。
4. 在大多数情况下，尤其是在调试时，仅“ NoSuchElementException”并不是很有用。 我们可能希望使用更多信息来自定义此错误消息，例如捕获屏幕快照或添加更多详细信息等。可以通过在每次findElement（s）调用周围使用try-catch块来实现此目的，但这不是我们使用隐式等待的目标 因为这是一个全球性的时间设置。
5. 由于有大量的JavaScript，因此可能会出现一些奇怪的情况。 即使该元素位于DOM中，也可能无法立即单击或显示或启用它。 结果我们可能会看到 [*ElementNotVisibleException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/ElementNotVisibleException.html) *，* [*WebDriverException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriverException.html) *，* [[ *StaleElementReferenceException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/StaleElementReferenceException.html)
6. 由于不同的元素可能在不同的时间加载，因此我们可能会说服将等待时间设置为较高的值（或等效于最慢的Web元素的加载时间），例如20秒左右。 我们对此的理由是，“无论如何，所有元素的加载速度都将比此时快，并且测试将按预期进行。” 但是您甚至猜不到**性能**-这种方法不是一个好主意吗？ 我在这里给您举几个例子，以便更好地了解，
1. 隐式等待只需要初始化一次。 设置后，它将适用于 WebDriver 对象实例的寿命。 换句话说，它将在浏览器打开的整个过程中就位。 因此，WebDriver 将等待该额外时间，然后对所有 [findElement](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriver.html#findElement(org.openqa.selenium.By)) 和 [findElements](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriver.html#findElements(org.openqa.selenium.By)) 抛出异常
2. 默认时间设置为 0。
3. 隐式等待仅影响 finddElement（s），它不影响其他 WebDriver 方法，例如 driver.getCurrentUrl（）等。
4. 在大多数情况下，尤其是在调试时，仅“ NoSuchElementException”并不是很有用。 我们可能希望使用更多信息来自定义此错误消息，例如捕获屏幕快照或添加更多详细信息等。可以通过在每次 findElement（s）调用周围使用 try-catch 块来实现此目的，但这不是我们使用隐式等待的目标 因为这是一个全球性的时间设置。
5. 由于有大量的 JavaScript，因此可能会出现一些奇怪的情况。 即使该元素位于 DOM 中，也可能无法立即单击或显示或启用它。 结果我们可能会看到 [*ElementNotVisibleException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/ElementNotVisibleException.html) *，* [*WebDriverException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriverException.html) *，* [[ *StaleElementReferenceException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/StaleElementReferenceException.html)
6. 由于不同的元素可能在不同的时间加载，因此我们可能会说服将等待时间设置为较高的值（或等效于最慢的 Web 元素的加载时间），例如 20 秒左右。 我们对此的理由是，“无论如何，所有元素的加载速度都将比此时快，并且测试将按预期进行。” 但是您甚至猜不到**性能**-这种方法不是一个好主意吗？ 我在这里给您举几个例子，以便更好地了解，
**情况1：**如果希望找到一个元素，但无论结果如何，都可以继续进行测试。
**情况 1：**如果希望找到一个元素，但无论结果如何，都可以继续进行测试。
**情况2：**如果仅需要验证是否缺少某个元素，例如等待警报框出现并关闭它。 即使这样，WebDriver也将不得不等到超时，即在这种情况下为20秒。 在庞大的测试套件中运行时，这将产生巨大的影响。
**情况 2：**如果仅需要验证是否缺少某个元素，例如等待警报框出现并关闭它。 即使这样，WebDriver 也将不得不等到超时，即在这种情况下为 20 秒。 在庞大的测试套件中运行时，这将产生巨大的影响。
为了克服隐式等待的一些缺点，我们有明确的等待来救援！ 但是考虑到我们的大脑一次只能占用那么多的空间，我将在下一篇文章中保留这个主题。
......
docs/11.md
浏览文件 @ 6bf5daa3
......@@ -2,9 +2,9 @@
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/order-of-execution-of-blocks-in-java/](https://javabeginnerstutorial.com/core-java-tutorial/order-of-execution-of-blocks-in-java/)
在本文中，我们将学习Java中块执行的顺序。
在本文中，我们将学习 Java 中块执行的顺序。
Java类中的不同块及其执行顺序
Java 类中的不同块及其执行顺序
1. 静态块
2. 初始化块（匿名块）
......@@ -64,10 +64,10 @@ Inside Ananymous Block
Inside COnstructor of Class
```
如您所见，STATIC块仅在加载类时执行一次。
如您所见，STATIC 块仅在加载类时执行一次。
但是，每当创建一个类的对象时，Anonymous block和Constructor就会运行。 初始化块将首先执行，然后构造函数。
但是，每当创建一个类的对象时，Anonymous block 和 Constructor 就会运行。 初始化块将首先执行，然后构造函数。
###### 下一篇文章
##### Java中的[访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/access-modifier-in-java/ "Access Modifiers in Java")
\ No newline at end of file
##### Java 中的[访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/access-modifier-in-java/ "Access Modifiers in Java")
\ No newline at end of file
docs/110.md
浏览文件 @ 6bf5daa3
......@@ -2,7 +2,7 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9i-webdriver-explicit-waits/](https://javabeginnerstutorial.com/selenium/9i-webdriver-explicit-waits/)
大家好！ 这篇文章是先前文章 [**9h的延续。 WebDriver –隐式等待**](https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/) 。
大家好！ 这篇文章是先前文章 [**9h 的延续。 WebDriver –隐式等待**](https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/) 。
事不宜迟，让我们利用“显式等待”的力量。 显式等待需要更多的编码，但是与隐式等待相比，它具有巨大的优势。 在这里，我们可以等到某种情况发生后再进行测试。 如果在指定的超时值内未满足条件，则将引发异常。
......@@ -13,25 +13,25 @@ WebDriverWait wait = new WebDriverWait(driver, 15);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("element_id")));
```
因此，WebDriverWait类用于指定最大超时值，在这种情况下为15秒。 ExpectedCondition类的方法涵盖了我们希望在测试中出现之前要等待的大多数条件。 这些条件与WebDriverWait一起使用。
因此，WebDriverWait 类用于指定最大超时值，在这种情况下为 15 秒。 ExpectedCondition 类的方法涵盖了我们希望在测试中出现之前要等待的大多数条件。 这些条件与 WebDriverWait 一起使用。
上面的代码一直等到元素变为可点击（即显示并启用）并返回结果。 默认情况下，WebDriverWait每500毫秒调用ExpectedCondition，直到成功返回。 在这种情况下，它会在抛出TimeoutException之前尝试长达15秒。 成功的返回值是布尔值true或非null对象。
上面的代码一直等到元素变为可点击（即显示并启用）并返回结果。 默认情况下，WebDriverWait 每 500 毫秒调用 ExpectedCondition，直到成功返回。 在这种情况下，它会在抛出 TimeoutException 之前尝试长达 15 秒。 成功的返回值是布尔值 true 或非 null 对象。
ExpectedCondition预定义方法的一些示例是，
ExpectedCondition 预定义方法的一些示例是，
* [*elementToBeClickable*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#elementToBeClickable-org.openqa.selenium.By-) （ [](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/By.html) 定位符提供的 [*）–用于检查元素的期望是可见的并已启用，以便您可以单击它。*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/By.html)
* [*elementToBeSelected*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#elementToBeSelected-org.openqa.selenium.WebElement-) *（* [*WebElement*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/WebElement.html) 元素）-检查是否选择了给定元素。
* [*presentOfElementLocated*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#presenceOfElementLocated-org.openqa.selenium.By-) *（* 定位符提供的 [*）–期望检查元素的DOM上是否存在元素 页。*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/By.html)
* [*urlToBe*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#urlToBe-java.lang.String-) *（java.lang.String* url）–当前页面的URL是一个特定的URL。
* [*可见性*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#visibilityOf-org.openqa.selenium.WebElement-) *（* [*WebElement*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/WebElement.html) 元素）-用于检查已知存在于元素上的元素的期望 页面的DOM是可见的。
* [*presentOfElementLocated*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#presenceOfElementLocated-org.openqa.selenium.By-) *（* 定位符提供的 [*）–期望检查元素的 DOM 上是否存在元素 页。*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/By.html)
* [*urlToBe*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#urlToBe-java.lang.String-) *（java.lang.String* url）–当前页面的 URL 是一个特定的 URL。
* [*可见性*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#visibilityOf-org.openqa.selenium.WebElement-) *（* [*WebElement*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/WebElement.html) 元素）-用于检查已知存在于元素上的元素的期望 页面的 DOM 是可见的。
您可以在此处找到[，找到适用于Java的ExpectedConditions包的所有可用方法及其用法的详细信息。](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html)
您可以在此处找到[，找到适用于 Java 的 ExpectedConditions 包的所有可用方法及其用法的详细信息。](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html)
***<u>便签</u>*** ***：*** *根据 [Selenium的官方文档](http://docs.seleniumhq.org/docs/04_webdriver_advanced.jsp#explicit-and-implicit-waits)* *，我们警告您不要混合使用隐式和显式等待，因为这可能会导致不可预测的等待时间。*
***<u>便签</u>*** ***：*** *根据 [Selenium 的官方文档](http://docs.seleniumhq.org/docs/04_webdriver_advanced.jsp#explicit-and-implicit-waits)* *，我们警告您不要混合使用隐式和显式等待，因为这可能会导致不可预测的等待时间。*
### 流利的等待
谁不喜欢自定义？ 对于显式等待，如果这是您要搜索的内容，那么我建议您使用Fluent Wait。 我们可以通过流畅的等待来配置以下内容，
谁不喜欢自定义？ 对于显式等待，如果这是您要搜索的内容，那么我建议您使用 Fluent Wait。 我们可以通过流畅的等待来配置以下内容，
* 在抛出异常之前我们希望等待（超时）条件发生的最长时间，
* 检查指定条件的频率，以及
......@@ -53,19 +53,19 @@ public WebElement fluentWait(final By locator) {
}
```
在这里，我们声明超时值为20秒的流畅等待，每2秒（频率）轮询DOM直到找到元素为止，并在此时间间隔内忽略NoSuchElementException。 我们在上面的代码片段中创建了一个新函数，以在.until（）;中标识此Web元素。
在这里，我们声明超时值为 20 秒的流畅等待，每 2 秒（频率）轮询 DOM 直到找到元素为止，并在此时间间隔内忽略 NoSuchElementException。 我们在上面的代码片段中创建了一个新函数，以在.until（）;中标识此 Web 元素。
#### 有几点值得您花时间，
1. 与隐式等待不同，此方法适用于findElement（s）以及您可能会想到的在自动化网页时进行枚举的任何其他条件。
2. 可以自定义默认超时值和频率，并且仅将其应用于特定元素，这与隐式等待不同，隐式等待在启动后就适用于WebDriver对象实例的寿命。
3. 我们可以实现自己的条件，也可以使用ExpectedConditions类中的预定义条件之一。
4. 使用FluentWait，我们可以忽略某些异常并改为指定自定义错误消息。 这将我们的调试经验提升到一个全新的水平。
1. 与隐式等待不同，此方法适用于 findElement（s）以及您可能会想到的在自动化网页时进行枚举的任何其他条件。
2. 可以自定义默认超时值和频率，并且仅将其应用于特定元素，这与隐式等待不同，隐式等待在启动后就适用于 WebDriver 对象实例的寿命。
3. 我们可以实现自己的条件，也可以使用 ExpectedConditions 类中的预定义条件之一。
4. 使用 FluentWait，我们可以忽略某些异常并改为指定自定义错误消息。 这将我们的调试经验提升到一个全新的水平。
5. 通过忽略特定的异常直到满足我们的条件，流利的等待比隐式等待更可靠。
同意的显式等待包括对代码的更多修饰，但是您认为值得这样做吗？
***<u>便签</u>*** **：** *您可能会想，为什么要经历所有这些痛苦？ 我不能只使用Thread.sleep（）吗？ 嗯，不 不建议这样做，因为它会使整个测试脚本无条件进入休眠状态。 在大多数情况下，指定的睡眠时间不够长（导致异常），或者变得太长，导致即使元素加载速度更快，测试也要等待。*
***<u>便签</u>*** **：** *您可能会想，为什么要经历所有这些痛苦？ 我不能只使用 Thread.sleep（）吗？ 嗯，不 不建议这样做，因为它会使整个测试脚本无条件进入休眠状态。 在大多数情况下，指定的睡眠时间不够长（导致异常），或者变得太长，导致即使元素加载速度更快，测试也要等待。*
**令我全神贯注：**虽然显式等待涉及更多的编程部分，但由于它能够解决很多问题，使我们的生活变得更加轻松，我宁愿选择此方法，而不是隐式等待（基于 测试自动化的需求和复杂性涉及*眨眼*）。
......@@ -75,4 +75,4 @@ public WebElement fluentWait(final By locator) {
###### 下一篇文章
##### [9j。 WebDriver –定位元素：第1部分（按ID，名称，标记名）](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/ "9j. WebDriver – Locating elements: Part 1 (by id, name, tagName)")
\ No newline at end of file
##### [9j。 WebDriver –定位元素：第 1 部分（按 ID，名称，标记名）](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/ "9j. WebDriver – Locating elements: Part 1 (by id, name, tagName)")
\ No newline at end of file
docs/111.md
浏览文件 @ 6bf5daa3
# 9j。 WebDriver –定位元素：第1部分（按id，名称，tagName）
# 9j。 WebDriver –定位元素：第 1 部分（按 id，名称，tagName）
> 原文： [https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)
朋友！ 如果您进入了硒世界，那么您一定已经遇到了Web Elements！ 文本框，按钮，链接，复选框，单选按钮，下拉菜单，警报等，所有内容均视为网络元素。 使用定位器类型和策略，我们可以轻松识别页面上任何所需的元素。 这是与页面进行交互并在代码中进一步引用这些元素的最关键步骤。 是的，它与我们在Selenium IDE 中看到的[非常相似，除了语法和概念的应用方式。](https://javabeginnerstutorial.com/selenium/7k-ide-locating-elements/)
朋友！ 如果您进入了硒世界，那么您一定已经遇到了 Web Elements！ 文本框，按钮，链接，复选框，单选按钮，下拉菜单，警报等，所有内容均视为网络元素。 使用定位器类型和策略，我们可以轻松识别页面上任何所需的元素。 这是与页面进行交互并在代码中进一步引用这些元素的最关键步骤。 是的，它与我们在 Selenium IDE 中看到的[非常相似，除了语法和概念的应用方式。](https://javabeginnerstutorial.com/selenium/7k-ide-locating-elements/)
使用Selenium webDriver定位Web元素的一般语法是：
使用 Selenium webDriver 定位 Web 元素的一般语法是：
```java
driver.findElement(By.LocatorStrategyType ("Locator_Value"));
......@@ -12,12 +12,12 @@ driver.findElement(By.LocatorStrategyType ("Locator_Value"));
**说明：**
* *驱动程序* –实现WebDriver接口的相应驱动程序类的实例变量
* *findElement（）* –查找并返回具有指定位置策略的第一个Web元素
* *findElements（）* –查找并返回与给定位置策略匹配的Web元素列表
* *驱动程序* –实现 WebDriver 接口的相应驱动程序类的实例变量
* *findElement（）* –查找并返回具有指定位置策略的第一个 Web 元素
* *findElements（）* –查找并返回与给定位置策略匹配的 Web 元素列表
* *按* –始终使用按类别定位目标
* *LocatorStrategyType* – ID，名称，标记名，类名，cssSelector，linkText，partialLinkText，xpath是可用于在页面上定位元素的某些定位器类型
* *Locator_Value* –可以标识元素的value / HTML标记
* *LocatorStrategyType* – ID，名称，标记名，类名，cssSelector，linkText，partialLinkText，xpath 是可用于在页面上定位元素的某些定位器类型
* *Locator_Value* –可以标识元素的 value / HTML 标记
#### 可用的定位器类型包括：
......@@ -30,26 +30,26 @@ driver.findElement(By.LocatorStrategyType ("Locator_Value"));
* cssSelector
* 路径
可以随时通过编程方式掌握页面上所需的元素，但要实现此目的，我们的创作方可能不得不偷看一下。 原因是，我们并不总是可以控制页面上的HTML。 这就是为什么我们有这么多的定位器类型，而且绝对没有理由惊慌！
可以随时通过编程方式掌握页面上所需的元素，但要实现此目的，我们的创作方可能不得不偷看一下。 原因是，我们并不总是可以控制页面上的 HTML。 这就是为什么我们有这么多的定位器类型，而且绝对没有理由惊慌！
让我们继续，并通过代码示例详细了解每种定位器类型。
## *<u>通过ID</u>* 定位
## *<u>通过 ID</u>* 定位
id是在页面上定位元素的最有用和首选的方式，因为它是唯一的。 但是，当心！ 一些开发人员要么自动生成这些ID，要么完全忘记添加一个。 那就是我们去寻找其他定位器类型的时候。
id 是在页面上定位元素的最有用和首选的方式，因为它是唯一的。 但是，当心！ 一些开发人员要么自动生成这些 ID，要么完全忘记添加一个。 那就是我们去寻找其他定位器类型的时候。
***语法**：* *driver.findElement（By.id（“ element_id”））;*
***说明**：*找到具有匹配id属性的第一个元素。
***说明**：*找到具有匹配 id 属性的第一个元素。
***示例**：*打开Goog​​le帐户创建页面。 让我们通过ID识别名字文本框。
***示例**：*打开 Goog​​le 帐户创建页面。 让我们通过 ID 识别名字文本框。
* Google Chrome –右键单击要确定其ID的网络元素，然后选择“检查”。 或通过单击F12打开开发人员工具，单击左上角的检查元素图标，然后在页面上单击所需的Web元素。 两种方法都将突出显示与所选元素相对应的HTML代码。
* Mozilla Firefox –右键单击Web元素，然后选择“使用Firebug检查元素”（以防您错过了 [<u>Firebug安装和使用</u>](https://javabeginnerstutorial.com/selenium/7n-ide-using-firebug/) 上的帖子）。 或者，如果您确实不想使用Firebug，则右键单击该元素并选择“检查元素”。 在两种情况下，都将打开并突出显示相应的HTML代码。
* Google Chrome –右键单击要确定其 ID 的网络元素，然后选择“检查”。 或通过单击 F12 打开开发人员工具，单击左上角的检查元素图标，然后在页面上单击所需的 Web 元素。 两种方法都将突出显示与所选元素相对应的 HTML 代码。
* Mozilla Firefox –右键单击 Web 元素，然后选择“使用 Firebug 检查元素”（以防您错过了 [<u>Firebug 安装和使用</u>](https://javabeginnerstutorial.com/selenium/7n-ide-using-firebug/) 上的帖子）。 或者，如果您确实不想使用 Firebug，则右键单击该元素并选择“检查元素”。 在两种情况下，都将打开并突出显示相应的 HTML 代码。
![Locating by Id](img/c073039501d98689d51ef3a4addb1095.png)
如上面的屏幕截图所示，“名字”文本框的ID为“名字”。 因此，此处使用的代码是
如上面的屏幕截图所示，“名字”文本框的 ID 为“名字”。 因此，此处使用的代码是
```java
driver.findElement(By.id("FirstName"));
......@@ -57,7 +57,7 @@ driver.findElement(By.id("FirstName"));
## *<u>按名称定位</u>*
Name属性也可用于在页面上定位元素。
Name 属性也可用于在页面上定位元素。
***语法**：* *driver.findElement（By.name（“ element_name”））;*
......@@ -65,7 +65,7 @@ Name属性也可用于在页面上定位元素。
***示例**：*让我们按名称标识姓氏文本框。
右键单击姓氏文本框，然后单击检查元素以获取相应的HTML代码。 在我们的案例中，name属性的值为LastName。 因此，按名称定位此网络元素的代码将是，
右键单击姓氏文本框，然后单击检查元素以获取相应的 HTML 代码。 在我们的案例中，name 属性的值为 LastName。 因此，按名称定位此网络元素的代码将是，
```java
driver.findElement(By.name("LastName"));
......@@ -75,15 +75,15 @@ driver.findElement(By.name("LastName"));
## *<u>通过标记名</u>* 定位
在这里，我们使用标记的实际名称，例如<，>作为锚，<表>作为表。 当我们想要获得具有给定标签名称的所有元素时，这很有用。 如果被测页面只有一个标签，则findElement将起作用。 但否则，建议对结果建立索引以找到我们希望使用的特定元素。
在这里，我们使用标记的实际名称，例如<，>作为锚，<表>作为表。 当我们想要获得具有给定标签名称的所有元素时，这很有用。 如果被测页面只有一个标签，则 findElement 将起作用。 但否则，建议对结果建立索引以找到我们希望使用的特定元素。
***语法**：* *driver.findElements（By.tagName（“ element_html_tag”））;;*
***说明**：*找到具有匹配标签名称的所有元素。
***示例**：*让我们找到Gmail帐户创建页面右上角的“登录”按钮。
***示例**：*让我们找到 Gmail 帐户创建页面右上角的“登录”按钮。
右键单击按钮，然后单击检查元素以获取相应的HTML代码。 我们可以看到它具有锚标记。 让我们继续并在列表中获取所有具有tagName“ a”的网络元素，然后通过其索引找到第一个元素，以便与“登录”按钮进行交互。
右键单击按钮，然后单击检查元素以获取相应的 HTML 代码。 我们可以看到它具有锚标记。 让我们继续并在列表中获取所有具有 tagName“ a”的网络元素，然后通过其索引找到第一个元素，以便与“登录”按钮进行交互。
```java
// List of all elements with anchor tag
......@@ -98,16 +98,16 @@ WebElement signInButton = buttons.get(0);
#### *场景*
1. 打开Firefox浏览器。
2. 导航到Google帐户创建页面
3. 通过ID找到名字文本框
1. 打开 Firefox 浏览器。
2. 导航到 Google 帐户创建页面
3. 通过 ID 找到名字文本框
4. 输入“ fname01”作为名字
5. 按名称找到姓氏文本框
6. 输入“ lname01”作为姓氏
7. 使用tagName找到“登录”按钮
7. 使用 tagName 找到“登录”按钮
8. 将按钮文字打印到控制台进行验证
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
import java.util.List;
......@@ -177,15 +177,15 @@ System.out.println("First button text: " + signInButton.getText());
将导入两个新的软件包，
**导入** org.openqa.selenium.WebElement –实例化一个新的Web元素。
**导入** org.openqa.selenium.WebElement –实例化一个新的 Web 元素。
**导入** org.openqa.selenium.By; –该包引用了被称为定位器类型的By类。
**导入** org.openqa.selenium.By; –该包引用了被称为定位器类型的 By 类。
注释清楚地提供给每一行代码，因此很容易解释。
![Output1](img/125542272ed942fe903e270ac7bb44bb.png)
执行测试用例后，成功显示为绿色，并且输出显示在控制台上，确认“登录”按钮与tagName一起位于。 图像的右半部分显示了在Firefox浏览器中执行的自动输出。 名字和姓氏文本框将填充代码中给出的值。
执行测试用例后，成功显示为绿色，并且输出显示在控制台上，确认“登录”按钮与 tagName 一起位于。 图像的右半部分显示了在 Firefox 浏览器中执行的自动输出。 名字和姓氏文本框将填充代码中给出的值。
让我们在这里休息一下。 在下面的文章中，我们将通过示例看到另外三种查找元素的方法。 蒙克就这些想法直到那时！
......@@ -193,4 +193,4 @@ System.out.println("First button text: " + signInButton.getText());
###### 下一篇文章
##### [9k。 WebDriver –定位元素：第2部分（按className，linkText，partialLinkText）](https://javabeginnerstutorial.com/selenium/9k-webdriver-locating-elements-2/ "9k. WebDriver – Locating elements: Part 2 (by className, linkText, partialLinkText)")
\ No newline at end of file
##### [9k。 WebDriver –定位元素：第 2 部分（按 className，linkText，partialLinkText）](https://javabeginnerstutorial.com/selenium/9k-webdriver-locating-elements-2/ "9k. WebDriver – Locating elements: Part 2 (by className, linkText, partialLinkText)")
\ No newline at end of file
docs/112.md
浏览文件 @ 6bf5daa3
# 9k。 WebDriver –定位元素：第2部分（按className，linkText，partialLinkText）
# 9k。 WebDriver –定位元素：第 2 部分（按 className，linkText，partialLinkText）
> 原文： [https://javabeginnerstutorial.com/selenium/9k-webdriver-locating-elements-2/](https://javabeginnerstutorial.com/selenium/9k-webdriver-locating-elements-2/)
......@@ -10,15 +10,15 @@
### *<u>按类别名称定位</u>*
类名称不过是用于设置Web元素样式的CSS类名称。 重要的是要注意页面上的许多Web元素可能具有相同的className。 在这种情况下，可以使用findElements方法，并且可以为结果建立索引。 请参考通过tagName策略定位（解释以及[先前文章](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)中提供的示例）。 如果我们有一个具有唯一className的元素，或者被测元素是该页面中使用该className的第一个元素，则findElement将执行此任务。
类名称不过是用于设置 Web 元素样式的 CSS 类名称。 重要的是要注意页面上的许多 Web 元素可能具有相同的 className。 在这种情况下，可以使用 findElements 方法，并且可以为结果建立索引。 请参考通过 tagName 策略定位（解释以及[先前文章](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)中提供的示例）。 如果我们有一个具有唯一 className 的元素，或者被测元素是该页面中使用该 className 的第一个元素，则 findElement 将执行此任务。
***语法：*** *driver.findElement（By.className（“ element_class_name”））;*
***说明：*** 找到具有匹配CSS类名称的第一个元素。
***说明：*** 找到具有匹配 CSS 类名称的第一个元素。
***示例：*** 让我们找到gmail帐户创建页面的“手机”文本框。
***示例：*** 让我们找到 gmail 帐户创建页面的“手机”文本框。
右键单击文本框，然后选择检查元素以获取相应的HTML代码。 我们可以看到“ input”标签包含 *class =“ i18n_phone_number_input-inner_input”* 。 让我们继续使用此类名称查找“手机”文本框，以进行进一步的交互。
右键单击文本框，然后选择检查元素以获取相应的 HTML 代码。 我们可以看到“ input”标签包含 *class =“ i18n_phone_number_input-inner_input”* 。 让我们继续使用此类名称查找“手机”文本框，以进行进一步的交互。
*代码：*
......@@ -28,15 +28,15 @@ driver.findElement(By.className("i18n_phone_number_input-inner_input"));
![Locating by ClassName](img/35fbb3061abb7c05aa82266e0c5f1ebf.png)
### *<u>通过linkText</u>* 定位
### *<u>通过 linkText</u>* 定位
当您想与超链接进行交互时，linkText非常有用。 使用该链接在网页上显示的实际文本。 那有多容易？
当您想与超链接进行交互时，linkText 非常有用。 使用该链接在网页上显示的实际文本。 那有多容易？
***语法：*** *driver.findElement（By.linkText（“ hyperlink_text”））;*
***说明：*** 找到具有匹配链接文本的第一个超链接。
***示例：*** 让我们找到在gmail帐户创建页面底部提供的超链接“了解更多信息”。
***示例：*** 让我们找到在 gmail 帐户创建页面底部提供的超链接“了解更多信息”。
*Code:*
......@@ -46,15 +46,15 @@ driver.findElement(By.linkText("Learn more"));
![Locating by LinkText](img/1a2edf43e534f498a4f3275dd5f6e4f3.png)
### *<u>通过partialLinkText</u>* 定位
### *<u>通过 partialLinkText</u>* 定位
PartialLinkText也用于与超链接进行交互，与linkText定位策略非常相似。 此方法不提供部分完整链接，而是提供链接显示的完整文本。 因此，可以将链接文本的一部分作为匹配条件。
PartialLinkText 也用于与超链接进行交互，与 linkText 定位策略非常相似。 此方法不提供部分完整链接，而是提供链接显示的完整文本。 因此，可以将链接文本的一部分作为匹配条件。
***语法：*** *driver.findElement（By.partialLinkText（“ hyperlink_partial_text”）））;*
***说明：*** 找到第一个超链接，其中**包含**指定的部分链接文本。
***示例：*** 让我们在Gmail帐户创建页面的“选择用户名”文本框下方找到超链接“我更喜欢使用我当前的电子邮件地址” -text，**'我更喜欢'**。
***示例：*** 让我们在 Gmail 帐户创建页面的“选择用户名”文本框下方找到超链接“我更喜欢使用我当前的电子邮件地址” -text，**'我更喜欢'**。
*Code:*
......@@ -70,16 +70,16 @@ driver.findElement(By.partialLinkText("I prefer to"));
#### *场景*
1. 打开Firefox浏览器。
2. 导航到Google帐户创建页面
3. 通过className找到手机文本框
1. 打开 Firefox 浏览器。
2. 导航到 Google 帐户创建页面
3. 通过 className 找到手机文本框
4. 输入“ 9496543210”作为手机号码
5. 通过linkText找到“了解详情”超链接
5. 通过 linkText 找到“了解详情”超链接
6. 链接超链接
7. 找到“我更喜欢使用当前的电子邮件地址”超链接和partialLinkText
7. 找到“我更喜欢使用当前的电子邮件地址”超链接和 partialLinkText
8. 将完整的链接文本打印到控制台进行验证
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
import java.util.concurrent.TimeUnit;
......@@ -145,11 +145,11 @@ public class ElementLocatorTest2 {
![Console output](img/ba6b69d34397c93cbfa5d3246cc4c6bb.png)
在JUnit窗格中，绿色条显示测试用例已成功执行。 输出将打印到控制台，以确认仅提供子文本“我更喜欢”作为partialLinkText，即可访问“我更喜欢使用当前的电子邮件地址”超链接。
在 JUnit 窗格中，绿色条显示测试用例已成功执行。 输出将打印到控制台，以确认仅提供子文本“我更喜欢”作为 partialLinkText，即可访问“我更喜欢使用当前的电子邮件地址”超链接。
![Output](img/ec0d674929c66c5314ee6de72154ea7c.png)
该图像的左半部分显示输入的电话号码，右半部分显示在Firefox浏览器中执行的最终输出。 点击“了解详情”链接后，我们将重定向到相应的页面。
该图像的左半部分显示输入的电话号码，右半部分显示在 Firefox 浏览器中执行的最终输出。 点击“了解详情”链接后，我们将重定向到相应的页面。
是时候再休息一次了。 在接下来的文章中，准备好消化更多的信息，因为我们将研究两种有效的元素定位技术。
......@@ -157,4 +157,4 @@ public class ElementLocatorTest2 {
###### 下一篇文章
##### [9l。 WebDriver –定位元素：第3a部分（由cssSelector提供）](https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/ "9l. WebDriver – Locating elements: Part 3a (by cssSelector)")
\ No newline at end of file
##### [9l。 WebDriver –定位元素：第 3a 部分（由 cssSelector 提供）](https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/ "9l. WebDriver – Locating elements: Part 3a (by cssSelector)")
\ No newline at end of file
docs/113.md
浏览文件 @ 6bf5daa3
# 9升 WebDriver –定位元素：第3a部分（由cssSelector提供）
# 9 升 WebDriver –定位元素：第 3a 部分（由 cssSelector 提供）
> 原文： [https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/](https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/)
Hiya测试人员！ 让我们直接进入cssSelector定位策略。
Hiya 测试人员！ 让我们直接进入 cssSelector 定位策略。
如果我们没有选择使用ID，类或名称来查找元素的方法，该怎么办？ 袖子上有东西吗？ 好吧，我有一个 **cssSelectors** 。 这是一种先进而有效的策略。
如果我们没有选择使用 ID，类或名称来查找元素的方法，该怎么办？ 袖子上有东西吗？ 好吧，我有一个 **cssSelectors** 。 这是一种先进而有效的策略。
##### *<u>准备点亮</u>*
* **CSS** （级联样式表）。 根据Wikipedia的说法，“ CSS是一种样式表语言，用于描述以标记语言编写的文档的表示形式”。 它通过添加样式来更改HTML元素的外观，并定义应如何在网页上显示它们。
* **选择器**是使用HTML标记，属性及其值构造的模式。 然后将它们用于匹配所需的Web元素。
* **CSS** （级联样式表）。 根据 Wikipedia 的说法，“ CSS 是一种样式表语言，用于描述以标记语言编写的文档的表示形式”。 它通过添加样式来更改 HTML 元素的外观，并定义应如何在网页上显示它们。
* **选择器**是使用 HTML 标记，属性及其值构造的模式。 然后将它们用于匹配所需的 Web 元素。
##### *<u>使用cssSelector定位器优于XPath定位器的优点</u>*
##### *<u>使用 cssSelector 定位器优于 XPath 定位器的优点</u>*
* 速度更快，尤其是在Internet Explorer中
* 速度更快，尤其是在 Internet Explorer 中
* 更简单
* 更具可读性
* 首选使用方式
## *<u>通过cssSelector定位</u>*
## *<u>通过 cssSelector 定位</u>*
有多种使用cssSelector定位器的方式，这取决于可用的标签，属性，关键字等。要列出它们，
有多种使用 cssSelector 定位器的方式，这取决于可用的标签，属性，关键字等。要列出它们，
1. 使用标签和ID属性
1. 使用标签和 ID 属性
2. 使用标签和类属性
3. 使用标签和名称属性
4. 使用标签和多个属性
......@@ -31,9 +31,9 @@ Hiya测试人员！ 让我们直接进入cssSelector定位策略。
在这篇文章中，我们将介绍前四种方法。 是时候一步一步地完成这些工作了。
## 1.使用标签和ID属性
## 1.使用标签和 ID 属性
借助cssSelector定位策略，可以使用元素的HTML标记及其ID属性及其值来对其进行访问。
借助 cssSelector 定位策略，可以使用元素的 HTML 标记及其 ID 属性及其值来对其进行访问。
有两种方法可以实现此目的：
......@@ -41,11 +41,11 @@ Hiya测试人员！ 让我们直接进入cssSelector定位策略。
或
*driver.findElement（By.cssSelector（“ tag_name [id ='value_of_id']”）））;;*
***说明*** *：*使用匹配的CSS选择器定位元素。 在第一种方法中，**＃**符号代表“ id”属性。
***说明*** *：*使用匹配的 CSS 选择器定位元素。 在第一种方法中，**＃**符号代表“ id”属性。
***示例*** *：*让我们在Gmail帐户登录页面上找到“电子邮件”文本框。
***示例*** *：*让我们在 Gmail 帐户登录页面上找到“电子邮件”文本框。
右键单击“输入电子邮件”文本框，然后选择检查元素以获取相应的HTML代码。 我们可以看到“输入”标签的“ id”属性为“电子邮件”。
右键单击“输入电子邮件”文本框，然后选择检查元素以获取相应的 HTML 代码。 我们可以看到“输入”标签的“ id”属性为“电子邮件”。
*代码：*
......@@ -63,17 +63,17 @@ driver.findElement(By.cssSelector("input[id='Email']"));
## 2.使用标签和类属性
元素的HTML标签及其类属性及其值可用于访问它。 也有两种方法可以实现此目的，
元素的 HTML 标签及其类属性及其值可用于访问它。 也有两种方法可以实现此目的，
***语法**：driver.findElement（By.cssSelector（“ tag_name.value_of_class”）））;*
或
*driver.findElement（By.cssSelector（“ tag_name [class ='value_of_class']”）））;;*
***说明*** *：*使用匹配的CSS选择器定位元素。 在第一种方法中，“。”符号代表“类别”属性。
***说明*** *：*使用匹配的 CSS 选择器定位元素。 在第一种方法中，“。”符号代表“类别”属性。
***示例*** *：*让我们在使用类属性的Gmail帐户“注册”页面上找到“手机”文本框。
***示例*** *：*让我们在使用类属性的 Gmail 帐户“注册”页面上找到“手机”文本框。
右键点击“手机”文本框，然后选择检查元素，以获取相应的HTML代码，如下所示，
右键点击“手机”文本框，然后选择检查元素，以获取相应的 HTML 代码，如下所示，
```java
<input   tabindex="0" name="RecoveryPhoneNumber"
......@@ -97,15 +97,15 @@ driver.findElement(By.cssSelector("input[class='i18n_phone_number_input-inner_in
## 3.使用标签和名称属性
元素的HTML标记及其名称属性及其值可用于访问它。
元素的 HTML 标记及其名称属性及其值可用于访问它。
***语法*** *：* *driver.findElement（By.cssSelector（“ tag_name [name =’value_of_name’]”）））;*
***说明*** *：*使用匹配的CSS选择器定位元素。
***说明*** *：*使用匹配的 CSS 选择器定位元素。
***示例*** *：*让我们在Gmail帐户注册页面上找到名字文本框。
***示例*** *：*让我们在 Gmail 帐户注册页面上找到名字文本框。
右键点击“名字”文本框，然后选择检查元素，以获取相应的HTML代码，如下所示，
右键点击“名字”文本框，然后选择检查元素，以获取相应的 HTML 代码，如下所示，
```java
<input value="" name="FirstName"
......@@ -123,15 +123,15 @@ driver.findElement(By.cssSelector("input[name='FirstName']"));
## 4.使用标签和多个属性
元素的HTML标签和一个以上的属性及其值可用于访问它。
元素的 HTML 标签和一个以上的属性及其值可用于访问它。
***语法*** *：* *driver.findElement（By.cssSelector（“ tag_name [attribute1 ='value_of_attribute1'] [attribute2 ='value_of_attribute2']”））） ;*
***说明*** *：*使用匹配的CSS选择器定位元素。 以这种方式可以提到许多属性。
***说明*** *：*使用匹配的 CSS 选择器定位元素。 以这种方式可以提到许多属性。
***示例*** *：*让我们使用ID，类型和名称属性在Gmail帐户注册页面上找到“创建密码”文本框。
***示例*** *：*让我们使用 ID，类型和名称属性在 Gmail 帐户注册页面上找到“创建密码”文本框。
右键点击“创建密码”文本框，然后选择检查元素以获取相应的HTML代码，如下所示，
右键点击“创建密码”文本框，然后选择检查元素以获取相应的 HTML 代码，如下所示，
```java
<input name="Passwd" id="Passwd" type="password">
......@@ -151,7 +151,7 @@ driver.findElement(By.cssSelector("input#Passwd[name='Passwd']"));
driver.findElement(By.cssSelector("input[type='Password'][name='Passwd'"));
```
如果使用id，则可以用“＃”符号表示，而可以用“。”符号表示类。
如果使用 id，则可以用“＃”符号表示，而可以用“。”符号表示类。
*感觉都糟透了吗？* *需要一些时间练习吗？*
......@@ -161,4 +161,4 @@ driver.findElement(By.cssSelector("input[type='Password'][name='Passwd'"));
###### 下一篇文章
##### [9m。 WebDriver –定位元素：第3b部分（由cssSelector续）](https://javabeginnerstutorial.com/selenium/9m-webdriver-locating-elements-3b/ "9m. WebDriver – Locating elements: Part 3b (by cssSelector contd.)")
\ No newline at end of file
##### [9m。 WebDriver –定位元素：第 3b 部分（由 cssSelector 续）](https://javabeginnerstutorial.com/selenium/9m-webdriver-locating-elements-3b/ "9m. WebDriver – Locating elements: Part 3b (by cssSelector contd.)")
\ No newline at end of file
docs/114.md
浏览文件 @ 6bf5daa3
# 9m。 WebDriver –定位元素：第3b部分（由cssSelector续）
# 9m。 WebDriver –定位元素：第 3b 部分（由 cssSelector 续）
> 原文： [https://javabeginnerstutorial.com/selenium/9m-webdriver-locating-elements-3b/](https://javabeginnerstutorial.com/selenium/9m-webdriver-locating-elements-3b/)
嗨，忍者！ 这篇文章是我们先前文章“ [*9l”的延续。 WebDriver –定位元素：第3a部分（由cssSelector提供）*](https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/) ”。 在继续进行操作之前，请确保对它进行了仔细的研究。
嗨，忍者！ 这篇文章是我们先前文章“ [*9l”的延续。 WebDriver –定位元素：第 3a 部分（由 cssSelector 提供）*](https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/) ”。 在继续进行操作之前，请确保对它进行了仔细的研究。
使用cssSelector定位器的最后两种方法尚待讨论：
使用 cssSelector 定位器的最后两种方法尚待讨论：
1. 定位子元素
2. 按子字符串匹配
......@@ -13,13 +13,13 @@
## 1.定位子元素
也可以使用cssSelectors来定位子元素。
也可以使用 cssSelectors 来定位子元素。
让我们考虑一下HTML代码，
让我们考虑一下 HTML 代码，
锚标记是“ div”的子元素。 要访问子元素，
*使用ID：*
*使用 ID：*
```java
driver.findElement(By.cssSelector("div#child a"));
......@@ -35,9 +35,9 @@ driver.findElement(By.cssSelector("div.bg_main a"));
**。** 代表“班级”
***示例*** *：*让我们在Gmail帐户注册页面上找到名字文本框。
***示例*** *：*让我们在 Gmail 帐户注册页面上找到名字文本框。
右键点击“名字”文本框，然后选择检查元素，以获取相应的HTML代码，如下所示，
右键点击“名字”文本框，然后选择检查元素，以获取相应的 HTML 代码，如下所示，
```java
<label id="recovery-email-label">
......@@ -57,7 +57,7 @@ driver.findElement(By.cssSelector("label#recovery-email-label input[name='Recove
如果父元素具有**多个子元素**（例如下拉列表），并且它们没有“ id”或“ class”或此类属性来标识，则“ **nth-of-type** ”用于定位特定的子元素。
考虑一下HTML代码，
考虑一下 HTML 代码，
```java
<ul id="pets">
......@@ -77,7 +77,7 @@ driver.findElement(By.cssSelector("ul#pets li:nth-of-type(2)"));
## 按子字符串匹配
cssSelectors也帮助我们使用子字符串来定位元素。
cssSelectors 也帮助我们使用子字符串来定位元素。
### <u>匹配前缀（或）以</u>开头
......@@ -147,27 +147,27 @@ driver.findElement(By.cssSelector("input[name*='wdAg']"));
## <u>总体图片</u>
让我们看一个测试用例，它实现了使用本方法和上一篇文章中介绍的cssSelector定位器的不同方法，
让我们看一个测试用例，它实现了使用本方法和上一篇文章中介绍的 cssSelector 定位器的不同方法，
***场景***
1. 打开Firefox浏览器。
2. 导航到Google帐户创建页面
3. 找到带有HTML标签和名称属性的“名字”文本框
1. 打开 Firefox 浏览器。
2. 导航到 Google 帐户创建页面
3. 找到带有 HTML 标签和名称属性的“名字”文本框
4. 输入“ testFirst”作为名字
5. 在“姓氏”文本框中找到一个以子字符串开头的值
6. 输入“ testLast”作为姓氏
7. 找到带有HTML标签，类型和名称属性的“创建密码”文本框
7. 找到带有 HTML 标签，类型和名称属性的“创建密码”文本框
8. 输入“ Pass1234！”作为密码
9. 在“确认您的密码”文本框中找到包含子字符串的值
10. 输入“ Pass1234！”作为确认密码
11. 找到带有HTML标签和类别属性的“手机”文本框
11. 找到带有 HTML 标签和类别属性的“手机”文本框
12. 输入“ 9496543210”作为电话号码
13. 使用子元素方法找到“当前电子邮件地址”文本框
14. 输入“ [[受电子邮件保护]](/cdn-cgi/l/email-protection) ”
15. 验证“ JUnit”窗格是否成功，并确认Eclipse IDE控制台输出屏幕
15. 验证“ JUnit”窗格是否成功，并确认 Eclipse IDE 控制台输出屏幕
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -248,9 +248,9 @@ public class ElementLocatorTest3 {
![by cssSelector output](img/6078cdcb4a983f8f81a8daae42d8ee69.png)
在JUnit窗格中，绿色条显示测试用例已成功执行。 另外，控制台窗口中不会记录任何错误。
在 JUnit 窗格中，绿色条显示测试用例已成功执行。 另外，控制台窗口中不会记录任何错误。
下图显示了在Firefox浏览器中执行的最终输出。
下图显示了在 Firefox 浏览器中执行的最终输出。
![Browser output](img/1f13c1fe4f6f1394ab62a44476418761.png)
......@@ -260,4 +260,4 @@ public class ElementLocatorTest3 {
###### 下一篇文章
##### [9n。 WebDriver –定位元素：第4a部分（通过xpath）](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/ "9n. WebDriver – Locating elements: Part 4a (by xpath)")
\ No newline at end of file
##### [9n。 WebDriver –定位元素：第 4a 部分（通过 xpath）](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/ "9n. WebDriver – Locating elements: Part 4a (by xpath)")
\ No newline at end of file
docs/115.md
浏览文件 @ 6bf5daa3
# 9n。 WebDriver –定位元素：第4a部分（通过xpath）
# 9n。 WebDriver –定位元素：第 4a 部分（通过 xpath）
> 原文： [https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/)
欢迎回来，我们今天将讨论XPath策略。 这也是一种先进且有效的定位策略（cssSelectors也是！）。 虽然有效，但有时可能会造成混淆。 因此，让我们深入研究如何理解我们经常被误解的朋友，并一劳永逸地提出好的代码。
欢迎回来，我们今天将讨论 XPath 策略。 这也是一种先进且有效的定位策略（cssSelectors 也是！）。 虽然有效，但有时可能会造成混淆。 因此，让我们深入研究如何理解我们经常被误解的朋友，并一劳永逸地提出好的代码。
当所有希望都丧失了时，拯救自己的唯一机会就是转向XPath策略。 因为在大多数情况下，我们将测试现有的东西并且无法修改。 我们并不总是能够控制页面以添加一些ID，从而使自动化成为一项更简单的任务。 因此，请停止咆哮并认真对待！
当所有希望都丧失了时，拯救自己的唯一机会就是转向 XPath 策略。 因为在大多数情况下，我们将测试现有的东西并且无法修改。 我们并不总是能够控制页面以添加一些 ID，从而使自动化成为一项更简单的任务。 因此，请停止咆哮并认真对待！
*<u>准备点亮</u>*
**XPath** （XML路径语言）：根据 [w3schools](https://www.w3schools.com/xml/xpath_intro.asp) 的说法，XPath是一种“路径式”语言，用于标识和浏览XML文档中的各种元素和属性。
**XPath** （XML 路径语言）：根据 [w3schools](https://www.w3schools.com/xml/xpath_intro.asp) 的说法，XPath 是一种“路径式”语言，用于标识和浏览 XML 文档中的各种元素和属性。
因此，XPath提供了用于定位HTML文档中任何元素的语法。
因此，XPath 提供了用于定位 HTML 文档中任何元素的语法。
***<u>即时贴：</u>***
*如果到目前为止，您从未接触过XPath，请在继续进行操作之前先了解XPath术语。 特别是，节点和这些节点之间的关系即父母，子女，兄弟姐妹，祖先，后代。*
*如果到目前为止，您从未接触过 XPath，请在继续进行操作之前先了解 XPath 术语。 特别是，节点和这些节点之间的关系即父母，子女，兄弟姐妹，祖先，后代。*
如果您已经知道这些术语，并且希望略微刷一下，请参考下图。 礼貌： [w3schools](https://www.w3schools.com/xml/dom_intro.asp)
![xpath DOM](img/47f64a04787a000ea375191bbccb2614.png)
现在是当今的主要任务：**通过XPath策略定位元素！** 在这篇文章中，我们将研究以下技术，
现在是当今的主要任务：**通过 XPath 策略定位元素！** 在这篇文章中，我们将研究以下技术，
1. 捷径
2. 绝对XPath和相对XPath
2. 绝对 XPath 和相对 XPath
3. 使用标签和属性
4. 使用两个条件
5. 使用contains（）
5. 使用 contains（）
6. 查找多个元素
让我们从最简单的动机开始。
### 1.捷径：
是否想以简单的方式在网页上找到任何元素的XPath？ 做完了 是否希望几乎每次都处于完美的工作状态？ 也做完了。 马上完成所有这些操作呢？ 它让您涵盖了摇滚明星！ 您只需要“萤火虫”！ 它可以作为Firefox浏览器的附加组件使用。
是否想以简单的方式在网页上找到任何元素的 XPath？ 做完了 是否希望几乎每次都处于完美的工作状态？ 也做完了。 马上完成所有这些操作呢？ 它让您涵盖了摇滚明星！ 您只需要“萤火虫”！ 它可以作为 Firefox 浏览器的附加组件使用。
食谱来了：
1. 点击Firebug图标或按“ F12”。
2. 检查其XPath是必需的元素。
3. 相应的代码将在Firebug面板的“ HTML”部分中突出显示。
4. 右键点击突出显示的代码，然后选择“复制XPath”
5. 瞧！ 您已将准备好的烘焙XPath复制到剪贴板！
1. 点击 Firebug 图标或按“ F12”。
2. 检查其 XPath 是必需的元素。
3. 相应的代码将在 Firebug 面板的“ HTML”部分中突出显示。
4. 右键点击突出显示的代码，然后选择“复制 XPath”
5. 瞧！ 您已将准备好的烘焙 XPath 复制到剪贴板！
瞥见我们刚才所说的话，
![xpath firebug](img/7ccbc0c89fb7c153094fd84dd37b031c.png)
如果您希望获得有关Firebug的详细信息，请在处查看[。](https://javabeginnerstutorial.com/selenium/7n-ide-using-firebug/)
如果您希望获得有关 Firebug 的详细信息，请在处查看[。](https://javabeginnerstutorial.com/selenium/7n-ide-using-firebug/)
2.现在对于 ***<u>长短</u>*** ：
为了从头提出XPath，我们首先需要了解可用的两种Xpath。 它们是绝对XPath和相对XPath。
为了从头提出 XPath，我们首先需要了解可用的两种 Xpath。 它们是绝对 XPath 和相对 XPath。
*奖励：<u>准备点亮</u>* *（更多时间）*
| **绝对XPath** | **相对XPath** |
| **绝对 XPath** | **相对 XPath** |
| 它以单个正斜杠（/）开头。 | 它以双正斜杠（//）开头。 |
| ‘/”指示XPath引擎参考根节点搜索元素。 | “ //”指示XPath引擎在DOM结构中的任何位置搜索匹配的元素。 |
| 与相对的XPath相比，元素标识更快。 | 由于仅指定了部分路径，因此需要花费更多时间来标识元素。 |
| 即使对HTML DOM结构进行了最细微的更改（例如添加标签或删除标签），绝对XPath也会失败。 | 相对XPath较短，更改的可能性较小，从而使其更可靠。 |
| ‘/”指示 XPath 引擎参考根节点搜索元素。 | “ //”指示 XPath 引擎在 DOM 结构中的任何位置搜索匹配的元素。 |
| 与相对的 XPath 相比，元素标识更快。 | 由于仅指定了部分路径，因此需要花费更多时间来标识元素。 |
| 即使对 HTML DOM 结构进行了最细微的更改（例如添加标签或删除标签），绝对 XPath 也会失败。 | 相对 XPath 较短，更改的可能性较小，从而使其更可靠。 |
| 例如，/ html / head / body / div [2] / form / input | 例如//输入[@ name =“用户名”] |
有了这些基本知识，就让我们开始吧！
### 3.使用标签和属性：
可以使用其HTML标签，其属性（例如ID，名称，类，标题，值，href，src等）及其相应的值来定位特定的Web元素。
可以使用其 HTML 标签，其属性（例如 ID，名称，类，标题，值，href，src 等）及其相应的值来定位特定的 Web 元素。
***语法*** *：* *driver.findElement（By.xpath（“ // tag_name [@ attribute ='value']”）））;*
***解释*** *：*标识XPath指向的元素。 “ //”标识指定的节点，“ @”符号用于选择与给定值匹配的指定属性。
***解释*** *：*标识 XPath 指向的元素。 “ //”标识指定的节点，“ @”符号用于选择与给定值匹配的指定属性。
***示例*** *：*让我们在Gmail帐户注册页面上找到名字文本框。
***示例*** *：*让我们在 Gmail 帐户注册页面上找到名字文本框。
右键点击“名字”文本框，然后选择检查元素，以获取相应的HTML代码，如下所示，
右键点击“名字”文本框，然后选择检查元素，以获取相应的 HTML 代码，如下所示，
```java
<input value="" name="FirstName" id="FirstName" spellcheck="false"
......@@ -97,7 +97,7 @@ driver.findElement(By.xpath("//input[@class='form-error']"));
driver.findElement(By.xpath("/html/body/div[1]/div[2]/div/div[1]/div/form/div[1]/fieldset/label[1]/input"));
```
表单标签有许多子div标签。 在我们的情况下，我们希望选择第一个div标签。 可以将其指定为“ **div [1]** ”。 这些方括号[]中的数字表示要选择的确切同级。
表单标签有许多子 div 标签。 在我们的情况下，我们希望选择第一个 div 标签。 可以将其指定为“ **div [1]** ”。 这些方括号[]中的数字表示要选择的确切同级。
### 4.使用两个条件
......@@ -105,11 +105,11 @@ driver.findElement(By.xpath("/html/body/div[1]/div[2]/div/div[1]/div/form/div[1]
***语法*** *：* *driver.findElement（By.xpath（“ // tag_name [@ attribute1 ='value1'] [@ attribute2 ='value2' ]”））；*
***说明*** *：*标识具有指定tag_name的元素，这些元素的属性与给定值匹配。
***说明*** *：*标识具有指定 tag_name 的元素，这些元素的属性与给定值匹配。
***示例*** *：*让我们在Gmail帐户注册页面上找到“确认密码”文本框。
***示例*** *：*让我们在 Gmail 帐户注册页面上找到“确认密码”文本框。
右键点击“创建密码”和“确认密码”文本框，然后选择检查元素以获取相应的HTML代码，如下所示，
右键点击“创建密码”和“确认密码”文本框，然后选择检查元素以获取相应的 HTML 代码，如下所示，
```java
<input name="Passwd" id="Passwd" type="password">
......@@ -124,19 +124,19 @@ driver.findElement(By.xpath("/html/body/div[1]/div[2]/div/div[1]/div/form/div[1]
driver.findElement(By.xpath("//input[@type='password'][@id='PasswdAgain']"));
```
### 5.使用contains（）：
### 5.使用 contains（）：
如今，大多数属性值（例如“ id”，“ src”，“ href”等）都是使用恒定的前缀或后缀动态生成的。
想象一个网页每天都有变化的图像。 其src可以是“ Image_random-generated-key_date.jpg”。 在这种情况下，我们可以通过XPath使用在其src属性中包含“ Image”值的“ img”标记定位图像。 因此，通过指定属性的部分值，我们可以找到元素。
想象一个网页每天都有变化的图像。 其 src 可以是“ Image_random-generated-key_date.jpg”。 在这种情况下，我们可以通过 XPath 使用在其 src 属性中包含“ Image”值的“ img”标记定位图像。 因此，通过指定属性的部分值，我们可以找到元素。
***语法*** *：* *driver.findElement（By.xpath（“ // tag_name [contains（@ attribute，'value'）]]“）））;*
***说明*** *：*标识具有指定tag_name的元素，该元素的属性与给定的部分值相匹配。
***说明*** *：*标识具有指定 tag_name 的元素，该元素的属性与给定的部分值相匹配。
***示例*** *：*让我们在Gmail帐户注册页面上找到“下一步”按钮。
***示例*** *：*让我们在 Gmail 帐户注册页面上找到“下一步”按钮。
右键单击按钮并检查元素以获取相应的HTML代码，如下所示，
右键单击按钮并检查元素以获取相应的 HTML 代码，如下所示，
*Code:*
......@@ -144,13 +144,13 @@ driver.findElement(By.xpath("//input[@type='password'][@id='PasswdAgain']"));
driver.findElement(By.xpath("//div[contains(@class,'button')]/input"));
```
注意，该XPath标识div元素，该div元素包含带有部分值'button'的class属性（< div **class** =” form-element nextstep- **按钮**” [>），然后找到其子“ input”标签（即“提交”按钮）。
注意，该 XPath 标识 div 元素，该 div 元素包含带有部分值'button'的 class 属性（< div **class** =” form-element nextstep- **按钮**” [>），然后找到其子“ input”标签（即“提交”按钮）。
### 6.查找多个元素
您可能会遇到希望查找具有特定类或名称的所有元素并对它们执行某些操作的情况。 星号（*）符号可助我们一臂之力！
***示例*** *：*让我们在Gmail帐户注册页面上找到所有类值为“ goog-inline-block”的元素。
***示例*** *：*让我们在 Gmail 帐户注册页面上找到所有类值为“ goog-inline-block”的元素。
*Code:*
......@@ -160,7 +160,7 @@ driver.findElements(By.xpath("//*[contains(@class,'goog-inline-block')]"));
这将找到在其“类别”属性中包含值“ goog-inline-block”的所有标签。
明确指出要使用“ **findElements** ”，以便将所有已标识的Web元素添加到列表中。 如果使用“ findElement”，它将仅返回所标识的第一个元素。
明确指出要使用“ **findElements** ”，以便将所有已标识的 Web 元素添加到列表中。 如果使用“ findElement”，它将仅返回所标识的第一个元素。
**<u>总体图片</u>**
......@@ -168,22 +168,22 @@ driver.findElements(By.xpath("//*[contains(@class,'goog-inline-block')]"));
*场景*
1. 打开Firefox浏览器。
2. 导航到Google帐户创建页面
3. 使用绝对XPath找到“名字”文本框
1. 打开 Firefox 浏览器。
2. 导航到 Google 帐户创建页面
3. 使用绝对 XPath 找到“名字”文本框
4. 输入“ testFirst”作为名字
5. 使用标签和“ id”属性找到“姓氏”文本框（当然是相对的XPath！）
5. 使用标签和“ id”属性找到“姓氏”文本框（当然是相对的 XPath！）
6. 输入“ testLast”作为姓氏
7. 使用两个条件（类型和ID属性）找到“确认密码”文本框
7. 使用两个条件（类型和 ID 属性）找到“确认密码”文本框
8. 输入“ Pass1234！”作为确认密码
9. 使用星号将所有包含在其“类别”属性中值“ goog-inline-block”的元素定位
10. 将找到的元素总数打印到控制台
11. 将第一个标识的元素的标题值打印到控制台
12. 使用contains（）找到“下一步”按钮
12. 使用 contains（）找到“下一步”按钮
13. 将其“名称”属性的值打印到控制台
14. 验证Eclipse IDE控制台的输出屏幕和JUnit窗格是否成功
14. 验证 Eclipse IDE 控制台的输出屏幕和 JUnit 窗格是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -261,11 +261,11 @@ public class ElementLocatorTest4 {
这段代码将作为本文讨论的每种技术的一部分进行解释。
在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还显示带有星号的Web元素总数，以及下拉菜单和按钮的属性值。
在 JUnit 窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还显示带有星号的 Web 元素总数，以及下拉菜单和按钮的属性值。
![xpath console output](img/977d8338a6c42f78ddef7ee01858c9d9.png)
下图显示了成功执行测试脚本后获得的Firefox输出。
下图显示了成功执行测试脚本后获得的 Firefox 输出。
![xpath firefox output](img/bb66994234386495657bf7d8f36f91dd.png)
......@@ -273,4 +273,4 @@ public class ElementLocatorTest4 {
###### 下一篇文章
##### [9o。 WebDriver –定位元素：第4b部分（由XPath续）](https://javabeginnerstutorial.com/selenium/9o-webdriver-locating-elements-4b/ "9o. WebDriver – Locating elements: Part 4b (by XPath contd.)")
\ No newline at end of file
##### [9o。 WebDriver –定位元素：第 4b 部分（由 XPath 续）](https://javabeginnerstutorial.com/selenium/9o-webdriver-locating-elements-4b/ "9o. WebDriver – Locating elements: Part 4b (by XPath contd.)")
\ No newline at end of file
docs/116.md
浏览文件 @ 6bf5daa3
# 9o。 WebDriver –定位元素：第4b部分（由XPath续）
# 9o。 WebDriver –定位元素：第 4b 部分（由 XPath 续）
> 原文： [https://javabeginnerstutorial.com/selenium/9o-webdriver-locating-elements-4b/](https://javabeginnerstutorial.com/selenium/9o-webdriver-locating-elements-4b/)
嗨冠军！ 欢迎来到我们关于定位元素的最后一篇文章。 好极了！！！
这是我们上一篇文章“ [9n。 WebDriver –定位元素：第4a部分（由XPath提供）](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/)”。 您以前曾经听过我说过这个，然后您会再次听我说过……在继续使用XPath策略之前，请先阅读第4a部分。
这是我们上一篇文章“ [9n。 WebDriver –定位元素：第 4a 部分（由 XPath 提供）](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/)”。 您以前曾经听过我说过这个，然后您会再次听我说过……在继续使用 XPath 策略之前，请先阅读第 4a 部分。
在这篇文章中，我们将研究以下技术，
1. 使用Text（）
2. 使用starts-with（）
3. 使用XPath轴
1. 使用 Text（）
2. 使用 starts-with（）
3. 使用 XPath 轴
这些技术以及我们在第4a部分中看到的技术可以结合起来，并用于形成有效的XPath，该XPath可以定位网页上的任何元素。 现在通过示例来介绍当今的技术。
这些技术以及我们在第 4a 部分中看到的技术可以结合起来，并用于形成有效的 XPath，该 XPath 可以定位网页上的任何元素。 现在通过示例来介绍当今的技术。
## 1.使用text（）
## 1.使用 text（）
通过提供与网页上显示的文本**完全相同的**，这是一种轻松定位元素的方法。****
......@@ -22,16 +22,16 @@
*当心！ 即使错误地包含空格，您也可能遇到“ ElementNotFound”异常。 在代码中提供的文本必须与可见文本完全匹配，这一点非常重要，我的意思是从字面上看！*
***示例*** *：*让我们找到“ Facebook注册”页面上的“忘记帐户？”链接。
***示例*** *：*让我们找到“ Facebook 注册”页面上的“忘记帐户？”链接。
右键点击“忘记帐户？”链接，然后选择检查元素以获取相应的HTML代码，如下所示，
右键点击“忘记帐户？”链接，然后选择检查元素以获取相应的 HTML 代码，如下所示，
```java
<a href="https://www.facebook.com/recover/initiate?lwv=111"
data-testid="forgot_account_link">Forgot account?</a>
```
让我们通过提供出现在Facebook页面上的文本来找到此链接。
让我们通过提供出现在 Facebook 页面上的文本来找到此链接。
*代码：*
......@@ -39,21 +39,21 @@ data-testid="forgot_account_link">Forgot account?</a>
driver.findElement(By.xpath("//a[text()='Forgot account?']"));
```
如果要查找包含部分文本的所有元素，可以将contains（）和text（）技术结合使用。 可以使用findElements方法在列表中获取所有元素。
如果要查找包含部分文本的所有元素，可以将 contains（）和 text（）技术结合使用。 可以使用 findElements 方法在列表中获取所有元素。
让我们尝试在同一示例中同时实现contains（）和text（）。 由于我们只有一个链接与该文本，因此将使用findElement方法。
让我们尝试在同一示例中同时实现 contains（）和 text（）。 由于我们只有一个链接与该文本，因此将使用 findElement 方法。
```java
driver.findElement(By.xpath("//*[contains(text(),'Forgot')]"));
```
## 2.使用starts-with（）
## 2.使用 starts-with（）
通过指定属性的部分值（前缀），可以使用starts-with（）查找元素。 当页面重新加载时属性值动态更改时，此功能非常有用。
通过指定属性的部分值（前缀），可以使用 starts-with（）查找元素。 当页面重新加载时属性值动态更改时，此功能非常有用。
***示例*** *：*让我们在“ Facebook注册”页面上找到“新密码”文本框。
***示例*** *：*让我们在“ Facebook 注册”页面上找到“新密码”文本框。
右键点击“新密码”文本框，然后选择检查元素以获取相应的HTML代码，
右键点击“新密码”文本框，然后选择检查元素以获取相应的 HTML 代码，
```java
<input class="inputtext _58mg _5dba _2ph-" data-type="text"
......@@ -75,11 +75,11 @@ aria-label="New password" type="password">
driver.findElement(By.xpath("(//input[starts-with(@type,'pass')])[2]"));
```
## 3.使用XPath轴
## 3.使用 XPath 轴
XPath轴定义在当前节点浏览DOM的树形结构时要考虑的相对于当前节点的节点集或方向。
XPath 轴定义在当前节点浏览 DOM 的树形结构时要考虑的相对于当前节点的节点集或方向。
下表（礼貌性表示： [w3schools](https://www.w3schools.com/xml/xpath_axes.asp) ）显示了所有13个可用的XPath轴及其结果。
下表（礼貌性表示： [w3schools](https://www.w3schools.com/xml/xpath_axes.asp) ）显示了所有 13 个可用的 XPath 轴及其结果。
| **轴名称** | **结果** |
| 祖先 | 选择当前节点的所有祖先（父，祖父母等） |
......@@ -102,7 +102,7 @@ XPath轴定义在当前节点浏览DOM的树形结构时要考虑的相对于当
选择当前节点的父级。
***示例*** *：*让我们找到位于Facebook Sign Up页面左上方的Facebook徽标的锚标记。
***示例*** *：*让我们找到位于 Facebook Sign Up 页面左上方的 Facebook 徽标的锚标记。
在检查元素后，
......@@ -120,13 +120,13 @@ XPath轴定义在当前节点浏览DOM的树形结构时要考虑的相对于当
driver.findElement(By.xpath("//i[@class='fb_logo']/parent::a"));
```
将找到具有href和title属性的父节点“ a”。
将找到具有 href 和 title 属性的父节点“ a”。
### **3b。 祖先轴**
选择当前节点的所有祖先（父代，祖父母等）。
***示例*** *：*让我们在“ Facebook注册”页面上找到文字“生日”。
***示例*** *：*让我们在“ Facebook 注册”页面上找到文字“生日”。
Upon inspecting the element,
......@@ -138,7 +138,7 @@ Birthday
driver.findElement(By.xpath("//select[@id='month']/ancestor::div[@class='_5k_5']/preceding-sibling::div"));
```
带有ID的“选择”标签，选择了“月”。 转到类“ _5k_5”的祖先div标签。 然后到其前一个带有“ div”标签的同级节点，其文本为“ Birthday”。
带有 ID 的“选择”标签，选择了“月”。 转到类“ _5k_5”的祖先 div 标签。 然后到其前一个带有“ div”标签的同级节点，其文本为“ Birthday”。
选择该特定示例以显示可以组合多个轴以获得所需的结果。
......@@ -146,7 +146,7 @@ driver.findElement(By.xpath("//select[@id='month']/ancestor::div[@class='_5k_5']
选择当前节点的所有子节点
***示例*** *：*让我们找到“ Facebook注册”页面上的“登录”按钮。
***示例*** *：*让我们找到“ Facebook 注册”页面上的“登录”按钮。
Upon inspecting the element,
......@@ -166,13 +166,13 @@ driver.findElement(By.xpath("//label[@id='loginbutton']/child::input"));
选择当前节点的所有后代（子代，孙代等）。
***示例*** *：*让我们在“ Facebook注册”页面上找到“名字”文本框。
***示例*** *：*让我们在“ Facebook 注册”页面上找到“名字”文本框。
Upon inspecting the element,
First name
<输入id =“ u_0_1”类=“ inputtext _58mg _5dba _2ph-” data-type =“ text” name =“ firstname” aria-required =“ 1” placeholder =“”“ aria-label =” First name“类型 =“文字” > < / div >
<输入 id =“ u_0_1”类=“ inputtext _58mg _5dba _2ph-” data-type =“ text” name =“ firstname” aria-required =“ 1” placeholder =“”“ aria-label =” First name“类型 =“文字” > < / div >
*Code:*
......@@ -180,13 +180,13 @@ First name
driver.findElement(By.xpath("//div[contains(@class,'uiStickyPlaceholderInput')]/descendant::input"));
```
类别为'uiStickyPlaceholderInput'的'div'标签的后代节点-ID为'u_o_1'的输入标签已找到。
类别为'uiStickyPlaceholderInput'的'div'标签的后代节点-ID 为'u_o_1'的输入标签已找到。
### **3e。 从动轴**
选择当前节点之后的所有同级
***示例*** *：*让我们在“ Facebook注册”页面页脚部分中找到“登录”链接。
***示例*** *：*让我们在“ Facebook 注册”页面页脚部分中找到“登录”链接。
Upon inspecting the element,
......@@ -205,7 +205,7 @@ Upon inspecting the element,
driver.findElement(By.xpath("//td[@class='_51m- hLeft plm']/following-sibling::td/child::a"));
```
以下td标签的同级类_51m-hLeft plm是另一个td标签，其子对象是带有标题“登录Facebook”的锚标签。
以下 td 标签的同级类 _51m-hLeft plm 是另一个 td 标签，其子对象是带有标题“登录 Facebook”的锚标签。
将后继同级和子级轴组合在一起，以在页脚部分中找到“登录”超链接。
......@@ -213,7 +213,7 @@ driver.findElement(By.xpath("//td[@class='_51m- hLeft plm']/following-sibling::t
选择当前节点之前的所有同级
***示例*** *：*让我们找到“ Facebook注册”页面上的“女性”单选按钮。
***示例*** *：*让我们找到“ Facebook 注册”页面上的“女性”单选按钮。
Upon inspecting the element,
......@@ -232,9 +232,9 @@ driver.findElement(By.xpath("//label[@class='_58mt']/preceding-sibling::input"))
“标签”标签的前面同级是“无线电”类型的“输入”标签。 这样就找到了所需的单选按钮。
这样，就涵盖了一些常用的XPath轴类型。
这样，就涵盖了一些常用的 XPath 轴类型。
我们在BrainBell方面一直处于停滞状态。 那为什么要延迟呢？ 开始了，
我们在 BrainBell 方面一直处于停滞状态。 那为什么要延迟呢？ 开始了，
***BrainBell –*** ***注意！*** *注意您的大脑状态。*
......@@ -242,7 +242,7 @@ driver.findElement(By.xpath("//label[@class='_58mt']/preceding-sibling::input"))
* *<u>诊断：</u>* *您的大脑超负荷。*
* *<u>Remedy:</u>* *Take a break! But remember to be back soon 😉*
*我将根据我的经验个人建议 **Pomodoro技术**。 它非常有效。 试一试！*
*我将根据我的经验个人建议 **Pomodoro 技术**。 它非常有效。 试一试！*
## 总体图片
......@@ -250,15 +250,15 @@ driver.findElement(By.xpath("//label[@class='_58mt']/preceding-sibling::input"))
*场景*
1. 打开Firefox浏览器。
2. 导航到www.facebook.com
3. 使用text（）找到“忘记帐户？”链接
1. 打开 Firefox 浏览器。
2. 导航到 www.facebook.com
3. 使用 text（）找到“忘记帐户？”链接
4. 将链接文本打印到控制台
5. 使用starts-with（）找到“新密码”文本框
5. 使用 starts-with（）找到“新密码”文本框
6. 输入值“ test1234！”
7. 使用子轴找到“登录”按钮
8. 将值属性打印到控制台
9. 使用父轴找到Facebook徽标
9. 使用父轴找到 Facebook 徽标
10. 将其“标题”属性的值打印到控制台
11. 在页脚部分的“兄弟姐妹”轴中找到“登录”链接
12. 将其“标题”属性的值打印到控制台
......@@ -268,9 +268,9 @@ driver.findElement(By.xpath("//label[@class='_58mt']/preceding-sibling::input"))
16. 将其文本打印到控制台
17. 使用后代轴找到“名字”文本框
18. 输入值“首先测试”
19. 验证Eclipse IDE控制台的输出屏幕和JUnit窗格是否成功
19. 验证 Eclipse IDE 控制台的输出屏幕和 JUnit 窗格是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -357,11 +357,11 @@ public class ElementLocatorTest4b {
这段代码将作为本文讨论的每种技术的一部分进行解释。
在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还可以按预期显示所有打印结果。
在 JUnit 窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还可以按预期显示所有打印结果。
![XPath JUnit Console](img/044fb8d15c96e0bbc42010e4396dd739.png)
下图显示了成功执行测试脚本后获得的Firefox输出。
下图显示了成功执行测试脚本后获得的 Firefox 输出。
![XPath Firefox output](img/c696b7d190e210595629764b59692033.png)
......@@ -371,4 +371,4 @@ public class ElementLocatorTest4b {
###### 下一篇文章
##### [9分。 WebDriver – Timesaver /捷径：定位器验证](https://javabeginnerstutorial.com/selenium/9p-webdriver-shortcut-locator-validation/ "9p. WebDriver – Timesaver/Shortcut: Locator validation")
\ No newline at end of file
##### [9 分。 WebDriver – Timesaver /捷径：定位器验证](https://javabeginnerstutorial.com/selenium/9p-webdriver-shortcut-locator-validation/ "9p. WebDriver – Timesaver/Shortcut: Locator validation")
\ No newline at end of file
docs/117.md
浏览文件 @ 6bf5daa3
# 9便士 WebDriver – Timesaver /捷径：定位器验证
# 9 便士 WebDriver – Timesaver /捷径：定位器验证
> 原文： [https://javabeginnerstutorial.com/selenium/9p-webdriver-shortcut-locator-validation/](https://javabeginnerstutorial.com/selenium/9p-webdriver-shortcut-locator-validation/)
今天*锦上添花*：“一种验证所选择的定位器策略是否唯一标识被测网络元素的捷径”。
想象一下，您有一个取决于许多因素的测试脚本。 当您要测试新的Web元素时，要求您对它进行一些补充。 为了定位每个元素，可以使用先前文章中讨论的任何定位器策略（按ID，名称，tagName，className，linkText，cssSelector，xpath等）。 要检查代码是否按预期工作并且Web元素是否正确定位，您将不得不一次又一次地运行整个测试用例。 真痛苦！
想象一下，您有一个取决于许多因素的测试脚本。 当您要测试新的 Web 元素时，要求您对它进行一些补充。 为了定位每个元素，可以使用先前文章中讨论的任何定位器策略（按 ID，名称，tagName，className，linkText，cssSelector，xpath 等）。 要检查代码是否按预期工作并且 Web 元素是否正确定位，您将不得不一次又一次地运行整个测试用例。 真痛苦！
在这种情况下，谁不喜欢快捷键或节省时间！ 我听到你了
......@@ -12,9 +12,9 @@
#### *示例：*
让我们使用cssSelector（标记和名称属性）在Gmail帐户注册页面上找到“您当前的电子邮件地址”文本框。
让我们使用 cssSelector（标记和名称属性）在 Gmail 帐户注册页面上找到“您当前的电子邮件地址”文本框。
右键点击“您当前的电子邮件地址”文本框，然后选择检查元素以获取相应的HTML代码，如下所示，
右键点击“您当前的电子邮件地址”文本框，然后选择检查元素以获取相应的 HTML 代码，如下所示，
```java
<input name="RecoveryEmailAddress" id="RecoveryEmailAddress"
......@@ -26,9 +26,9 @@ type="text">
![Shortcut](img/87d67dcea7c38175d9c6e55c5ca89c74.png)
1. 输入“ ***css = input [name ='RecoveryEmailAddress']*** ”作为目标。 要了解此命令的形成方式，请签出 [7l。 Selenium IDE –定位元素（续）。 （通过CSS，DOM，XPath）](https://javabeginnerstutorial.com/selenium/7l-ide-locating-elements-contd/)
1. 输入“ ***css = input [name ='RecoveryEmailAddress']*** ”作为目标。 要了解此命令的形成方式，请签出 [7l。 Selenium IDE –定位元素（续）。 （通过 CSS，DOM，XPath）](https://javabeginnerstutorial.com/selenium/7l-ide-locating-elements-contd/)
2. 点击**'查找'**
3. **“您当前的电子邮件地址”** 文本框在Gmail帐户注册页面上突出显示。
3. **“您当前的电子邮件地址”** 文本框在 Gmail 帐户注册页面上突出显示。
这表明我们的定位器可以唯一地标识所需的元素，并且可以更加有把握地直接在代码中使用它。 这种方法节省了大量时间。 任务完成！
......
docs/118.md
浏览文件 @ 6bf5daa3
......@@ -2,7 +2,7 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9q-webdriver-handling-captcha/](https://javabeginnerstutorial.com/selenium/9q-webdriver-handling-captcha/)
有人说验证码吗？ 好吧，我听到了！ 让我们看看如何使用Selenium WebDriver处理这些问题，是的，我们将尝试尽快完成这项工作，因为今天晚些时候我将不得不参加比赛。
有人说验证码吗？ 好吧，我听到了！ 让我们看看如何使用 Selenium WebDriver 处理这些问题，是的，我们将尝试尽快完成这项工作，因为今天晚些时候我将不得不参加比赛。
*<u>准备点亮</u>*
......@@ -10,7 +10,7 @@
哦，别生我的气！ 那不是错字！ 确实有一个叫做**的缩写，** / backronym。 当由其他词的缩写形成缩写时，称为缩写。 但是，如果创建了一个新短语以适合已经存在的首字母缩写，那么它被称为简称。
因此，现在您知道什么是简称，并且CAPTCHA代表什么，让我们详细介绍一下。 验证码主要用于确定用户是否为人类。 它会生成图像或人类可以解决的某种形式的测试，但漫游器/计算机程序无法解决。
因此，现在您知道什么是简称，并且 CAPTCHA 代表什么，让我们详细介绍一下。 验证码主要用于确定用户是否为人类。 它会生成图像或人类可以解决的某种形式的测试，但漫游器/计算机程序无法解决。
因此，其主要目的是防止漫游器和其他自动化程序从网站获取任何敏感信息。 因此， ***验证码可以杀死自动化！*** 如果我们能够使其自动化，那么使用验证码的原因就变得毫无价值。
......@@ -20,7 +20,7 @@
1. **禁用**验证码验证
2. 提供**解决方法**或后门以获取验证码值
3. 调整验证码，使其每次都接受一个**特定输入值**
4. 开发一种方法，将随机文本存储在验证码图像的 **alt属性**中，然后可以使用可用的定位符获取该随机文本并将其传递到验证码文本框中
4. 开发一种方法，将随机文本存储在验证码图像的 **alt 属性**中，然后可以使用可用的定位符获取该随机文本并将其传递到验证码文本框中
但是，请确保它们仅在测试环境中处于活动状态，并且仅用于自动化目的。
......@@ -38,16 +38,16 @@
*场景*
1. 打开Firefox浏览器
2. 导航至https://www.in.ckgs.us/myaccount/
3. 通过cssSelector找到“当前护照号码”文本框：标记和名称属性
1. 打开 Firefox 浏览器
2. 导航至 https://www.in.ckgs.us/myaccount/
3. 通过 cssSelector 找到“当前护照号码”文本框：标记和名称属性
4. 输入“ 123456789”
5. 提示用户进行干预并输入显示的验证码
6. 通过ID找到验证码文本框
6. 通过 ID 找到验证码文本框
7. 将用户输入的值发送到找到的验证码文本框中
8. 在Eclipse IDE中验证JUnit窗格是否成功
8. 在 Eclipse IDE 中验证 JUnit 窗格是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -120,15 +120,15 @@ String captchaVal = JOptionPane.showInputDialog("Please enter the captcha value:
driver.findElement(By.id("recaptcha_response_field")).sendKeys(captchaVal);
```
保存在“ captchaVal”中的该值将在ID所在的验证码文本框中输入。
保存在“ captchaVal”中的该值将在 ID 所在的验证码文本框中输入。
![captcha_popup](img/a02b77a5d38b7b8d7bca02b434d431c4.png)
在JUnit窗格中，绿色条显示测试用例已成功执行。
在 JUnit 窗格中，绿色条显示测试用例已成功执行。
![captcha_output](img/865cb2e1e1ea8cb640637443e06caa77.png)
下图显示了在Firefox浏览器中执行的最终输出。
下图显示了在 Firefox 浏览器中执行的最终输出。
![captcha_output_firefox](img/c86ca4b23c21ea60785bf46a9b9c28a8.png)
......
docs/119.md
浏览文件 @ 6bf5daa3
# 9河 WebDriver –断言和验证
# 9 河 WebDriver –断言和验证
> 原文： [https://javabeginnerstutorial.com/selenium/9r-webdriver-assert-and-verify/](https://javabeginnerstutorial.com/selenium/9r-webdriver-assert-and-verify/)
Hiya超级巨星！ 我们已经定位元素很多天了。 让我们今天换一下话题，谈谈“确认和验证”。
Hiya 超级巨星！ 我们已经定位元素很多天了。 让我们今天换一下话题，谈谈“确认和验证”。
### 要记住，
......@@ -33,13 +33,13 @@ Hiya超级巨星！ 我们已经定位元素很多天了。 让我们今天换
## 示例场景
让我们获得为本教程系列创建的[示例网页](https://chandanachaitanya.github.io/selenium-practice-site/)的标题。 这将是我们使用WebDriver的`getTitle()`方法获得的**实际标题**。 **的预期标题**是“ WebDriver演示网站”。
让我们获得为本教程系列创建的[示例网页](https://chandanachaitanya.github.io/selenium-practice-site/)的标题。 这将是我们使用 WebDriver 的`getTitle()`方法获得的**实际标题**。 **的预期标题**是“ WebDriver 演示网站”。
### 情况1：通过`assertEquals`通过测试用例
### 情况 1：通过`assertEquals`通过测试用例
实际标题与预期标题相同，因此条件`Assert.assertEquals("WebDriver Demo Website", pageTitle);`的输出将是*成功。* 将执行此行之后的代码，并且将*传递给*测试用例。
### 情况2：使用`assertNotEquals`使测试用例失败
### 情况 2：使用`assertNotEquals`使测试用例失败
实际标题与预期标题相同，因此条件`Assert.assertNotEquals("WebDriver Demo Website", pageTitle);`的输出将是*故障*。 此行之后的代码将执行*而不是*。 测试执行*被中止*，并且测试用例将失败*。*
......@@ -55,4 +55,4 @@ System.out.println("Assert not equals failed");
![Assert condition failed](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20720%20340'%3E%3C/svg%3E)
<noscript><img alt="Assert condition failed" class="alignnone size-full wp-image-14150" height="340" src="img/9272cef7d4d831fd5ed1b3ae54bbd374.png" width="720"/><p>上图中的控制台显示<code>assertEquals</code>条件成功，因此将打印检查后的语句，“ <strong>声明等于通过。 </strong>”，而<code>assertNotEquals</code>条件失败，因此将不执行此检查之后的行。 打印语句“ <strong>声明不等于失败</strong>”不会打印到控制台。</p><h3>情况3：尽管assertNotEquals条件失败，但通过测试用例</h3><p>要仅验证实际值和预期值是否不相等，请使用<code>try-catch</code>块。</p><p><strong>Code snippet</strong></p><pre><code class="language-java">//Verify title not equal using try-catch block try { // Making the test fail Assert.assertNotEquals("WebDriver Demo Website", pageTitle); } catch(Error e){ // Following lines will be printed when the assert condition fails System.out.println("Assert not equals failed. But test execution is not aborted."); System.out.println("Error message: " + e.toString()); }</code></pre><p>即使<code>assertNotEquals</code>条件失败，catch块中的语句也将被执行，并且错误消息将被打印到控制台。</p><p><img alt="Verify condition fails" class="alignnone size-full wp-image-14149" data-lazy-sizes="(max-width: 825px) 100vw, 825px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg 825w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-300x124.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-768x318.jpg 768w" height="342" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20825%20342'%3E%3C/svg%3E" width="825"/></p><noscript><img alt="Verify condition fails" class="alignnone size-full wp-image-14149" height="342" sizes="(max-width: 825px) 100vw, 825px" src="img/d09793dee60556d778b6b7f310560194.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg 825w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-300x124.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-768x318.jpg 768w" width="825"/><p>如图所示，测试用例执行成功，并且错误被打印到控制台。</p><h2>完整的代码</h2><pre><code class="language-java">import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertAndVerify { // Declaring variables private WebDriver driver; private String baseUrl; @Before public void setUp() throws Exception { // Selenium version 3 beta releases require system property set up System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\" + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe"); // Create a new instance for the class FirefoxDriver // that implements WebDriver interface driver = new FirefoxDriver(); // Implicit wait for 5 seconds driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // Assign the URL to be invoked to a String variable baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/"; } @Test public void testPageTitle() throws Exception { // Open baseUrl in Firefox browser window driver.get(baseUrl); // Get the page title String pageTitle = driver.getTitle(); // Print the title to console System.out.println("The actual title is: " + pageTitle); // Check if actual and expected values are equal Assert.assertEquals("WebDriver Demo Website", pageTitle); // Printing success message System.out.println("Assert equals passed."); // Making the test fail //Assert.assertNotEquals("WebDriver Demo Website", pageTitle); // Following lines will not be executed as above assert condition fails //System.out.println("Assert not equals failed"); //Verify title not equal using try-catch block try { // Making the test fail Assert.assertNotEquals("WebDriver Demo Website", pageTitle); } catch(Error e){ // Following lines will be printed when the assert condition fails System.out.println("Assert not equals failed. But test execution is not aborted."); System.out.println("Error message: " + e.toString()); } } // End of @Test @After public void tearDown() throws Exception { // Close the Firefox browser driver.close(); } }</code></pre><p>所有代码文件都放置在<a href="https://github.com/JBTAdmin/Selenium/tree/master/WebDriver"> GitHub存储库</a>中，以方便访问。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读“ README.md”文件以获取明确说明。</p><p>总结了断言和验证的这一部分。 祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/" title="9s. WebDriver – Handling text boxes and images"> 9秒。 WebDriver –处理文本框和图像</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Assert condition failed" class="alignnone size-full wp-image-14150" height="340" src="img/9272cef7d4d831fd5ed1b3ae54bbd374.png" width="720"/><p>上图中的控制台显示<code>assertEquals</code>条件成功，因此将打印检查后的语句，“ <strong>声明等于通过。 </strong>”，而<code>assertNotEquals</code>条件失败，因此将不执行此检查之后的行。 打印语句“ <strong>声明不等于失败</strong>”不会打印到控制台。</p><h3>情况 3：尽管 assertNotEquals 条件失败，但通过测试用例</h3><p>要仅验证实际值和预期值是否不相等，请使用<code>try-catch</code>块。</p><p><strong>Code snippet</strong></p><pre><code class="language-java">//Verify title not equal using try-catch block try { // Making the test fail Assert.assertNotEquals("WebDriver Demo Website", pageTitle); } catch(Error e){ // Following lines will be printed when the assert condition fails System.out.println("Assert not equals failed. But test execution is not aborted."); System.out.println("Error message: " + e.toString()); }</code></pre><p>即使<code>assertNotEquals</code>条件失败，catch 块中的语句也将被执行，并且错误消息将被打印到控制台。</p><p><img alt="Verify condition fails" class="alignnone size-full wp-image-14149" data-lazy-sizes="(max-width: 825px) 100vw, 825px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg 825w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-300x124.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-768x318.jpg 768w" height="342" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20825%20342'%3E%3C/svg%3E" width="825"/></p><noscript><img alt="Verify condition fails" class="alignnone size-full wp-image-14149" height="342" sizes="(max-width: 825px) 100vw, 825px" src="img/d09793dee60556d778b6b7f310560194.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg 825w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-300x124.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-768x318.jpg 768w" width="825"/><p>如图所示，测试用例执行成功，并且错误被打印到控制台。</p><h2>完整的代码</h2><pre><code class="language-java">import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertAndVerify { // Declaring variables private WebDriver driver; private String baseUrl; @Before public void setUp() throws Exception { // Selenium version 3 beta releases require system property set up System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\" + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe"); // Create a new instance for the class FirefoxDriver // that implements WebDriver interface driver = new FirefoxDriver(); // Implicit wait for 5 seconds driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // Assign the URL to be invoked to a String variable baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/"; } @Test public void testPageTitle() throws Exception { // Open baseUrl in Firefox browser window driver.get(baseUrl); // Get the page title String pageTitle = driver.getTitle(); // Print the title to console System.out.println("The actual title is: " + pageTitle); // Check if actual and expected values are equal Assert.assertEquals("WebDriver Demo Website", pageTitle); // Printing success message System.out.println("Assert equals passed."); // Making the test fail //Assert.assertNotEquals("WebDriver Demo Website", pageTitle); // Following lines will not be executed as above assert condition fails //System.out.println("Assert not equals failed"); //Verify title not equal using try-catch block try { // Making the test fail Assert.assertNotEquals("WebDriver Demo Website", pageTitle); } catch(Error e){ // Following lines will be printed when the assert condition fails System.out.println("Assert not equals failed. But test execution is not aborted."); System.out.println("Error message: " + e.toString()); } } // End of @Test @After public void tearDown() throws Exception { // Close the Firefox browser driver.close(); } }</code></pre><p>所有代码文件都放置在<a href="https://github.com/JBTAdmin/Selenium/tree/master/WebDriver"> GitHub 存储库</a>中，以方便访问。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读“ README.md”文件以获取明确说明。</p><p>总结了断言和验证的这一部分。 祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/" title="9s. WebDriver – Handling text boxes and images"> 9 秒。 WebDriver –处理文本框和图像</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/12.md
浏览文件 @ 6bf5daa3
# Java中的访问修饰符
# Java 中的访问修饰符
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/access-modifier-in-java/](https://javabeginnerstutorial.com/core-java-tutorial/access-modifier-in-java/)
Java中的访问修饰符可帮助您设置所需的类，变量和方法的访问级别。
Java 中的访问修饰符可帮助您设置所需的类，变量和方法的访问级别。
有三个访问修饰符。 不包括默认访问修饰符。 默认值为访问控制，当未指定任何访问修饰符时将设置访问控制。
......@@ -17,17 +17,17 @@ Java中的访问修饰符可帮助您设置所需的类，变量和方法的访
## 类的访问修饰符
Java中的类只能使用public和default访问修饰符。
Java 中的类只能使用 public 和 default 访问修饰符。
### 上市
设置为public时，java世界中所有可用的类都可以访问给定的类。
设置为 public 时，java 世界中所有可用的类都可以访问给定的类。
### 默认
当设置为默认值时，给定的类将可供同一包中定义的类访问。
## 类的Java访问修饰符表
## 类的 Java 访问修饰符表
| **可见性** | **公共访问修饰符** | **默认访问修饰符** |
| **位于同一程序包中** | 是 | Yes |
......@@ -46,15 +46,15 @@ Java中的类只能使用public和default访问修饰符。
>
> 如果该类是可见的，则在该类内部定义的变量将是可见的。
>
> 如果看不到Class，则即使将其设置为public，也将无法访问任何变量。
> 如果看不到 Class，则即使将其设置为 public，也将无法访问任何变量。
### Default
如果将变量设置为默认值，则同一包中定义的类将可以访问该变量。 在同一包中的类中定义的任何方法都可以访问变量v *或* ***继承*** *或* ***直接访问。***
如果将变量设置为默认值，则同一包中定义的类将可以访问该变量。 在同一包中的类中定义的任何方法都可以访问变量 v *或* ***继承*** *或* ***直接访问。***
### 上市
如果将变量设置为公共变量，则可以从Java世界中可用的任何类中进行访问。 任何类中的任何方法都可以访问给定变量v *或* ***继承*** *或* ***直接访问。***
如果将变量设置为公共变量，则可以从 Java 世界中可用的任何类中进行访问。 任何类中的任何方法都可以访问给定变量 v *或* ***继承*** *或* ***直接访问。***
### 受保护的
......@@ -64,9 +64,9 @@ Java中的类只能使用public和default访问修饰符。
### 私人的
只能从定义变量的类内部访问定义的变量private。 此类变量不能从已定义的类外部访问，甚至不能在其子类中访问。
只能从定义变量的类内部访问定义的变量 private。 此类变量不能从已定义的类外部访问，甚至不能在其子类中访问。
## 变量的Java Access修饰符表
## 变量的 Java Access 修饰符表
| **Visibility** | **Public Access Modifier** | **专用访问修饰符** | **受保护的访问修饰符** | **Default Access Modifier** |
| **在同一个类别中** | Yes | Yes | Yes | Yes |
......@@ -85,7 +85,7 @@ Java中的类只能使用public和default访问修饰符。
### 上市
将Method设置为public时，可以从Java世界中可用的任何类中访问它。 任何类中的任何方法都可以访问*或**继承**或**直接访问*** 的给定方法，具体取决于类级别的访问。
将 Method 设置为 public 时，可以从 Java 世界中可用的任何类中访问它。 任何类中的任何方法都可以访问*或**继承**或**直接访问*** 的给定方法，具体取决于类级别的访问。
**受保护的**
......@@ -97,7 +97,7 @@ Java中的类只能使用public和default访问修饰符。
只能从定义其的类内部访问定义为私有的方法。 此类方法无法从已定义的类外部访问，甚至不能从其子类访问。
## 方法的Java访问修饰符表
## 方法的 Java 访问修饰符表
| **Visibility** | **Public Access Modifier** | **Private Access Modifier** | **Protected Access Modifier** | **Default Access Modifier** |
| **Within Same Class** | Yes | Yes | Yes | Yes |
......@@ -108,7 +108,7 @@ Java中的类只能使用public和default访问修饰符。
## 局部变量的访问修饰符
*无法将*访问修饰符应用于l ocal变量。 只能将**最终**应用于局部变量，该局部变量是[非访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/ "Non Access Modifiers in Java")。
*无法将*访问修饰符应用于 l ocal 变量。 只能将**最终**应用于局部变量，该局部变量是[非访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/ "Non Access Modifiers in Java")。
## 继承或直接访问之间的区别
......@@ -179,10 +179,10 @@ class SecondClass extends FirstClass {
### 备忘单
* ***公共，私有，受保护的*** 是3种访问修饰符
* Java有4个访问级别。 ***公共，私有，受保护&默认。***
* ***公共，私有，受保护的*** 是 3 种访问修饰符
* Java 有 4 个访问级别。 ***公共，私有，受保护&默认。***
* 一个类只能具有公共和默认访问级别。
* 方法和实例变量（ ***非本地*** ）可以使用所有4个访问级别。
* 方法和实例变量（ ***非本地*** ）可以使用所有 4 个访问级别。
* 如果某个班级对其他班级不可见，则即使该成员的访问级别是公共的，也没有访问该班级成员的问题（ ***重要*** ）。
* 在成员可见之前，应检查班级可见性。
* 如果超类具有公共成员，则子类将继承它，即使它在其他包中也是如此。
......@@ -199,4 +199,4 @@ class SecondClass extends FirstClass {
###### 下一篇文章
##### [Java中的非访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/ "Non Access Modifiers in Java")
\ No newline at end of file
##### [Java 中的非访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/ "Non Access Modifiers in Java")
\ No newline at end of file
docs/120.md
浏览文件 @ 6bf5daa3
......@@ -2,7 +2,7 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/](https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/)
Hiya测试人员！ 如果您一直在关注我的帖子，那么您应该已经是使用Selenium WebDriver输入文本的专家。 如果不是（带着悲伤的表情），那就不用担心了！ 我把你们都覆盖了。
Hiya 测试人员！ 如果您一直在关注我的帖子，那么您应该已经是使用 Selenium WebDriver 输入文本的专家。 如果不是（带着悲伤的表情），那就不用担心了！ 我把你们都覆盖了。
## 处理文本框
......@@ -24,7 +24,7 @@ Hiya测试人员！ 如果您一直在关注我的帖子，那么您应该已经
<input name="Passwd" id="Passwd" type="password">
```
我们可以看到，“输入”标签具有“ **id** ”属性，名称和密码字段的属性分别为“ **FirstName** ”和“ **Passwd** ”。 使用这些ID定位这些网络元素后，我们将分别传递“ testFirst”和“ test1234！”作为它们的值。
我们可以看到，“输入”标签具有“ **id** ”属性，名称和密码字段的属性分别为“ **FirstName** ”和“ **Passwd** ”。 使用这些 ID 定位这些网络元素后，我们将分别传递“ testFirst”和“ test1234！”作为它们的值。
*代码：*
......@@ -41,9 +41,9 @@ driver.findElement(By.id("Passwd")).sendKeys("test1234!");
## 点击图片
可以通过多种方式选择图像。 通过id，name，className，cssSelector，xpath等。 我希望这样做是因为定位图像有时会非常棘手。
可以通过多种方式选择图像。 通过 id，name，className，cssSelector，xpath 等。 我希望这样做是因为定位图像有时会非常棘手。
请使用WebDriver中提供的使用各种策略定位元素的[定位元素的先前帖子，以防您错过它们。](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)
请使用 WebDriver 中提供的使用各种策略定位元素的[定位元素的先前帖子，以防您错过它们。](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)
让我们来看一个示例场景，为什么这个过程很棘手。
......@@ -51,7 +51,7 @@ driver.findElement(By.id("Passwd")).sendKeys("test1234!");
![Image](img/e8b6c97eab0095fb2fb26ac8a0fb070a.png)
右键点击“ Kindle”图片和检查元素。 相应的HTML代码是
右键点击“ Kindle”图片和检查元素。 相应的 HTML 代码是
```java
<a class="a-link-normal" href="/b/ref=br_pdt_mgUpt?_encoding=UTF8&amp;node=6669702011&amp;pf_rd_m=ATVPDKIKX0DER&amp;pf_rd_s=&amp;pf_rd_r=5VQBXJP2N17GX77H0TN9&amp;pf_rd_t=36701&amp;pf_rd_p=9c7b479f-fe0c-48f3-a1ab-c19df6492672&amp;pf_rd_i=desktop">
......@@ -62,7 +62,7 @@ src="https://images-na.ssl-images-amazon.com/images/G/01/gateway/yiyiz/Kindle._C
***说明*** ：如您所见，“ img”标签既没有提供“ id”属性，也没有提供“ class”属性。 这样就很难找到一个小小的中间！ 对于您在网络上找到的大多数图像，情况就是如此。
考虑到HTML代码，可以使用 **cssSelector** 定位策略。 通过这种策略定位图像的方法有两种，
考虑到 HTML 代码，可以使用 **cssSelector** 定位策略。 通过这种策略定位图像的方法有两种，
一个。 使用“ img”标签和“ src”属性
......@@ -84,7 +84,7 @@ driver.findElement(By.cssSelector("a.a-link-normal img[src='https://images-na.ss
driver.findElement(By.xpath("//a[@class='a-link-normal']/img"));
```
b。 直接将img标签及其src属性使用
b。 直接将 img 标签及其 src 属性使用
```java
driver.findElement(By.xpath("//img[@src='https://images-na.ssl-images-amazon.com/images/G/01/gateway/yiyiz/Kindle._CB300901238_.png']"));
......@@ -92,15 +92,15 @@ driver.findElement(By.xpath("//img[@src='https://images-na.ssl-images-amazon.com
*正在考虑的场景，*
1. 打开Firefox浏览器
2. 导航至https：// [amazon.com](https://www.amazon.com)
1. 打开 Firefox 浏览器
2. 导航至 https：// [amazon.com](https://www.amazon.com)
3. 将页面标题打印到控制台
4. 找到主页上显示的“ Kindle”图片
5. 点击图片
6. 再次将导航的页面标题打印到控制台
7. 在Eclipse IDE中验证JUnit窗口是否成功
7. 在 Eclipse IDE 中验证 JUnit 窗口是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -160,11 +160,11 @@ public class Click_Image {
代码是不言自明的，因为每行都有注释。
在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误以及单击图像前后的页面标题。
在 JUnit 窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误以及单击图像前后的页面标题。
![Image_eclipse_output](img/9b68bb9dc7e43c44056f5c8a0b41fe75.png)
下图显示了成功执行测试脚本后获得的Firefox输出。
下图显示了成功执行测试脚本后获得的 Firefox 输出。
![Image_browser_output](img/5a950207260065d079d6d163e6fd6762.png)
......
docs/121.md
浏览文件 @ 6bf5daa3
# 9吨 WebDriver –处理单选按钮和复选框
# 9 吨 WebDriver –处理单选按钮和复选框
> 原文： [https://javabeginnerstutorial.com/selenium/9t-webdriver-handling-radio-buttons-checkboxes/](https://javabeginnerstutorial.com/selenium/9t-webdriver-handling-radio-buttons-checkboxes/)
Hiya超级巨星！ 我知道您现在是[处理文本框和图像](https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/)的专家，但是还有很多东西要学习。 让我们成为铁杆！ 让我们了解如何处理单选按钮，复选框，下拉菜单，表格，警报等，但我们一次只能看到一个。 在本文中，我们将专注于处理单选按钮和复选框。 最后，WebDriver将使您表现出前所未有的表现力。
Hiya 超级巨星！ 我知道您现在是[处理文本框和图像](https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/)的专家，但是还有很多东西要学习。 让我们成为铁杆！ 让我们了解如何处理单选按钮，复选框，下拉菜单，表格，警报等，但我们一次只能看到一个。 在本文中，我们将专注于处理单选按钮和复选框。 最后，WebDriver 将使您表现出前所未有的表现力。
*<u>准备点亮</u>*
**单选按钮：**在一组单选按钮中，一次只能选择一个。 在HTML中，它们使用<输入>标签表示，并带有**类型的**属性，称为“ **radio”** 。
**单选按钮：**在一组单选按钮中，一次只能选择一个。 在 HTML 中，它们使用<输入>标签表示，并带有**类型的**属性，称为“ **radio”** 。
**复选框：**在一组复选框中，每个复选框都单独运行，用户可以根据需要选择多个复选框。 在HTML中，使用<输入>标签并将**类型**属性称为“ **复选框”** 来表示复选框。
**复选框：**在一组复选框中，每个复选框都单独运行，用户可以根据需要选择多个复选框。 在 HTML 中，使用<输入>标签并将**类型**属性称为“ **复选框”** 来表示复选框。
现在我们对单选按钮和复选框的工作方式有了一些清晰的了解，让我们使用Selenium WebDriver进行一些有趣的操作。
现在我们对单选按钮和复选框的工作方式有了一些清晰的了解，让我们使用 Selenium WebDriver 进行一些有趣的操作。
1. 使用各种定位策略定位单选按钮和复选框
2. 检查是否显示单选按钮/复选框[提示：isDisplayed（）方法]
......@@ -18,15 +18,15 @@ Hiya超级巨星！ 我知道您现在是[处理文本框和图像](https://java
4. 检查默认情况下是否选中单选按钮/复选框[提示：isSelected（）方法]
5. 选择/单击单选按钮或复选框[提示：click（）]
这五个操作将与[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)中的示例一起进行说明。 它没有世界上最好的UI，但目前已达到目的。
这五个操作将与[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)中的示例一起进行说明。 它没有世界上最好的 UI，但目前已达到目的。
## **1.使用各种定位策略定位单选按钮和复选框**
是时候再利用[定位策略](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)的功能了！
***示例*** *：*让我们按ID定位“ Bicycle”复选框，按名称定位“ Tricycle”复选框，按xPath定位“ Sedan”复选框，并按“ Magazines”单选按钮定位 cssSelector。
***示例*** *：*让我们按 ID 定位“ Bicycle”复选框，按名称定位“ Tricycle”复选框，按 xPath 定位“ Sedan”复选框，并按“ Magazines”单选按钮定位 cssSelector。
右键单击所需元素，然后选择检查元素，将给出相应的HTML代码，如下所示，
右键单击所需元素，然后选择检查元素，将给出相应的 HTML 代码，如下所示，
```java
<input id="bicycle-checkbox" type="checkbox" name="vehicle1" value="Bicycle">&nbsp;Bicycle
......@@ -46,11 +46,11 @@ driver.findElement(By.cssSelector("input[value='Magazines']"));
## 2\. **检查单选按钮/复选框是否显示**
使用Selenium WebDriver，检查特定的单选按钮或复选框是否按预期显示在网页上是小菜一碟！ 我们有isDisplayed（）方法来进行救援。 此方法返回一个布尔值（显示 **true** –元素，显示 **false** – element）。
使用 Selenium WebDriver，检查特定的单选按钮或复选框是否按预期显示在网页上是小菜一碟！ 我们有 isDisplayed（）方法来进行救援。 此方法返回一个布尔值（显示 **true** –元素，显示 **false** – element）。
***示例*** *：*让我们检查网页上是否显示了“ Tricycle”复选框。
各自的HTML代码供参考，
各自的 HTML 代码供参考，
```java
<input id="tricycle-checkbox" type="checkbox" name="vehicle2" value="Tricycle" disabled>&nbsp;Tricycle
......@@ -64,7 +64,7 @@ driver.findElement(By.name("vehicle2")).isDisplayed();
## 3\. **检查单选按钮/复选框是否已启用，以便可以选择它**
同样，为了验证是否启用了特定的单选按钮或复选框，我们有isEnabled（）方法。 这还会返回一个布尔值（ **true** –元素已启用， **false** –元素已禁用）。
同样，为了验证是否启用了特定的单选按钮或复选框，我们有 isEnabled（）方法。 这还会返回一个布尔值（ **true** –元素已启用， **false** –元素已禁用）。
***示例*** *：*让我们检查是否启用了“ Tricycle”复选框。 如果是的话，让我们检查一下，否则我们只会在控制台上打印一条消息。
......@@ -90,7 +90,7 @@ if (tricycleCheckbox.isEnabled()) {
## 4\. **检查默认情况下是否选中单选按钮/复选框**
为了验证默认情况下是否选中了特定的单选按钮或复选框，我们有isSelected（）方法。 这还会返回一个布尔值（ **true** –元素已选择， **false** –未选择元素）。
为了验证默认情况下是否选中了特定的单选按钮或复选框，我们有 isSelected（）方法。 这还会返回一个布尔值（ **true** –元素已选择， **false** –未选择元素）。
***示例*** *：*让我们检查一下默认情况下是否选中了“杂志”单选按钮。 如果是，请让我们将该消息打印到控制台，否则我们将单击它以选择“杂志”选项。
......@@ -118,7 +118,7 @@ if (magazinesRadioBtn.isSelected()) {
## 5\. **选择/单击单选按钮或复选框**
您为什么认为Selenium WebDriver中有 **click（）**？ 你懂我！ 选中单选按钮非常容易，对于复选框，可以使用相同的click（）在选中和取消选中之间切换！
您为什么认为 Selenium WebDriver 中有 **click（）**？ 你懂我！ 选中单选按钮非常容易，对于复选框，可以使用相同的 click（）在选中和取消选中之间切换！
***示例*** *：*让我们选中并取消选中“轿车”复选框。
......@@ -150,21 +150,21 @@ for (int i = 0; i < 2; i++) {
*场景*
1. 打开Firefox浏览器。
1. 打开 Firefox 浏览器。
2. 导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
3. 按名称找到“三轮车”复选框
4. 检查是否显示“三轮车”复选框，并将相应消息打印到控制台
5. 检查“三轮车”复选框是否已启用
6. 如果是，请单击复选框，如果否，则将相应消息打印到控制台
7. 根据“货车”和“ SUV”复选框的当前选择状态，选中或取消选中并在执行click（）动作之前和之后打印状态
8. 使用XPath找到“轿车”复选框
7. 根据“货车”和“ SUV”复选框的当前选择状态，选中或取消选中并在执行 click（）动作之前和之后打印状态
8. 使用 XPath 找到“轿车”复选框
9. 使用两次迭代在选择状态和取消选择状态之间切换
10. 使用cssSelector找到“杂志”单选按钮
10. 使用 cssSelector 找到“杂志”单选按钮
11. 检查是否默认选中
12. 如果是，则将相应消息打印到控制台，否则，选择单选按钮
13. 验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功
13. 验证 Eclipse IDE 控制台输出屏幕和 JUnit 窗格是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -287,7 +287,7 @@ Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
除一个片段外，部分代码将作为本文讨论的每种技术的一部分进行解释。
所有类型为复选框的Web元素均在列表中获得，
所有类型为复选框的 Web 元素均在列表中获得，
```java
//Get all checkbox elements in a list
......@@ -309,7 +309,7 @@ for (int i = 0; i < list.size(); i++) {
+ list.get(i).isSelected());
```
使用isSelected（）方法，检查是否已选中“货车”或“ SUV”复选框。 如果未选中复选框，则将其选中，然后将其选择状态打印到控制台，显示“之后”。 如果已经选择了它们，然后再次单击以取消选择它们并将相应的消息打印到控制台。
使用 isSelected（）方法，检查是否已选中“货车”或“ SUV”复选框。 如果未选中复选框，则将其选中，然后将其选择状态打印到控制台，显示“之后”。 如果已经选择了它们，然后再次单击以取消选择它们并将相应的消息打印到控制台。
```java
// Check if the checkbox is selected
......@@ -326,11 +326,11 @@ System.out.println("AFTER: Is "+ list.get(i).getAttribute("value") + " selected?
}
```
在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
在 JUnit 窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
![Checkbox output IDE](img/f61f8cf48823ef303b562801236faccc.png)
下图显示了成功执行测试脚本后获得的Firefox输出。
下图显示了成功执行测试脚本后获得的 Firefox 输出。
![Radio Buttons Output Browser](img/7169846461ce6135ab02ca0c7a8aae86.png)
......
docs/122.md
浏览文件 @ 6bf5daa3
......@@ -2,15 +2,15 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9u-webdriver-select-items-two-ways/](https://javabeginnerstutorial.com/selenium/9u-webdriver-select-items-two-ways/)
Hiya摇滚明星（虽然不包括吉他和音乐）！ 在本文中，我们将深入研究下拉菜单以及如何以两种方式选择项目。 是的，我们还讨论了多个选择！ 所有概念都将与[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)中的示例一起进行说明。
Hiya 摇滚明星（虽然不包括吉他和音乐）！ 在本文中，我们将深入研究下拉菜单以及如何以两种方式选择项目。 是的，我们还讨论了多个选择！ 所有概念都将与[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)中的示例一起进行说明。
# <u>方法1：</u>
# <u>方法 1：</u>
使用可用定位策略之一使用相同年代的传统元素定位方法。 首先，我们找到下拉列表元素，然后找到需要选择的项目。 由于选项没有唯一的标识符，因此这并不困难。
***示例*** *：*让我们通过ID查找“编程语言”下拉列表。 要从可用的下拉菜单中找到“ C ++”，我们将必须找到标记名称为“ options”的所有元素，并将其放在列表中。 遍历列表，或者如果知道其索引，则相应地检索元素并执行单击操作。
***示例*** *：*让我们通过 ID 查找“编程语言”下拉列表。 要从可用的下拉菜单中找到“ C ++”，我们将必须找到标记名称为“ options”的所有元素，并将其放在列表中。 遍历列表，或者如果知道其索引，则相应地检索元素并执行单击操作。
右键单击所需元素，然后选择检查元素，将给出相应的HTML代码，如下所示，
右键单击所需元素，然后选择检查元素，将给出相应的 HTML 代码，如下所示，
```java
<select id="programming-languages" class="input-xlarge" name="languages">
......@@ -41,21 +41,21 @@ List<WebElement> options = progLanguages.findElements(By.tagName("option"));
options.get(1).click();
```
0、1、2、3是下拉列表的索引值。
0、1、2、3 是下拉列表的索引值。
# <u>方法2：</u>使用“ **选择”** 类。
# <u>方法 2：</u>使用“ **选择”** 类。
让我们深入研究并了解Select类的工作原理，并看一下它是否具有魔力。 以及为什么您首先要使用它？
让我们深入研究并了解 Select 类的工作原理，并看一下它是否具有魔力。 以及为什么您首先要使用它？
使用方法1具有主要缺点。 由于没有唯一标识符，因此选择特定选项变得非常困难。 另外，要选择多个选项，请取消选择特定的项目，这会变得很复杂。 Selenium Webdriver再次为我们解救！ 它为 **Select类**提供了预定义的方法，专门用于处理下拉菜单和多选方案。
使用方法 1 具有主要缺点。 由于没有唯一标识符，因此选择特定选项变得非常困难。 另外，要选择多个选项，请取消选择特定的项目，这会变得很复杂。 Selenium Webdriver 再次为我们解救！ 它为 **Select 类**提供了预定义的方法，专门用于处理下拉菜单和多选方案。
**步骤1：**该选择类在“ org.openqa.selenium.support.ui.Select”包中可用。 因此，必须将此包导入我们的测试脚本中。
**步骤 1：**该选择类在“ org.openqa.selenium.support.ui.Select”包中可用。 因此，必须将此包导入我们的测试脚本中。
```java
import org.openqa.selenium.support.ui.Select;
```
**步骤2：**通过传递所需的下拉标识符为Select类创建一个实例。
**步骤 2：**通过传递所需的下拉标识符为 Select 类创建一个实例。
```java
Select languages = new Select(driver.findElement(By.id("element_ID")));
......@@ -63,13 +63,13 @@ Select languages = new Select(driver.findElement(By.id("element_ID")));
可以使用前面讨论的任何定位策略（https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/）来定位下拉列表。
**步骤3：**找到下拉Web元素并创建Select类的对象后，就可以访问其所有方法来执行选择和取消选择。
**步骤 3：**找到下拉 Web 元素并创建 Select 类的对象后，就可以访问其所有方法来执行选择和取消选择。
***<u>即时贴：</u>***
*Select类仅适用于具有< select >标签的Web元素。*
*Select 类仅适用于具有< select >标签的 Web 元素。*
下面是Select类中所有可用方法的快照。
下面是 Select 类中所有可用方法的快照。
![Select class methods](img/c29b9a3b5bbe6b3e73ca7d1d07f4720b.png)
......@@ -77,11 +77,11 @@ Select languages = new Select(driver.findElement(By.id("element_ID")));
***<u>Sticky Note:</u>***
*如果找不到匹配的选项，则可能会使用所有select和deselect方法碰到 **NoSuchElementException** 。*
*如果找不到匹配的选项，则可能会使用所有 select 和 deselect 方法碰到 **NoSuchElementException** 。*
### **1\. selectByVisibleText（String arg0）和deselectByVisibleText（String arg0）**
### **1\. selectByVisibleText（String arg0）和 deselectByVisibleText（String arg0）**
这些方法选择和取消选择一个显示的文本与传递的String参数完全匹配的选项。
这些方法选择和取消选择一个显示的文本与传递的 String 参数完全匹配的选项。
***语法：*** *selectObject.selectByVisibleText（“ displayed_option_text”）;*
......@@ -106,17 +106,17 @@ languages.selectByVisibleText("JavaScript");
languages.deselectByVisibleText("JavaScript");
```
### **2\. selectByValue（String arg0）和deselectByValue（String arg0）**
### **2\. selectByValue（String arg0）和 deselectByValue（String arg0）**
这些方法选择和取消选择其value属性与传递的String参数匹配的选项。
这些方法选择和取消选择其 value 属性与传递的 String 参数匹配的选项。
***语法：*** *selectObject.selectByValue（“ value_attribute_text”）;*
*selectObject.deselectByValue（“ value_attribute_text”）;*
***示例：*** 让我们从Selenium Tool Suite多选选项中选择“ Selenium RC”。
***示例：*** 让我们从 Selenium Tool Suite 多选选项中选择“ Selenium RC”。
右键单击所需的Web元素，然后选择inspect元素，将给出相应的HTML代码，如下所示，
右键单击所需的 Web 元素，然后选择 inspect 元素，将给出相应的 HTML 代码，如下所示，
```java
<select id="selenium_suite" multiple="multiple" name="selenium_suite">
......@@ -125,7 +125,7 @@ languages.deselectByVisibleText("JavaScript");
<option value="RC">Selenium RC</option>
```
“值”属性的值“ RC”将作为参数传递给selectByValue方法。
“值”属性的值“ RC”将作为参数传递给 selectByValue 方法。
*Code:*
......@@ -133,7 +133,7 @@ languages.deselectByVisibleText("JavaScript");
multiSelect.selectByValue("RC");
```
### **3\. selectByIndex（int arg0）和deselectByIndex（int arg0）**
### **3\. selectByIndex（int arg0）和 deselectByIndex（int arg0）**
这些方法选择和取消选择指定索引值处的选项。 重要的是要注意，索引值始终以零开头。
......@@ -141,9 +141,9 @@ multiSelect.selectByValue("RC");
*selectObject.deselectByIndex（“ option_index”）;*
***示例：*** 让我们从Selenium Tool Suite多选选项中取消选择“ Selenium RC”。
***示例：*** 让我们从 Selenium Tool Suite 多选选项中取消选择“ Selenium RC”。
基于HTML代码，Selenium IDE的索引为0，Selenium WebDriver的索引为1，Selenium RC的索引为2。
基于 HTML 代码，Selenium IDE 的索引为 0，Selenium WebDriver 的索引为 1，Selenium RC 的索引为 2。
*Code:*
......@@ -157,11 +157,11 @@ multiSelect.deselectByIndex(2);
***<u>Sticky Note:</u>***
*此方法仅适用于多选方案，即< select >标签应具有值为“ multiple”的multi属性。 否则抛出“ **NotImplementedError** ”。*
*此方法仅适用于多选方案，即< select >标签应具有值为“ multiple”的 multi 属性。 否则抛出“ **NotImplementedError** ”。*
***语法：*** *selectObject.deselectAll（）*
***示例：*** 让我们取消选择在Selenium Tool Suite多重选择框中选择的所有选项。
***示例：*** 让我们取消选择在 Selenium Tool Suite 多重选择框中选择的所有选项。
*Code:*
......@@ -171,13 +171,13 @@ multiSelect.deselectAll();
### **5\. isMultiple（）**
当您想知道Web元素是否允许多选时，此方法很方便。 它返回true或false。 没有传递参数。
当您想知道 Web 元素是否允许多选时，此方法很方便。 它返回 true 或 false。 没有传递参数。
***语法：*** *selectObject.isMultiple（）*
### **6\. getOptions（）**
此方法作为Web元素返回在多重选择框中可用的所有选项的列表。
此方法作为 Web 元素返回在多重选择框中可用的所有选项的列表。
***语法：*** selectObject.getOptions（）
......@@ -189,7 +189,7 @@ List<WebElement> allOptions = multiSelect.getOptions();
### **7\. getFirstSelectedOption（）**
此方法在多重选择框中返回第一个选定的选项。 如果在仅允许单个选择的下拉菜单中使用此选项，则将所选选项作为Web元素返回。
此方法在多重选择框中返回第一个选定的选项。 如果在仅允许单个选择的下拉菜单中使用此选项，则将所选选项作为 Web 元素返回。
***语法：*** *selectObject.getFirstSelectedOption（）。getText（）*
......@@ -197,7 +197,7 @@ List<WebElement> allOptions = multiSelect.getOptions();
### **8\. getAllSelectedOptions（）**
此方法返回作为多选框的一部分而被选择为Web元素的所有选项的列表。
此方法返回作为多选框的一部分而被选择为 Web 元素的所有选项的列表。
***语法：*** *selectObject.getAllSelectedOptions（）*
......@@ -213,22 +213,22 @@ List<WebElement> allSelectedOptions = multiSelect.getAllSelectedOptions();
*场景*
1. 打开Firefox浏览器
1. 打开 Firefox 浏览器
2. 导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
3. 使用ID找到“编程语言”下拉菜单
4. 为Select类创建一个对象
3. 使用 ID 找到“编程语言”下拉菜单
4. 为 Select 类创建一个对象
5. 通过可见的文本选择“ JavaScript”语言
6. 将选定的选项打印到控制台
7. 检查“编程语言”下拉列表是否支持多项选择并将相应消息打印到控制台
8. 使用名称找到“ Selenium Tool Suite”多选框
9. 使用多选Web元素创建Select类的实例
10. 根据其值选择“硒RC”和“优势”
9. 使用多选 Web 元素创建 Select 类的实例
10. 根据其值选择“硒 RC”和“优势”
11. 通过索引取消选择“ Selenium RC”
12. 通过可见的文本选择“ Selenium WebDriver”
13. 在列表中获取所有选定的选项，并将它们打印到控制台
14. 验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功
14. 验证 Eclipse IDE 控制台输出屏幕和 JUnit 窗格是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -318,11 +318,11 @@ public class SelectItems {
每行代码都带有不言自明的注释，并且部分代码作为帖子中涉及的每个概念的一部分进行了说明。
在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
在 JUnit 窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
![select items eclipse output](img/fa9d2b65b4ab5173d953ac4dd65f06ca.png)
下图显示了成功执行测试脚本后获得的Firefox输出。
下图显示了成功执行测试脚本后获得的 Firefox 输出。
![select items firefox output](img/cd461c9703ed2d8df5413dd7dfa2a536.png)
......
docs/123.md
浏览文件 @ 6bf5daa3
......@@ -2,19 +2,19 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9v-webdriver-handling-tables-two-ways/](https://javabeginnerstutorial.com/selenium/9v-webdriver-handling-tables-two-ways/)
Hiya冠军！ 欢迎回到关于使用Selenium WebDriver处理Web元素的另一篇文章。 您每天都会学到一些新知识，而这就是我们今天将要学习的内容：使用和不使用XPath处理表！ 让我们回到我们的[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)以更好地理解这个概念。
Hiya 冠军！ 欢迎回到关于使用 Selenium WebDriver 处理 Web 元素的另一篇文章。 您每天都会学到一些新知识，而这就是我们今天将要学习的内容：使用和不使用 XPath 处理表！ 让我们回到我们的[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)以更好地理解这个概念。
餐桌就像到处都是名人。 好吧，是时候该去见我们的明星了！ 在整个这篇文章中，我们将使用演示站点中的“实践表”表。 在很多情况下，您可能需要检查表的特定单元格中是否存在特定数据。 因此，让我们继续前进，击中头部的粗体！
## **方法1：不使用XPath处理表**
## **方法 1：不使用 XPath 处理表**
在“练习表”中，我们有一个具有两行两列的表。 我们在第一行第二列中嵌套了另一个表。
***例如：***
让我们尝试访问嵌套表的第一行，并将文本“ Inner Row 1”打印到控制台。 由于我们不在这里使用XPath，因此它将变得有些复杂。 但是一旦您掌握了如何以一个嵌套级别定位一个单元，然后访问更深层次的单元就轻松了！ 第一步是使用标签名称“ table”查找主表。 可以使用任何定位策略，但通常表的行和列没有ID或名称。 因此，访问它们的最佳方法是使用它们相应的标签名称。 第二步是使用获得的Web元素（表），找到嵌套表。 最后一步是，使用嵌套表web元素，找到第一行并获取其文本！
让我们尝试访问嵌套表的第一行，并将文本“ Inner Row 1”打印到控制台。 由于我们不在这里使用 XPath，因此它将变得有些复杂。 但是一旦您掌握了如何以一个嵌套级别定位一个单元，然后访问更深层次的单元就轻松了！ 第一步是使用标签名称“ table”查找主表。 可以使用任何定位策略，但通常表的行和列没有 ID 或名称。 因此，访问它们的最佳方法是使用它们相应的标签名称。 第二步是使用获得的 Web 元素（表），找到嵌套表。 最后一步是，使用嵌套表 web 元素，找到第一行并获取其文本！
右键单击所需元素，然后选择检查元素，将给出相应的HTML代码段，如下所示，
右键单击所需元素，然后选择检查元素，将给出相应的 HTML 代码段，如下所示，
```java
<table class="table table-bordered">
......@@ -44,13 +44,13 @@ WebElement innerRow1 = innerTable.findElement(By.tagName("td"));
System.out.println("Inner table first row text = " + innerRow1.getText());
```
## **方法2：使用XPath处理表**
## **方法 2：使用 XPath 处理表**
第一种方法需要使用三个Web元素来访问所需的单元格。 如果涉及许多嵌套级别，则用于定位元素的命令数量将增加。 为了减轻这种情况，我们有XPath可以拯救我们！ “ XPath”一词会响起吗？ 如果不是这样，请参考XPath 的[定位元素以简单的方式构造它。](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/)
第一种方法需要使用三个 Web 元素来访问所需的单元格。 如果涉及许多嵌套级别，则用于定位元素的命令数量将增加。 为了减轻这种情况，我们有 XPath 可以拯救我们！ “ XPath”一词会响起吗？ 如果不是这样，请参考 XPath 的[定位元素以简单的方式构造它。](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/)
***例如：***
让我们找到嵌套表的第二行，并将其内容打印到控制台。 相对路径是XPath的一部分，用于定位嵌套表的所需单元格。
让我们找到嵌套表的第二行，并将其内容打印到控制台。 相对路径是 XPath 的一部分，用于定位嵌套表的所需单元格。
*Code:*
......@@ -65,16 +65,16 @@ WebElement innerRow2 = driver.findElement(By.xpath("//table/tbody/tr[1]/td[2]/ta
*场景*
1. 打开Firefox浏览器
1. 打开 Firefox 浏览器
2. 导航到演示站点（ [https://chandanachaitanya.github.io/selenium-practice-site/](https://chandanachaitanya.github.io/selenium-practice-site/) ）
3. 使用标签名称找到“练习表格”
4. 使用标签名称找到嵌套表
5. 使用标签名称找到嵌套表的第一行
6. 打印文本“ Inner Row 1”进行控制台
7. 使用XPath找到嵌套表的第二行
7. 使用 XPath 找到嵌套表的第二行
8. 打印文本“ Inner Row 2”进行控制台
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -137,7 +137,7 @@ public class HandlingTables {
每行代码都带有不言自明的注释，并且作为到目前为止涵盖的概念的一部分，代码得到了很好的解释。
注意到Eclipse IDE的JUnit视图后，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示了两个嵌套表行的文本。
注意到 Eclipse IDE 的 JUnit 视图后，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示了两个嵌套表行的文本。
![Handling tables eclipse output](img/550c64f7ac9901b92446c71830a0834f.png)
......
docs/124.md
浏览文件 @ 6bf5daa3
# 9周 WebDriver –遍历表元素
# 9 周 WebDriver –遍历表元素
> 原文： [https://javabeginnerstutorial.com/selenium/9w-webdriver-looping-table-elements/](https://javabeginnerstutorial.com/selenium/9w-webdriver-looping-table-elements/)
欢迎回来，勇士们！ 我们刚刚看到了如何检查使用和不使用XPath的表的特定单元格中是否存在特定的[数据。 是时候遍历每个元素并可视化Selenium WebDriver的功能了。 让我们回到我们的](https://javabeginnerstutorial.com/selenium/9v-webdriver-handling-tables-two-ways/)[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)并关注“ **书籍&作者”** 表以了解这一概念。
欢迎回来，勇士们！ 我们刚刚看到了如何检查使用和不使用 XPath 的表的特定单元格中是否存在特定的[数据。 是时候遍历每个元素并可视化 Selenium WebDriver 的功能了。 让我们回到我们的](https://javabeginnerstutorial.com/selenium/9v-webdriver-handling-tables-two-ways/)[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)并关注“ **书籍&作者”** 表以了解这一概念。
## **步骤1：**
## **步骤 1：**
**使用其ID“ BooksAuthorsTable”找到“图书&作者”** 表。 HTML代码如下
**使用其 ID“ BooksAuthorsTable”找到“图书&作者”** 表。 HTML 代码如下
```java
<table id="BooksAuthorsTable" class="table table-bordered">
......@@ -18,11 +18,11 @@
WebElement BooksTable = driver.findElement(By.id("BooksAuthorsTable"));
```
## **步骤2：**
## **步骤 2：**
**使用XPath计算行和列的总数**。
**使用 XPath 计算行和列的总数**。
让我们使用绝对XPath查找总行数。 请注意，XPath以标签名称“ tr”结尾。 size（）方法给出使用XPath由findElements（）返回的元素数。
让我们使用绝对 XPath 查找总行数。 请注意，XPath 以标签名称“ tr”结尾。 size（）方法给出使用 XPath 由 findElements（）返回的元素数。
*Code:*
......@@ -30,7 +30,7 @@ WebElement BooksTable = driver.findElement(By.id("BooksAuthorsTable"));
int rowNum = driver.findElements(By.xpath("/html/body/form/div[5]/div/div/table/tbody/tr")).size();
```
让我们稍微切换一下齿轮，并使用相对XPath查找总列数。
让我们稍微切换一下齿轮，并使用相对 XPath 查找总列数。
*Code:*
......@@ -40,11 +40,11 @@ int colNum = driver.findElements(By.xpath("//table[@id='BooksAuthorsTable']/tbod
这种查找行和列总数的方法在表的行和列动态变化的情况下很有用。
## **步骤3：**
## **步骤 3：**
**遍历表元素**
如果表的行和列号固定为，那么遍历每个表元素将变得非常容易。 可以使用两个for（）循环，一个用于行，另一个用于访问列值。
如果表的行和列号固定为，那么遍历每个表元素将变得非常容易。 可以使用两个 for（）循环，一个用于行，另一个用于访问列值。
*Code:*
......@@ -72,7 +72,7 @@ List<WebElement> rowVals = BooksTable.findElements(By.tagName("tr"));
List<WebElement> colHeader = rowVals.get(0).findElements(By.tagName("th"));
```
要将每个标题文本打印到控制台，请遍历colHeader列表中的标题值并使用getText（）方法。
要将每个标题文本打印到控制台，请遍历 colHeader 列表中的标题值并使用 getText（）方法。
```java
for(int i=0; i<colHeader.size(); i++){
......@@ -80,7 +80,7 @@ System.out.println(colHeader.get(i).getText());
}
```
要将表内容打印到控制台，请遍历每一行。 对于每一行，遍历每一列，并使用相同的getText（）方法打印值。
要将表内容打印到控制台，请遍历每一行。 对于每一行，遍历每一列，并使用相同的 getText（）方法打印值。
```java
for(int i=1; i<rowNum; i++){
......@@ -91,7 +91,7 @@ for(int j=0; j<colNum; j++){
}
```
您有能力集中精力下坡吗？ 如果是，让我们看看BrainBell！
您有能力集中精力下坡吗？ 如果是，让我们看看 BrainBell！
***BrainBell –可视化！*** *我们大多数人都知道，为我们希望记住的概念创建心理图片比单词更清晰，更容易记住。 我们不知道或做的是仔细观察它几秒钟。 这将有助于轻松调用它。*
......@@ -99,11 +99,11 @@ for(int j=0; j<colNum; j++){
### *场景*
1. 打开Firefox浏览器
1. 打开 Firefox 浏览器
2. 导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
3. 使用ID定位“图书&作者”表
4. 使用绝对XPath获取总行数
5. 使用相对XPath获取总列数
3. 使用 ID 定位“图书&作者”表
4. 使用绝对 XPath 获取总行数
5. 使用相对 XPath 获取总列数
6. 将行数和列数打印到控制台
7. 通过标签名称“ tr”获取所有行值
8. 通过标签名称“ th”获取列表中的列标题值
......@@ -112,7 +112,7 @@ for(int j=0; j<colNum; j++){
11. 将值打印到控制台
12. 使用固定的行号和列号将表内容打印到控制台
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -208,7 +208,7 @@ public class LoopingThroughTableElements {
到目前为止，每行代码都作为概念的一部分进行了很好的解释。
注意到Eclipse IDE的JUnit视图后，绿色条显示测试用例已成功执行。
注意到 Eclipse IDE 的 JUnit 视图后，绿色条显示测试用例已成功执行。
![Table looping eclipse output](img/eb1be06c75d2739900d2ad719e04086a.png)
......@@ -222,4 +222,4 @@ public class LoopingThroughTableElements {
###### 下一篇文章
##### [9倍。 WebDriver –处理警报/弹出框](https://javabeginnerstutorial.com/selenium/9x-webdriver-handling-alerts-popup-box/ "9x. WebDriver – Handling alerts/pop-up boxes")
\ No newline at end of file
##### [9 倍。 WebDriver –处理警报/弹出框](https://javabeginnerstutorial.com/selenium/9x-webdriver-handling-alerts-popup-box/ "9x. WebDriver – Handling alerts/pop-up boxes")
\ No newline at end of file
docs/125.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/126.md
浏览文件 @ 6bf5daa3
# 9岁 WebDriver –处理多个窗口
# 9 岁 WebDriver –处理多个窗口
> 原文： [https://javabeginnerstutorial.com/selenium/9y-webdriver-handling-multiple-windows/](https://javabeginnerstutorial.com/selenium/9y-webdriver-handling-multiple-windows/)
大家好！ 测试涉及多个窗口的工作流已成为生活的一部分。 借助Selenium WebDriver，在这些打开的窗口之间进行平滑切换已成为小菜一碟。 如果您像我一样，那么您可能会急切希望看到所有这些在我们的代码中如何真正起作用。 因此，让我们继续深入探讨吧……
大家好！ 测试涉及多个窗口的工作流已成为生活的一部分。 借助 Selenium WebDriver，在这些打开的窗口之间进行平滑切换已成为小菜一碟。 如果您像我一样，那么您可能会急切希望看到所有这些在我们的代码中如何真正起作用。 因此，让我们继续深入探讨吧……
每当实例化一个新的WebDriver对象时，就会向每个打开的唯一窗口分配一个唯一的字母数字ID。 这个独特的ID被称为“窗口句柄”-*，这是Selenium Ville* 拥挤的街道上的另一个新名词。 因此，使用这些唯一的ID，我们可以轻松地在窗口之间切换控件并执行所需的活动。
每当实例化一个新的 WebDriver 对象时，就会向每个打开的唯一窗口分配一个唯一的字母数字 ID。 这个独特的 ID 被称为“窗口句柄”-*，这是 Selenium Ville* 拥挤的街道上的另一个新名词。 因此，使用这些唯一的 ID，我们可以轻松地在窗口之间切换控件并执行所需的活动。
1.字符串getWindowHandle（）：
1.字符串 getWindowHandle（）：
此方法用于获取当前窗口的窗口句柄。
......@@ -19,7 +19,7 @@ String parentWinHandle = driver.getWindowHandle();
2.设置<字符串> getWindowHandles（）：
此方法用于获取Set中所有打开的窗口的窗口句柄。
此方法用于获取 Set 中所有打开的窗口的窗口句柄。
*Syntax:*
......@@ -28,26 +28,26 @@ String parentWinHandle = driver.getWindowHandle();
Set<String> winHandles = driver.getWindowHandles();
```
可以使用分配给每个打开的窗口的唯一句柄的引用，使用相同的switchTo（）方法从一个窗口切换到另一窗口。 为了更好地了解switchTo（），请单击此处的[。](https://javabeginnerstutorial.com/selenium/9x-webdriver-handling-alerts-popup-box/)
可以使用分配给每个打开的窗口的唯一句柄的引用，使用相同的 switchTo（）方法从一个窗口切换到另一窗口。 为了更好地了解 switchTo（），请单击此处的[。](https://javabeginnerstutorial.com/selenium/9x-webdriver-handling-alerts-popup-box/)
## **<u>场景</u>**
让我们看一个实现这些方法的测试案例，以更深入地了解这些概念，
1. 打开Firefox浏览器
1. 打开 Firefox 浏览器
2. 导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
3. 获取当前的窗口句柄并将其打印到控制台
4. 使用ID找到“点击以打开新的浏览器窗口！”按钮
4. 使用 ID 找到“点击以打开新的浏览器窗口！”按钮
5. 点击按钮打开新窗口
6. 获取两个打开的窗口的窗口句柄
7. 通过两个句柄循环
8. 切换到带有手柄参考的新窗口
9. 获取标题并将其打印到控制台
10. 关闭新视窗
11. 将控件切换回父窗口，然后将URL打印到控制台
12. 验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功
11. 将控件切换回父窗口，然后将 URL 打印到控制台
12. 验证 Eclipse IDE 控制台输出屏幕和 JUnit 窗格是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -126,7 +126,7 @@ driver.getTitle());
代码是不言自明的，因为同时提供了注释。
在Eclipse IDE中-> JUnit窗格->绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
在 Eclipse IDE 中-> JUnit 窗格->绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
![multiple windows eclipse output](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20819%20391'%3E%3C/svg%3E)
......
docs/127.md
浏览文件 @ 6bf5daa3
......@@ -2,9 +2,9 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9z-webdriver-window-maximize/](https://javabeginnerstutorial.com/selenium/9z-webdriver-window-maximize/)
嗨冠军！ 事情并非总是以我们希望的方式运作，这就是挑战的形式。 使用Selenium Webdriver，我们的测试工作变得比我们期望的要容易得多。 一种这样的情况是最大化浏览器窗口。
嗨冠军！ 事情并非总是以我们希望的方式运作，这就是挑战的形式。 使用 Selenium Webdriver，我们的测试工作变得比我们期望的要容易得多。 一种这样的情况是最大化浏览器窗口。
屏幕截图可以节省生命，为了在抓取时查看所有Web元素，最大化浏览器窗口非常重要。 因此，与其向下滚动到特定元素，不如最大化窗口并完成手头的任务。
屏幕截图可以节省生命，为了在抓取时查看所有 Web 元素，最大化浏览器窗口非常重要。 因此，与其向下滚动到特定元素，不如最大化窗口并完成手头的任务。
```java
// Maximize the new window
......@@ -15,10 +15,10 @@ driver.manage().window().maximize();
## <u>场景</u>
1. 打开Firefox浏览器
1. 打开 Firefox 浏览器
2. 导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
3. 获取当前的窗口句柄
4. 使用ID定位“单击以打开一个小窗口！”按钮
4. 使用 ID 定位“单击以打开一个小窗口！”按钮
5. 点击按钮打开小窗口
6. 获取两个打开的窗口的窗口句柄
7. 通过两个句柄循环
......@@ -26,10 +26,10 @@ driver.manage().window().maximize();
9. 获取标题并将其打印到控制台
10. 将小窗口最大化到全屏尺寸
11. 关闭新视窗
12. 将控件切换回父窗口，然后将URL打印到控制台
13. 验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功
12. 将控件切换回父窗口，然后将 URL 打印到控制台
13. 验证 Eclipse IDE 控制台输出屏幕和 JUnit 窗格是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
package com.blog.junitTests;
......@@ -97,8 +97,8 @@ public class WindowMaximize {
清晰的注释使代码不言自明。
在Eclipse IDE中-> JUnit窗格->绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
在 Eclipse IDE 中-> JUnit 窗格->绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
![](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20819%20391'%3E%3C/svg%3E)
<noscript><img alt="" class="alignnone size-full wp-image-12549" height="391" src="img/8747d9f868b65e6dad7be604914dd691.png" width="819"/><p>如有任何疑问，请不要在评论部分大喊大叫！</p><p>我很快会在另一篇文章中再见。 祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9aa-webdriver-executing-javascript-code/" title="9aa. WebDriver – Executing JavaScript code"> 9aa。 WebDriver –执行JavaScript代码</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="" class="alignnone size-full wp-image-12549" height="391" src="img/8747d9f868b65e6dad7be604914dd691.png" width="819"/><p>如有任何疑问，请不要在评论部分大喊大叫！</p><p>我很快会在另一篇文章中再见。 祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9aa-webdriver-executing-javascript-code/" title="9aa. WebDriver – Executing JavaScript code"> 9aa。 WebDriver –执行 JavaScript 代码</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/128.md
浏览文件 @ 6bf5daa3
# 9aa。 WebDriver –执行JavaScript代码
# 9aa。 WebDriver –执行 JavaScript 代码
> 原文： [https://javabeginnerstutorial.com/selenium/9aa-webdriver-executing-javascript-code/](https://javabeginnerstutorial.com/selenium/9aa-webdriver-executing-javascript-code/)
嗨冠军！ 今天就与浏览器进行一些高质量的互动！！ 因此，您能猜出浏览器首选的语言吗？ 是的，你说对了。 确实是 **JavaScript** 。 如果您使用的是Chrome，则单击“ F12”将打开“开发人员工具”，这有助于我们直接从浏览器执行JavaScript。 某些动作（例如滚动，显示警报等）变得更易于使用JavaScript进行管理。
嗨冠军！ 今天就与浏览器进行一些高质量的互动！！ 因此，您能猜出浏览器首选的语言吗？ 是的，你说对了。 确实是 **JavaScript** 。 如果您使用的是 Chrome，则单击“ F12”将打开“开发人员工具”，这有助于我们直接从浏览器执行 JavaScript。 某些动作（例如滚动，显示警报等）变得更易于使用 JavaScript 进行管理。
![Executing JavaScript in browser](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20791%20669'%3E%3C/svg%3E)
<noscript><img alt="Executing JavaScript in browser" class="alignnone size-full wp-image-13955" height="669" src="img/bc2efaf567c829cdf5dbeb4e67e88112.png" width="791"/><p>除此之外，在其他情况下，我们可能找不到合适的Selenium API来执行特定操作。 但是我们可以通过执行JavaScript代码来执行该操作。 Selenium WebDriver提供了一个界面，可以帮助我们做到这一点！</p><p><strong> JavascriptExecutor </strong>…您听说过，就像那些名人一样。 好吧，现在是我们该去见那颗璀璨的星星的时候了。 JavascriptExecutor不需要添加任何外部JAR文件或插件。 只需导入一个包即可完成工作，“导入<strong> org.openqa.selenium.JavascriptExecutor” </strong>。 它有两种重要的方法可以执行我们的Selenium测试中的JavaScript代码，以自动化测试中的应用程序，即</p><ul><li><strong> executeScript </strong>（脚本，参数）</li><li><strong> executeAsyncScript </strong>（脚本，参数）</li></ul><p><img alt="JavascriptExecutor methods" class="alignnone size-full wp-image-13956" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/2_JS-Executor-methods-1.jpg" height="130" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20511%20130'%3E%3C/svg%3E" width="511"/></p><noscript><img alt="JavascriptExecutor methods" class="alignnone size-full wp-image-13956" height="130" src="img/a2b574fd1517d1155515eab84c2019a6.png" width="511"/><p>让我们通过几个简单的步骤来理解这一点。</p><h2><strong>步骤1：</strong></h2><p>导入以下软件包，<code data-enlighter-language="java">import org.openqa.selenium.JavascriptExecutor;</code></p><p>创建一个JavascriptExecutor对象，并通过将其类型转换为JavascriptExecutor来分配驱动程序对象。</p><pre><code class="language-java">// Typecast driver to JavascriptExecutor JavascriptExecutor jsExecutor = (JavascriptExecutor)driver;</code></pre><h2><strong>步骤2：</strong></h2><p>这样创建的JavascriptExecutor对象允许我们从Selenium测试中执行JavaScript代码。</p><pre><code class="language-java">// Scroll down by 100 pixels jsExecutor.executeScript("window.scrollBy(0,100)");</code></pre><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad ezoic-adl" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>此“ excuteScript”方法采用两个参数。 第一个是JavaScript代码，第二个是Java脚本代码所需的可选参数列表。</p><h2><strong> <u>总体图片</u> </strong></h2><p>让我们看一个测试案例，实现到目前为止所介绍的技术，</p><h3><em>场景</em></h3><ol><li>打开Firefox浏览器</li><li>导航到演示站点（<a href="https://chandanachaitanya.github.io/selenium-practice-site/"> https://chandanachaitanya.github.io/selenium-practice-site/ </a>）</li><li>使用和不使用JavaScript代码打印页面URL进行控制台</li><li>垂直向下滚动页面100像素</li><li>刷新页面</li><li>导航到Google主页</li><li>使用JavaScript代码执行上述三个操作</li><li>验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功</li></ol><p>此方案的JUnit代码是，</p><pre><code class="language-java">import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.JavascriptExecutor; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class JavaScriptExecutorTest { // Declaring variables private WebDriver driver; private String baseUrl; @Before public void setUp() throws Exception { // Selenium version 3 beta releases require system property set up System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\" + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe"); // Create a new instance for the class FirefoxDriver // that implements WebDriver interface driver = new FirefoxDriver();53 // Implicit wait for 5 seconds driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // Assign the URL to be invoked to a String variable baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/"; } @Test public void testPageTitle() throws Exception { // Open baseUrl in Firefox browser window driver.get(baseUrl); Thread.sleep(5000); // Typecast driver to JavascriptExecutor JavascriptExecutor jsExecutor = (JavascriptExecutor)driver; // Execute JavaScript code and assign it to a String String pageURL = (String)jsExecutor.executeScript("return document.URL;"); // Print the URL to the console System.out.println("URL : " + pageURL); // Print the URL without JavaScript to the console System.out.println("URL without JavascriptExecutor: " + driver.getCurrentUrl()); // Scroll down by 100 pixels jsExecutor.executeScript("window.scrollBy(0,100)"); // Refresh the page jsExecutor.executeScript("history.go(0)"); // Navigating to a different page jsExecutor.executeScript("window.location = 'https://www.google.com/';"); } // End of @Test @After public void tearDown() throws Exception { // Close the Firefox browser driver.close(); } }</code></pre><h3><em>执行结果：</em></h3><p>为每行代码提供了注释，使其易于说明。</p><p>在JUnit窗格中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。</p><p><img alt="Eclipse IDE console output" class="alignnone size-full wp-image-13954" data-lazy-sizes="(max-width: 813px) 100vw, 813px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg 813w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-300x96.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-768x245.jpg 768w" height="259" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20813%20259'%3E%3C/svg%3E" width="813"/></p><noscript><img alt="Eclipse IDE console output" class="alignnone size-full wp-image-13954" height="259" sizes="(max-width: 813px) 100vw, 813px" src="img/9197339b0edc0ae7320e695f9f25a475.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg 813w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-300x96.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-768x245.jpg 768w" width="813"/><p>是时候尝试今天的技能了。 是的，戴上安全帽，以免遇到任何异常！</p><p>所有代码文件都放置在<a href="https://github.com/JBTAdmin/Selenium"> GitHub存储库</a>中，以方便访问。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读“ README.md”文件以获取明确说明。</p><p>祝你有美好的一天！</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9bb-webdriver-actions-class/" title="9ab. WebDriver – Using Actions Class"> 9ab。 WebDriver –使用动作类</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Executing JavaScript in browser" class="alignnone size-full wp-image-13955" height="669" src="img/bc2efaf567c829cdf5dbeb4e67e88112.png" width="791"/><p>除此之外，在其他情况下，我们可能找不到合适的 Selenium API 来执行特定操作。 但是我们可以通过执行 JavaScript 代码来执行该操作。 Selenium WebDriver 提供了一个界面，可以帮助我们做到这一点！</p><p><strong> JavascriptExecutor </strong>…您听说过，就像那些名人一样。 好吧，现在是我们该去见那颗璀璨的星星的时候了。 JavascriptExecutor 不需要添加任何外部 JAR 文件或插件。 只需导入一个包即可完成工作，“导入<strong> org.openqa.selenium.JavascriptExecutor” </strong>。 它有两种重要的方法可以执行我们的 Selenium 测试中的 JavaScript 代码，以自动化测试中的应用程序，即</p><ul><li><strong> executeScript </strong>（脚本，参数）</li><li><strong> executeAsyncScript </strong>（脚本，参数）</li></ul><p><img alt="JavascriptExecutor methods" class="alignnone size-full wp-image-13956" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/2_JS-Executor-methods-1.jpg" height="130" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20511%20130'%3E%3C/svg%3E" width="511"/></p><noscript><img alt="JavascriptExecutor methods" class="alignnone size-full wp-image-13956" height="130" src="img/a2b574fd1517d1155515eab84c2019a6.png" width="511"/><p>让我们通过几个简单的步骤来理解这一点。</p><h2><strong>步骤 1：</strong></h2><p>导入以下软件包，<code data-enlighter-language="java">import org.openqa.selenium.JavascriptExecutor;</code></p><p>创建一个 JavascriptExecutor 对象，并通过将其类型转换为 JavascriptExecutor 来分配驱动程序对象。</p><pre><code class="language-java">// Typecast driver to JavascriptExecutor JavascriptExecutor jsExecutor = (JavascriptExecutor)driver;</code></pre><h2><strong>步骤 2：</strong></h2><p>这样创建的 JavascriptExecutor 对象允许我们从 Selenium 测试中执行 JavaScript 代码。</p><pre><code class="language-java">// Scroll down by 100 pixels jsExecutor.executeScript("window.scrollBy(0,100)");</code></pre><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad ezoic-adl" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>此“ excuteScript”方法采用两个参数。 第一个是 JavaScript 代码，第二个是 Java 脚本代码所需的可选参数列表。</p><h2><strong> <u>总体图片</u> </strong></h2><p>让我们看一个测试案例，实现到目前为止所介绍的技术，</p><h3><em>场景</em></h3><ol><li>打开 Firefox 浏览器</li><li>导航到演示站点（<a href="https://chandanachaitanya.github.io/selenium-practice-site/"> https://chandanachaitanya.github.io/selenium-practice-site/ </a>）</li><li>使用和不使用 JavaScript 代码打印页面 URL 进行控制台</li><li>垂直向下滚动页面 100 像素</li><li>刷新页面</li><li>导航到 Google 主页</li><li>使用 JavaScript 代码执行上述三个操作</li><li>验证 Eclipse IDE 控制台输出屏幕和 JUnit 窗格是否成功</li></ol><p>此方案的 JUnit 代码是，</p><pre><code class="language-java">import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.JavascriptExecutor; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class JavaScriptExecutorTest { // Declaring variables private WebDriver driver; private String baseUrl; @Before public void setUp() throws Exception { // Selenium version 3 beta releases require system property set up System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\" + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe"); // Create a new instance for the class FirefoxDriver // that implements WebDriver interface driver = new FirefoxDriver();53 // Implicit wait for 5 seconds driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // Assign the URL to be invoked to a String variable baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/"; } @Test public void testPageTitle() throws Exception { // Open baseUrl in Firefox browser window driver.get(baseUrl); Thread.sleep(5000); // Typecast driver to JavascriptExecutor JavascriptExecutor jsExecutor = (JavascriptExecutor)driver; // Execute JavaScript code and assign it to a String String pageURL = (String)jsExecutor.executeScript("return document.URL;"); // Print the URL to the console System.out.println("URL : " + pageURL); // Print the URL without JavaScript to the console System.out.println("URL without JavascriptExecutor: " + driver.getCurrentUrl()); // Scroll down by 100 pixels jsExecutor.executeScript("window.scrollBy(0,100)"); // Refresh the page jsExecutor.executeScript("history.go(0)"); // Navigating to a different page jsExecutor.executeScript("window.location = 'https://www.google.com/';"); } // End of @Test @After public void tearDown() throws Exception { // Close the Firefox browser driver.close(); } }</code></pre><h3><em>执行结果：</em></h3><p>为每行代码提供了注释，使其易于说明。</p><p>在 JUnit 窗格中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。</p><p><img alt="Eclipse IDE console output" class="alignnone size-full wp-image-13954" data-lazy-sizes="(max-width: 813px) 100vw, 813px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg 813w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-300x96.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-768x245.jpg 768w" height="259" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20813%20259'%3E%3C/svg%3E" width="813"/></p><noscript><img alt="Eclipse IDE console output" class="alignnone size-full wp-image-13954" height="259" sizes="(max-width: 813px) 100vw, 813px" src="img/9197339b0edc0ae7320e695f9f25a475.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg 813w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-300x96.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-768x245.jpg 768w" width="813"/><p>是时候尝试今天的技能了。 是的，戴上安全帽，以免遇到任何异常！</p><p>所有代码文件都放置在<a href="https://github.com/JBTAdmin/Selenium"> GitHub 存储库</a>中，以方便访问。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读“ README.md”文件以获取明确说明。</p><p>祝你有美好的一天！</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9bb-webdriver-actions-class/" title="9ab. WebDriver – Using Actions Class"> 9ab。 WebDriver –使用动作类</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/129.md
浏览文件 @ 6bf5daa3
......@@ -2,11 +2,11 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9bb-webdriver-actions-class/](https://javabeginnerstutorial.com/selenium/9bb-webdriver-actions-class/)
灯光，摄像头，动作！ 是的，今天所有有关动作的内容。 哦，我不是在谈论您在电影中观看的那些战斗顺序，而是在谈论键盘和鼠标的动作。 Selenium WebDriver提供了一个面向用户的API，用于执行复杂的用户手势。 我们到处都希望自动化！ 因此，除了直接使用键盘和鼠标，我们还可以使用Actions类来执行基本的`click`，`sendKeys`和复杂的操作，例如`dragAndDrop`等。
灯光，摄像头，动作！ 是的，今天所有有关动作的内容。 哦，我不是在谈论您在电影中观看的那些战斗顺序，而是在谈论键盘和鼠标的动作。 Selenium WebDriver 提供了一个面向用户的 API，用于执行复杂的用户手势。 我们到处都希望自动化！ 因此，除了直接使用键盘和鼠标，我们还可以使用 Actions 类来执行基本的`click`，`sendKeys`和复杂的操作，例如`dragAndDrop`等。
## 一些可用的键盘和鼠标方法是，
### 1.单击（WebElement目标）
### 1.单击（WebElement 目标）
参数：*目标* –要单击的元素。
......@@ -16,13 +16,13 @@
说明：单击当前鼠标位置不会释放。
### 3\. doubleClick（WebElement目标）
### 3\. doubleClick（WebElement 目标）
Parameter: *target* – element to click.
说明：在给定目标元素的中间双击。 等效于：`Actions.moveToElement(element).doubleClick();`
### 4\. dragAndDrop（WebElement源，WebElement目标）
### 4\. dragAndDrop（WebElement 源，WebElement 目标）
参数：
......@@ -32,7 +32,7 @@ Parameter: *target* – element to click.
说明：在源元素的位置单击并按住，移至目标元素的位置，然后释放鼠标。
### 5\. dragAndDropBy（WebElement源，int xOffset，int yOffset）
### 5\. dragAndDropBy（WebElement 源，int xOffset，int yOffset）
Parameters:
......@@ -42,7 +42,7 @@ Parameters:
*yOffset* -垂直移动偏移。
说明：在源元素的位置单击并按住，在x轴上移动给定的xOffset，在y轴上移动给定的yOffset，然后释放鼠标。
说明：在源元素的位置单击并按住，在 x 轴上移动给定的 xOffset，在 y 轴上移动给定的 yOffset，然后释放鼠标。
### 6\. keyDown（java.lang.CharSequencemodifier_key）
......@@ -60,9 +60,9 @@ Parameters:
*xOffset* -垂直偏移。 负值表示向上移动鼠标。
说明：将鼠标从其当前位置（或0,0）移动x轴上的给定xOffset和y轴上的yOffset。
说明：将鼠标从其当前位置（或 0,0）移动 x 轴上的给定 xOffset 和 y 轴上的 yOffset。
### 8\. moveToElement（WebElement目标）
### 8\. moveToElement（WebElement 目标）
Parameters:
......@@ -84,17 +84,17 @@ Parameters:
### *场景*
1. 开启Chrome浏览器
1. 开启 Chrome 浏览器
2. 导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
3. 使用Actions类执行以下键盘和鼠标操作，
3. 使用 Actions 类执行以下键盘和鼠标操作，
1. 找到并点击“自行车”复选框
2. 找到文本“消息”，然后双击以突出显示它
3. 在大写文本框中输入“ hi there”
4. 将`click()`从第一位置拖放到可排序列表的第三位置
4. 在Chrome浏览器中验证输出
5. 验证Eclipse IDE控制台输出屏幕上是否有任何已打印的消息，并验证JUnit窗格是否成功
4. 在 Chrome 浏览器中验证输出
5. 验证 Eclipse IDE 控制台输出屏幕上是否有任何已打印的消息，并验证 JUnit 窗格是否成功
此方案的JUnit代码是，
此方案的 JUnit 代码是，
```java
import java.util.concurrent.TimeUnit;
......@@ -216,7 +216,7 @@ actions
.perform();
```
最简单的方法是使用`dragAndDropBy`方法，在该方法中，我们可以指定要拖动的元素以及xOffset和yOffset。
最简单的方法是使用`dragAndDropBy`方法，在该方法中，我们可以指定要拖动的元素以及 xOffset 和 yOffset。
如果您想走复杂路线，看起来像忍者，
......@@ -228,7 +228,7 @@ actions
.perform();
```
单击目标元素，在本例中为`html()`，并确保不要释放该喀哒声。 移动给定的xOffset和yOffset，然后释放鼠标单击，以便将元素放置在新位置。 结果，该元素被拖放。
单击目标元素，在本例中为`html()`，并确保不要释放该喀哒声。 移动给定的 xOffset 和 yOffset，然后释放鼠标单击，以便将元素放置在新位置。 结果，该元素被拖放。
### *执行结果：*
......@@ -236,4 +236,4 @@ actions
![Actions output 1](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20727%20338'%3E%3C/svg%3E)
<noscript><img alt="Actions output 1" class="alignnone size-full wp-image-14169" height="338" sizes="(max-width: 727px) 100vw, 727px" src="img/a68025a724b5fa9a039ffea6277c6cec.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/1_BrowserOutput1-1.jpg 727w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/1_BrowserOutput1-1-300x139.jpg 300w" width="727"/><p>自行车复选框位于并按预期检查。</p><p><img alt="Actions output 2" class="alignnone size-full wp-image-14170" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_BrowserOutput2.jpg" height="405" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20764%20405'%3E%3C/svg%3E" width="764"/></p><noscript><img alt="Actions output 2" class="alignnone size-full wp-image-14170" height="405" src="img/42cf6db6c7594635f8626fa848cb1b00.png" width="764"/><p>双击文本<code>Message</code>，结果将突出显示。 在文本框中，“ hi there”用大写字母键入。 从可排序列表中将<code>click()</code>从其默认的第一位置拖动到第三位置。</p><p>在JUnit窗格中，绿色条显示测试用例已成功执行。 同样，控制台窗口显示没有错误以及所有打印的消息如预期的那样。</p><p><img alt="Actions eclipse IDE output" class="alignnone size-full wp-image-14171" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/3_EclipseOutput-1.jpg" height="323" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20637%20323'%3E%3C/svg%3E" width="637"/></p><noscript><img alt="Actions eclipse IDE output" class="alignnone size-full wp-image-14171" height="323" src="img/fc8513d158727fc823c0450b50cb21b2.png" width="637"/><p>是时候把忍者带出来了。 尝试使用尽可能多的动作类方法，并从中获得乐趣！</p><p>上面讨论的所有代码都可以在<a href="https://github.com/JBTAdmin/Selenium"> GitHub存储库</a>的“ WebDriver”文件夹中找到。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读<code>README.md</code>文件以获取明确说明。</p><p>祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9ac-webdriver-unable-to-locate-an-element-easily-read-on/" title="9ac. WebDriver – Unable to locate an element easily? Read on…"> 9ac。 WebDriver –无法轻松定位元素？ 继续阅读…</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Actions output 1" class="alignnone size-full wp-image-14169" height="338" sizes="(max-width: 727px) 100vw, 727px" src="img/a68025a724b5fa9a039ffea6277c6cec.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/1_BrowserOutput1-1.jpg 727w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/1_BrowserOutput1-1-300x139.jpg 300w" width="727"/><p>自行车复选框位于并按预期检查。</p><p><img alt="Actions output 2" class="alignnone size-full wp-image-14170" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_BrowserOutput2.jpg" height="405" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20764%20405'%3E%3C/svg%3E" width="764"/></p><noscript><img alt="Actions output 2" class="alignnone size-full wp-image-14170" height="405" src="img/42cf6db6c7594635f8626fa848cb1b00.png" width="764"/><p>双击文本<code>Message</code>，结果将突出显示。 在文本框中，“ hi there”用大写字母键入。 从可排序列表中将<code>click()</code>从其默认的第一位置拖动到第三位置。</p><p>在 JUnit 窗格中，绿色条显示测试用例已成功执行。 同样，控制台窗口显示没有错误以及所有打印的消息如预期的那样。</p><p><img alt="Actions eclipse IDE output" class="alignnone size-full wp-image-14171" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/3_EclipseOutput-1.jpg" height="323" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20637%20323'%3E%3C/svg%3E" width="637"/></p><noscript><img alt="Actions eclipse IDE output" class="alignnone size-full wp-image-14171" height="323" src="img/fc8513d158727fc823c0450b50cb21b2.png" width="637"/><p>是时候把忍者带出来了。 尝试使用尽可能多的动作类方法，并从中获得乐趣！</p><p>上面讨论的所有代码都可以在<a href="https://github.com/JBTAdmin/Selenium"> GitHub 存储库</a>的“ WebDriver”文件夹中找到。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读<code>README.md</code>文件以获取明确说明。</p><p>祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9ac-webdriver-unable-to-locate-an-element-easily-read-on/" title="9ac. WebDriver – Unable to locate an element easily? Read on…"> 9ac。 WebDriver –无法轻松定位元素？ 继续阅读…</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/13.md
浏览文件 @ 6bf5daa3
# Java中的非访问修饰符
# Java 中的非访问修饰符
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/)
在本文中，您将学习非访问修饰符。 以下是可用的Java非访问修饰符。
在本文中，您将学习非访问修饰符。 以下是可用的 Java 非访问修饰符。
* 最后
* 抽象
......@@ -24,17 +24,17 @@
#### 期末课程：
一个类别设置为final时，不能由任何其他类别扩展为 ****。****
一个类别设置为 final 时，不能由任何其他类别扩展为 ****。****
#### **示例：java.lang包中的字符串**类
#### **示例：java.lang 包中的字符串**类
#### 最终方法：
一个方法设置为final时，*不能被任何子类覆盖**。***
一个方法设置为 final 时，*不能被任何子类覆盖**。***
#### 最终变量：
当变量设置为final时，其值*不能*更改为。 最终变量就像常量。
当变量设置为 final 时，其值*不能*更改为。 最终变量就像常量。
**示例：** public static final int i = 10;
......@@ -81,16 +81,16 @@
本机方法表明该方法是在依赖于平台的代码上实现的。
## Strictfp非访问权限编辑
## Strictfp 非访问权限编辑
### Applicable to
1. 类
2. 方法
### Strictfp类/方法
### Strictfp 类/方法
Strictfp非访问修饰符强制浮点或浮点操作遵守IEEE 754标准。
Strictfp 非访问修饰符强制浮点或浮点操作遵守 IEEE 754 标准。
**注意*：Strictfp** 不可访问修饰符*无法将*应用于变量。
......@@ -102,11 +102,11 @@ Strictfp非访问修饰符强制浮点或浮点操作遵守IEEE 754标准。
* 局部变量*不能*声明为*静态。*
* *静态关键字也可以应用于*方法。* 它们将适用于所有实例，并且它们将不依赖于实例创建。*
* 最终修饰符可以应用于*方法*和*变量*。
* Final是唯一可用于局部变量的修饰符。
* 一旦声明为final，则变量的值无法更改。
* 赋值后，最终变量不会获得默认值，而实例变量coz值无法更改。
* Final 是唯一可用于局部变量的修饰符。
* 一旦声明为 final，则变量的值无法更改。
* 赋值后，最终变量不会获得默认值，而实例变量 coz 值无法更改。
* 最终方法不能被覆盖。
###### 下一篇文章
##### [面向初学者的Java语句教程](https://javabeginnerstutorial.com/core-java-tutorial/java-statements-tutorial-for-beginners/ "Java Statements tutorial for Beginners")
\ No newline at end of file
##### [面向初学者的 Java 语句教程](https://javabeginnerstutorial.com/core-java-tutorial/java-statements-tutorial-for-beginners/ "Java Statements tutorial for Beginners")
\ No newline at end of file
docs/130.md
浏览文件 @ 6bf5daa3
......@@ -2,21 +2,21 @@
> 原文： [https://javabeginnerstutorial.com/selenium/9ac-webdriver-unable-to-locate-an-element-easily-read-on/](https://javabeginnerstutorial.com/selenium/9ac-webdriver-unable-to-locate-an-element-easily-read-on/)
好吧，如果您的内存比我的好，那么您将记住，Selenium WebDriver中有8种定位器类型，即ID，名称，标签名称，类名称，链接文本，部分链接文本，CSS选择器和XPath。 令人遗憾的是，即使我们有很多定位器类型，定位元素仍然充满挑战，尤其是在被测试的应用程序很复杂的情况下。
好吧，如果您的内存比我的好，那么您将记住，Selenium WebDriver 中有 8 种定位器类型，即 ID，名称，标签名称，类名称，链接文本，部分链接文本，CSS 选择器和 XPath。 令人遗憾的是，即使我们有很多定位器类型，定位元素仍然充满挑战，尤其是在被测试的应用程序很复杂的情况下。
例如，
1. 为每个会话生成唯一的ID（带有随机字母数字字符）
1. 为每个会话生成唯一的 ID（带有随机字母数字字符）
2. 各种元素的重复类名
3. 多个div标签使XPath的长度比平时更长
3. 多个 div 标签使 XPath 的长度比平时更长
所有这些使自动化测试人员的工作更具挑战性！ 绝对XPath可能会有所帮助，但是如果DOM中包含新元素或现有元素稍微移动了一点，那么脚本可能会失败，因为找不到该元素。 相对的XPath可能可以解决，但是即使那样，由于脚本变得复杂，整个过程也变得很困难。
所有这些使自动化测试人员的工作更具挑战性！ 绝对 XPath 可能会有所帮助，但是如果 DOM 中包含新元素或现有元素稍微移动了一点，那么脚本可能会失败，因为找不到该元素。 相对的 XPath 可能可以解决，但是即使那样，由于脚本变得复杂，整个过程也变得很困难。
The easy and best way to handle such situations is to introduce **`data-* attributes`** (custom data attributes) on HTML elements. The only catch here is, you will need to be in the good books of the developer! 😉 He/she is the one to add these attributes to the code as per your requirement.
现在让我对这些自定义数据属性进行学习，
custom属性允许我们在HTML元素上存储额外的数据或信息。 要遵循的规则是，
custom 属性允许我们在 HTML 元素上存储额外的数据或信息。 要遵循的规则是，
1. 属性名称应以 **`data-`** 开头
2. 在`data-`的此前缀之后，属性名称应至少一个字符长，并且只能使用小写字母
......@@ -40,4 +40,4 @@ custom属性允许我们在HTML元素上存储额外的数据或信息。 要遵
###### 下一篇文章
##### [10a。 高级WebDriver –使用Apache ANT](https://javabeginnerstutorial.com/selenium/10a-advanced-webdriver-apache-ant/ "10a. Advanced WebDriver – Using Apache ANT")
\ No newline at end of file
##### [10a。 高级 WebDriver –使用 Apache ANT](https://javabeginnerstutorial.com/selenium/10a-advanced-webdriver-apache-ant/ "10a. Advanced WebDriver – Using Apache ANT")
\ No newline at end of file
docs/131.md
浏览文件 @ 6bf5daa3
# 10a。 高级WebDriver –使用Apache ANT
# 10a。 高级 WebDriver –使用 Apache ANT
> 原文： [https://javabeginnerstutorial.com/selenium/10a-advanced-webdriver-apache-ant/](https://javabeginnerstutorial.com/selenium/10a-advanced-webdriver-apache-ant/)
大家好！ 您的构建中是否有ANT？ 开玩笑！ 其实我不是。 同意这听起来很怪异，但不要害怕，因为我在这里！ （现在，这就是我所说的，押韵。）
大家好！ 您的构建中是否有 ANT？ 开玩笑！ 其实我不是。 同意这听起来很怪异，但不要害怕，因为我在这里！ （现在，这就是我所说的，押韵。）
今天，让我们考虑一下这个Apache ANT到底是什么，以及为什么它将它作为WebDriver框架构建中的重要构建块。 到本文结束时，您一般应该可以处理任何ANT项目。
今天，让我们考虑一下这个 Apache ANT 到底是什么，以及为什么它将它作为 WebDriver 框架构建中的重要构建块。 到本文结束时，您一般应该可以处理任何 ANT 项目。
*<u>跳入：</u>*
由Apache Software Foundation提供的**和 **N** 的 **T** 工具是用 **Java** 编写的**构建工具**。 它已经很老了（Maven在这个领域赢得了胜利，Gradle在相处中），非常受欢迎，并且在大多数项目中仍然可以找到。 Apache ANT的优点在于，它仅执行被告知要做的事情。 引擎盖下没有太多魔术发生。 *（请注意，有时这可能是一把双刃剑！）***
由 Apache Software Foundation 提供的**和 **N** 的 **T** 工具是用 **Java** 编写的**构建工具**。 它已经很老了（Maven 在这个领域赢得了胜利，Gradle 在相处中），非常受欢迎，并且在大多数项目中仍然可以找到。 Apache ANT 的优点在于，它仅执行被告知要做的事情。 引擎盖下没有太多魔术发生。 *（请注意，有时这可能是一把双刃剑！）***
创建可执行文件意味着
* 在src文件夹下编译所需的.java文件
* 为JAR创建清单文件
* 将所有.class文件和清单文件一起压缩
* 使用jar命令创建可执行文件
* 在 src 文件夹下编译所需的.java 文件
* 为 JAR 创建清单文件
* 将所有.class 文件和清单文件一起压缩
* 使用 jar 命令创建可执行文件
但是，使用Apache ANT可以通过简单的 **Target** 处理所有这些步骤（我们将在一分钟内看到Target是什么！）。
但是，使用 Apache ANT 可以通过简单的 **Target** 处理所有这些步骤（我们将在一分钟内看到 Target 是什么！）。
要完成的所有工作都以结构化和模块化的方式在XML文件中指定，从而很容易识别是否有问题。 这个文件被称为著名的“ **build.xml** ”。
要完成的所有工作都以结构化和模块化的方式在 XML 文件中指定，从而很容易识别是否有问题。 这个文件被称为著名的“ **build.xml** ”。
Apache ANT带有一个名为build.xml的默认构建文件。 我们总是可以编辑或创建一个新的XML文件来满足我们的需求。 这基本上是**命令行工具**。 因此，使用命令“ ant build_file_name.xml”从命令提示符运行Apache ANT非常容易。 最好的部分是，如果您没有重命名build.xml（只需修改提供的默认值或创建您自己的名称并将其命名为build.xml），那么只有命令“ ant”会自动知道要查找构建。 xml并执行它的作用！
Apache ANT 带有一个名为 build.xml 的默认构建文件。 我们总是可以编辑或创建一个新的 XML 文件来满足我们的需求。 这基本上是**命令行工具**。 因此，使用命令“ ant build_file_name.xml”从命令提示符运行 Apache ANT 非常容易。 最好的部分是，如果您没有重命名 build.xml（只需修改提供的默认值或创建您自己的名称并将其命名为 build.xml），那么只有命令“ ant”会自动知道要查找构建。 xml 并执行它的作用！
Apache ANT具有强大的功能，足以超越“谢谢”的门槛！ 我们可以，
Apache ANT 具有强大的功能，足以超越“谢谢”的门槛！ 我们可以，
* 清理项目
* 编译源代码
* 生成可分发的JAR或WAR
* 处理来自版本控制系统（例如CVS，SVN等）的代码
* 生成可分发的 JAR 或 WAR
* 处理来自版本控制系统（例如 CVS，SVN 等）的代码
* 向指定级别的记录器和侦听器回显消息（错误，警告，信息，详细信息，调试信息）
* 创建或删除目录
* 复制，移动，删除文件
* 可以压缩，解压缩，tar，untar，unjar，unwar文件
* 执行JUnit测试，测试脚本等。
* 通过JDBC对数据库执行一系列SQL语句
* 生成JUnit测试报告
* 可以压缩，解压缩，tar，untar，unjar，unwar 文件
* 执行 JUnit 测试，测试脚本等。
* 通过 JDBC 对数据库执行一系列 SQL 语句
* 生成 JUnit 测试报告
*还有很多其他事情…*
听起来很吓人，但到目前为止，我刚才提到的每件事都可以通过buildfile来实现。
听起来很吓人，但到目前为止，我刚才提到的每件事都可以通过 buildfile 来实现。
是时候忙于大肆宣传的buildfile的元素了。 这些都是用XML编写的。
是时候忙于大肆宣传的 buildfile 的元素了。 这些都是用 XML 编写的。
***<u>便笺</u>*** **：** *以下信息足以使您熟悉Apache ANT构建文件。 有关深入的知识，请访问Apache ANT用户手册。 （http://ant.apache.org/manual/）*
***<u>便笺</u>*** **：** *以下信息足以使您熟悉 Apache ANT 构建文件。 有关深入的知识，请访问 Apache ANT 用户手册。 （http://ant.apache.org/manual/）*
每个构建文件都有
......@@ -51,8 +51,8 @@ Apache ANT具有强大的功能，足以超越“谢谢”的门槛！ 我们可
2. 目标–执行工作单元的一组任务
3. 任务–可以执行的一段代码
示例build.xml文件如下，
示例 build.xml 文件如下，
![sample build.xml](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20839%20425'%3E%3C/svg%3E)
<noscript><img alt="sample build.xml" class="alignnone size-full wp-image-12640" height="425" src="img/28116bee6867f10c68cb8a7b00821a1e.png" width="839"/><p>让我们一次将构建文件提取一个标签。</p><p><strong>项目</strong>：这具有三个属性。</p><ol><li>名称–项目名称</li><li>default –如果未提供任何内容，则应执行的默认目标</li><li>baseDir –从中计算文件中相对路径的基本目录。 “。” 指执行的当前目录</li></ol><p><strong>目标</strong>：如示例构建文件中所示，一个项目可以具有一个或多个目标。 目标是一组任务。 我们可以选择希望ANT执行的目标，并用逗号分隔它们的名称。 如果未指定目标，则将执行默认目标。</p><p>这里要注意的重要属性是“依赖”。 这指定了它所依赖的目标名称。 例如，编译目标将仅在其依赖的初始化目标执行后执行。 因此，depends属性指定执行目标的顺序。</p><p><strong>任务</strong>：这是一段可以执行的代码。 每个任务可以具有一个或多个属性作为键值对。</p><p>句法：</p><p>&lt; <em>名称</em> <em> attribute1 </em> =” <em> value1 </em>” <em> attribute2 </em> =” <em> value2 </em>”…/ &gt;</p><p><em>名称</em>是任务的名称，<em>属性N </em>和<em> valueN </em>分别是属性名称和值名称。</p><p>这是现成的<a href="https://ant.apache.org/manual/tasklist.html">内置任务</a>的长长列表。 我们也可以编写自己的任务。 （还记得吗？都是用Java编写的）。</p><p>您一定想知道，为什么要深入研究构建文件，而不是立即安装并开始执行操作！ 传递这么多ANT知识是有原因的。 随着我们在旅途中的进一步发展，您将对此表示赞赏。 请稍等...</p><p>现在开始营业！</p><p><strong>步骤1 </strong>：转到“ https://ant.apache.org/bindownload.cgi”，然后单击“ apache-ant-1.10.2-bin.zip”以在下面下载.zip文件 “蚂蚁的当前版本”。</p><p><img alt="Download link" class="alignnone size-full wp-image-12641" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/1_downloadLink.jpg" height="98" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20572%2098'%3E%3C/svg%3E" width="572"/></p><noscript><img alt="Download link" class="alignnone size-full wp-image-12641" height="98" src="img/14970a7f07b1ccaa7596be317ad9fa33.png" width="572"/><p><strong>步骤2：</strong>下载.zip存档后，将所有文件提取到本地计算机上的目录中。</p><p><strong>步骤3 </strong>：如下设置环境变量ANT_HOME和Path，</p><p>右键点击“计算机”-&gt;属性-&gt;高级系统设置-&gt;“高级”标签-&gt;环境变量-&gt;在系统变量下单击“新建”。</p><p>ANT_HOME设置为提取Apache ANT文件的文件夹的路径。</p><p><img alt="System variable settings" class="alignnone size-full wp-image-12642" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/2_SystemVariable.jpg" height="162" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20376%20162'%3E%3C/svg%3E" width="376"/></p><noscript><img alt="System variable settings" class="alignnone size-full wp-image-12642" height="162" src="img/ba0bc910e93456af8ef5bbf18bafd97b.png" width="376"/><p>类似地，编辑Path变量以包含％ANT_HOME％\ bin。</p><p><strong>步骤4 </strong>：通过在“命令提示符”中键入以下命令来验证是否已安装Apache ANT</p><p><em>蚂蚁版本</em></p><p><img alt="ANT version check in cmd" class="alignnone size-full wp-image-12643" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/3_CmdVersionCheck.jpg" height="86" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20354%2086'%3E%3C/svg%3E" width="354"/></p><noscript><img alt="ANT version check in cmd" class="alignnone size-full wp-image-12643" height="86" src="img/418f05483293c425772a4636e1d0364c.png" width="354"/><p><strong>步骤5：</strong>下一个任务是打开Eclipse IDE，</p><ul><li>右键单击Java项目-&gt;导出</li><li>在“常规”下，选择“蚂蚁构建文件”，然后点击“下一步”</li><li>确保已选择所需的项目</li><li>取消选中“创建目标以使用Eclipse编译器编译项目”，以删除对Eclipse的任何依赖</li></ul><p><img alt="Generating ANT buildfile" class="alignnone size-full wp-image-12638" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/4_Buildfiles-1.jpg" height="407" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20509%20407'%3E%3C/svg%3E" width="509"/></p><noscript><img alt="Generating ANT buildfile" class="alignnone size-full wp-image-12638" height="407" src="img/f6b7286b63d7900c3782225e686a6833.png" width="509"/><p>单击“完成”以查看自动生成的eclipse文件。</p><p>就是这样！ 您已经准备好将所有项目作为ANT构建运行。 这很简单，不是吗？</p><p><strong> <em>即时贴：</em> </strong> <em> Eclipse与ANT集成在一起。 为了确保Eclipse的“蚂蚁之家”指向最新版本的ANT，请单击Windows-&gt;首选项-&gt; Ant-&gt;运行时。 点击“类路径”标签。 展开“蚂蚁房屋入境”并验证路径。 如果指向的是其他版本，请单击“蚂蚁之家”并浏览用于提取Apache ANT文件的文件夹的位置。 </em></p><p>在我们的下一篇文章中，让我们做到这一点，并在ANT目标的帮助下生成JUnit报告。</p><p>安装愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10b-advanced-webdriver-generating-junit-reports/" title="10b. Advanced WebDriver – Generating JUnit Report"> 10b。 高级WebDriver –生成JUnit报告</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="sample build.xml" class="alignnone size-full wp-image-12640" height="425" src="img/28116bee6867f10c68cb8a7b00821a1e.png" width="839"/><p>让我们一次将构建文件提取一个标签。</p><p><strong>项目</strong>：这具有三个属性。</p><ol><li>名称–项目名称</li><li>default –如果未提供任何内容，则应执行的默认目标</li><li>baseDir –从中计算文件中相对路径的基本目录。 “。” 指执行的当前目录</li></ol><p><strong>目标</strong>：如示例构建文件中所示，一个项目可以具有一个或多个目标。 目标是一组任务。 我们可以选择希望 ANT 执行的目标，并用逗号分隔它们的名称。 如果未指定目标，则将执行默认目标。</p><p>这里要注意的重要属性是“依赖”。 这指定了它所依赖的目标名称。 例如，编译目标将仅在其依赖的初始化目标执行后执行。 因此，depends 属性指定执行目标的顺序。</p><p><strong>任务</strong>：这是一段可以执行的代码。 每个任务可以具有一个或多个属性作为键值对。</p><p>句法：</p><p>&lt; <em>名称</em> <em> attribute1 </em> =” <em> value1 </em>” <em> attribute2 </em> =” <em> value2 </em>”…/ &gt;</p><p><em>名称</em>是任务的名称，<em>属性 N </em>和<em> valueN </em>分别是属性名称和值名称。</p><p>这是现成的<a href="https://ant.apache.org/manual/tasklist.html">内置任务</a>的长长列表。 我们也可以编写自己的任务。 （还记得吗？都是用 Java 编写的）。</p><p>您一定想知道，为什么要深入研究构建文件，而不是立即安装并开始执行操作！ 传递这么多 ANT 知识是有原因的。 随着我们在旅途中的进一步发展，您将对此表示赞赏。 请稍等...</p><p>现在开始营业！</p><p><strong>步骤 1 </strong>：转到“ https://ant.apache.org/bindownload.cgi”，然后单击“ apache-ant-1.10.2-bin.zip”以在下面下载.zip 文件 “蚂蚁的当前版本”。</p><p><img alt="Download link" class="alignnone size-full wp-image-12641" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/1_downloadLink.jpg" height="98" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20572%2098'%3E%3C/svg%3E" width="572"/></p><noscript><img alt="Download link" class="alignnone size-full wp-image-12641" height="98" src="img/14970a7f07b1ccaa7596be317ad9fa33.png" width="572"/><p><strong>步骤 2：</strong>下载.zip 存档后，将所有文件提取到本地计算机上的目录中。</p><p><strong>步骤 3 </strong>：如下设置环境变量 ANT_HOME 和 Path，</p><p>右键点击“计算机”-&gt;属性-&gt;高级系统设置-&gt;“高级”标签-&gt;环境变量-&gt;在系统变量下单击“新建”。</p><p>ANT_HOME 设置为提取 Apache ANT 文件的文件夹的路径。</p><p><img alt="System variable settings" class="alignnone size-full wp-image-12642" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/2_SystemVariable.jpg" height="162" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20376%20162'%3E%3C/svg%3E" width="376"/></p><noscript><img alt="System variable settings" class="alignnone size-full wp-image-12642" height="162" src="img/ba0bc910e93456af8ef5bbf18bafd97b.png" width="376"/><p>类似地，编辑 Path 变量以包含％ANT_HOME％\ bin。</p><p><strong>步骤 4 </strong>：通过在“命令提示符”中键入以下命令来验证是否已安装 Apache ANT</p><p><em>蚂蚁版本</em></p><p><img alt="ANT version check in cmd" class="alignnone size-full wp-image-12643" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/3_CmdVersionCheck.jpg" height="86" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20354%2086'%3E%3C/svg%3E" width="354"/></p><noscript><img alt="ANT version check in cmd" class="alignnone size-full wp-image-12643" height="86" src="img/418f05483293c425772a4636e1d0364c.png" width="354"/><p><strong>步骤 5：</strong>下一个任务是打开 Eclipse IDE，</p><ul><li>右键单击 Java 项目-&gt;导出</li><li>在“常规”下，选择“蚂蚁构建文件”，然后点击“下一步”</li><li>确保已选择所需的项目</li><li>取消选中“创建目标以使用 Eclipse 编译器编译项目”，以删除对 Eclipse 的任何依赖</li></ul><p><img alt="Generating ANT buildfile" class="alignnone size-full wp-image-12638" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/4_Buildfiles-1.jpg" height="407" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20509%20407'%3E%3C/svg%3E" width="509"/></p><noscript><img alt="Generating ANT buildfile" class="alignnone size-full wp-image-12638" height="407" src="img/f6b7286b63d7900c3782225e686a6833.png" width="509"/><p>单击“完成”以查看自动生成的 eclipse 文件。</p><p>就是这样！ 您已经准备好将所有项目作为 ANT 构建运行。 这很简单，不是吗？</p><p><strong> <em>即时贴：</em> </strong> <em> Eclipse 与 ANT 集成在一起。 为了确保 Eclipse 的“蚂蚁之家”指向最新版本的 ANT，请单击 Windows-&gt;首选项-&gt; Ant-&gt;运行时。 点击“类路径”标签。 展开“蚂蚁房屋入境”并验证路径。 如果指向的是其他版本，请单击“蚂蚁之家”并浏览用于提取 Apache ANT 文件的文件夹的位置。 </em></p><p>在我们的下一篇文章中，让我们做到这一点，并在 ANT 目标的帮助下生成 JUnit 报告。</p><p>安装愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10b-advanced-webdriver-generating-junit-reports/" title="10b. Advanced WebDriver – Generating JUnit Report"> 10b。 高级 WebDriver –生成 JUnit 报告</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/132.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/133.md
浏览文件 @ 6bf5daa3
# 10分。 先进的WebDriver – JUnit报表定制
# 10 分。 先进的 WebDriver – JUnit 报表定制
> 原文： [https://javabeginnerstutorial.com/selenium/10c-advanced-webdriver-junit-report-customization/](https://javabeginnerstutorial.com/selenium/10c-advanced-webdriver-junit-report-customization/)
定制！ 谁不喜欢自己作品中的某些独特之处？ 让我们在[上添加一些糖霜，Apache ANT生成的JUnit报告](https://javabeginnerstutorial.com/selenium/10b-advanced-webdriver-generating-junit-reports/)通过引入一些优点使其看起来更漂亮。
定制！ 谁不喜欢自己作品中的某些独特之处？ 让我们在[上添加一些糖霜，Apache ANT 生成的 JUnit 报告](https://javabeginnerstutorial.com/selenium/10b-advanced-webdriver-generating-junit-reports/)通过引入一些优点使其看起来更漂亮。
作为自定义自动生成报告的第一步，让我们了解其背后的代码（来自Build.xml），
作为自定义自动生成报告的第一步，让我们了解其背后的代码（来自 Build.xml），
```java
<junitreport todir="junit">
......@@ -15,15 +15,15 @@
</junitreport>
```
Apache ANT的JunitReport任务通过执行以下步骤来生成报告，
Apache ANT 的 JunitReport 任务通过执行以下步骤来生成报告，
* JUnit任务生成的所有单个XML文件都被合并并命名为TESTS-TestSuites.xml
* CSS样式应用于合并后的文档
* 最终的可浏览报告以HTML格式提供
* JUnit 任务生成的所有单个 XML 文件都被合并并命名为 TESTS-TestSuites.xml
* CSS 样式应用于合并后的文档
* 最终的可浏览报告以 HTML 格式提供
`<junitreport todir="junit">`
属性“ todir”指定了将合并的XML文件保存到的目录。 如果未指定任何内容，则默认为当前目录。
属性“ todir”指定了将合并的 XML 文件保存到的目录。 如果未指定任何内容，则默认为当前目录。
```java
<fileset dir="junit">
......@@ -31,9 +31,9 @@ Apache ANT的JunitReport任务通过执行以下步骤来生成报告，
</fileset>
```
***<u>便笺</u>*** **：** *所有单独的JUnit测试都是通过“ junit” ANT任务执行的，生成的XML文件为 生成的名称使用“ outfile”属性指定。 如果未提及名称，则默认值为“ TEST-name”（其中name是在junit task的name属性中指定的测试名称）。*
***<u>便笺</u>*** **：** *所有单独的 JUnit 测试都是通过“ junit” ANT 任务执行的，生成的 XML 文件为 生成的名称使用“ outfile”属性指定。 如果未提及名称，则默认值为“ TEST-name”（其中 name 是在 junit task 的 name 属性中指定的测试名称）。*
使用<文件集>元素，junitreport会从“ dir”中提到的给定目录中收集所有单个XML文件，并根据上述代码段考虑所有以“ TEST-”开头的文件。
使用<文件集>元素，junitreport 会从“ dir”中提到的给定目录中收集所有单个 XML 文件，并根据上述代码段考虑所有以“ TEST-”开头的文件。
`<report format="frames" todir="junit/report"/>`
......@@ -42,18 +42,18 @@ Apache ANT的JunitReport任务通过执行以下步骤来生成报告，
属性“格式”指定可用于生成报告的两种可用格式之一。 它们必须是“框架”或“无框架”。 如果未指定任何内容，则默认为“帧”格式。 “ todir”属性指定生成的报告必须保存到的目录。
* “ **框架”** 格式将生成一个报告，该报告将包含具有重定向功能的多个文件，并使用样式表来实现此效果。 这是一种更具可读性的格式。
* “ **noframes”** 格式会生成一个名为“ junit-noframes.html”的文件，没有任何框架，并且不使用任何类型的重定向。 这种类型更适合作为电子邮件附件发送或生成pdf文件。
* “ **noframes”** 格式会生成一个名为“ junit-noframes.html”的文件，没有任何框架，并且不使用任何类型的重定向。 这种类型更适合作为电子邮件附件发送或生成 pdf 文件。
既然您已经了解了事物的内在运作方式，那么让我们进入有趣的部分（可能比拥有圣代冰淇淋更有趣）！
与那些无聊的自动生成的报告说再见，并欢迎**定制！** 这意味着，我们将要编写或编辑某些内容。 那就是一个XSL文件，它位于下载的apache-ant-1.10.2-bin.zip的“ etc”目录中。 让我们走简单的路线，就是编辑！
与那些无聊的自动生成的报告说再见，并欢迎**定制！** 这意味着，我们将要编写或编辑某些内容。 那就是一个 XSL 文件，它位于下载的 apache-ant-1.10.2-bin.zip 的“ etc”目录中。 让我们走简单的路线，就是编辑！
还记得吗，我们有两种格式？ 因此，要自定义：
* 框架–编辑junit-frames.xsl
* noframes –编辑junit-noframes.xsl
* 框架–编辑 junit-frames.xsl
* noframes –编辑 junit-noframes.xsl
就我而言，这两个XSL文件都位于“ E：\ apache-ant-1.10.2 \ etc”路径中。 作为本文的一部分，让我们研究“框架”格式。 这意味着我们将编辑“ **junit-frames.xsl** ”文件。 复制此文件并将其粘贴到项目路径中。 不要重命名文件。 为了使所有更改都能正常进行，请向报告任务添加属性**'styledir'**，如下所示。 这指定了定义的样式表junit-frames.xsl的位置。 **“。”** 指定此样式表位于当前目录中（与构建文件的目录相同）。
就我而言，这两个 XSL 文件都位于“ E：\ apache-ant-1.10.2 \ etc”路径中。 作为本文的一部分，让我们研究“框架”格式。 这意味着我们将编辑“ **junit-frames.xsl** ”文件。 复制此文件并将其粘贴到项目路径中。 不要重命名文件。 为了使所有更改都能正常进行，请向报告任务添加属性**'styledir'**，如下所示。 这指定了定义的样式表 junit-frames.xsl 的位置。 **“。”** 指定此样式表位于当前目录中（与构建文件的目录相同）。
`<report styledir="." format="frames" todir="junit/report"/>`
......@@ -69,13 +69,13 @@ Apache ANT的JunitReport任务通过执行以下步骤来生成报告，
* 在标题部分添加徽标
* 修改静态文字
***即时贴：*** *因此，所有更改都是对放置在项目目录“ E：\ Selenium \”（其中Selenium中的“ junit-frames.xsl”）进行的 在我的情况下是项目名称）。*
***即时贴：*** *因此，所有更改都是对放置在项目目录“ E：\ Selenium \”（其中 Selenium 中的“ junit-frames.xsl”）进行的 在我的情况下是项目名称）。*
## **更改报告标题和描述**
在项目位置的“ junit-frames.xsl”样式表中，
1.将参数名称的文本（标题为TITLE）更改为“ JUnit Report”。
1.将参数名称的文本（标题为 TITLE）更改为“ JUnit Report”。
#### 之前的
......@@ -86,7 +86,7 @@ Apache ANT的JunitReport任务通过执行以下步骤来生成报告，
`<!-- <xsl:param name="TITLE">Unit Test Results.</xsl:param> -->
<xsl:param name="TITLE">JUnit Report</xsl:param>`
2.“页眉”部分负责显示标题和右侧显示的说明。 将它们分别更改为“自定义JUnit报告”和“由忍者设计！”。
2.“页眉”部分负责显示标题和右侧显示的说明。 将它们分别更改为“自定义 JUnit 报告”和“由忍者设计！”。
#### *BEFORE*
......@@ -106,4 +106,4 @@ Apache ANT的JunitReport任务通过执行以下步骤来生成报告，
![Before Title Customization](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20718%20340'%3E%3C/svg%3E)
<noscript><img alt="Before Title Customization" class="size-full wp-image-13084 aligncenter" height="340" src="img/105704c5b193643f7f113ac0be161c95.png" width="718"/><h4><em>AFTER</em></h4><pre><code class="language-xml">&lt;xsl:template name="pageHeader"&gt; &lt;!-- &lt;h1&gt;&lt;xsl:value-of select="$TITLE"/&gt;&lt;/h1&gt; --&gt; &lt;h1&gt;Custom JUnit Report&lt;h1&gt; &lt;table width="100%"&gt; &lt;tr&gt; &lt;td align="left"&gt;&lt;/td&gt; &lt;!-- &lt;td align="right"&gt;Designed for use with &lt;a href="http://www.junit.org/"&gt;JUnit&lt;/a&gt; and &lt;a href="http://ant.apache.org/"&gt;Ant&lt;/a&gt;.&lt;/td&gt; --&gt; &lt;td align="right"&gt;Designed by ninjas!&lt;/td&gt; &lt;/tr&gt; &lt;/table&gt; &lt;hr size="1"/&gt; &lt;/xsl:template&gt;</code></pre><p>保存更改并从eclipse生成JUnit报告。</p><p><img alt="Title after customization" class="alignnone size-full wp-image-13085" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/15_CustomTitleAfter-1.jpg" height="336" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20773%20336'%3E%3C/svg%3E" width="773"/></p><noscript><img alt="Title after customization" class="alignnone size-full wp-image-13085" height="336" src="img/79f7da90cc8512a6f3a09a33020e5481.png" width="773"/><h2><strong>增加堆栈跟踪字体大小</strong></h2><p>我们在发生故障时看到的堆栈跟踪信息非常小，很难读取。 为了增加其字体大小，只需在模板中添加几行名称为stylesheet.css的行即可。</p><pre><code class="language-xml">&lt;xsl:template name="stylesheet.css"&gt; .StackTrace { font-size: 100%; }</code></pre><p>然后将该类添加到“ display-failures”模板的“ code”标签中，该模板负责显示堆栈跟踪信息。</p><h4><em>BEFORE</em></h4><pre><code class="language-xml">&lt;code &lt;xsl:call-template name="br-replace"&gt; &lt;xsl:with-param name="word" select="."/&gt; &lt;/xsl:call-template&gt; &lt;/code&gt;</code></pre><p><img alt="Stack trace before customization" class="alignnone size-full wp-image-13086" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/16_CustomStackTraceBefore-1.jpg" height="281" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20704%20281'%3E%3C/svg%3E" width="704"/></p><noscript><img alt="Stack trace before customization" class="alignnone size-full wp-image-13086" height="281" src="img/bb8d2d9cffa6c125da7d189e67916d17.png" width="704"/><h4>之后<i></i></h4><pre><code class="language-xml">&lt;code class="StackTrace"&gt; &lt;xsl:call-template name="br-replace"&gt; &lt;xsl:with-param name="word" select="."/&gt; &lt;/xsl:call-template&gt; &lt;/code&gt;</code></pre><p><img alt="Stack trace after customization" class="alignnone size-full wp-image-13083" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/17_CustomStackTraceAfter-1.jpg" height="308" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20744%20308'%3E%3C/svg%3E" width="744"/></p><noscript><img alt="Stack trace after customization" class="alignnone size-full wp-image-13083" height="308" src="img/aa339356190129736acc86ac3372a513.png" width="744"/><p>现在是时候戴上帽子了。 愿ANT的力量与您同在。</p><p>在另一篇文章中再见。 定制愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10d-advanced-webdriver-junit-report-customization-part2/" title="10d. Advanced WebDriver – JUnit Report Customization Contd."> 10d。 高级WebDriver – JUnit报告自定义续。 </a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Before Title Customization" class="size-full wp-image-13084 aligncenter" height="340" src="img/105704c5b193643f7f113ac0be161c95.png" width="718"/><h4><em>AFTER</em></h4><pre><code class="language-xml">&lt;xsl:template name="pageHeader"&gt; &lt;!-- &lt;h1&gt;&lt;xsl:value-of select="$TITLE"/&gt;&lt;/h1&gt; --&gt; &lt;h1&gt;Custom JUnit Report&lt;h1&gt; &lt;table width="100%"&gt; &lt;tr&gt; &lt;td align="left"&gt;&lt;/td&gt; &lt;!-- &lt;td align="right"&gt;Designed for use with &lt;a href="http://www.junit.org/"&gt;JUnit&lt;/a&gt; and &lt;a href="http://ant.apache.org/"&gt;Ant&lt;/a&gt;.&lt;/td&gt; --&gt; &lt;td align="right"&gt;Designed by ninjas!&lt;/td&gt; &lt;/tr&gt; &lt;/table&gt; &lt;hr size="1"/&gt; &lt;/xsl:template&gt;</code></pre><p>保存更改并从 eclipse 生成 JUnit 报告。</p><p><img alt="Title after customization" class="alignnone size-full wp-image-13085" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/15_CustomTitleAfter-1.jpg" height="336" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20773%20336'%3E%3C/svg%3E" width="773"/></p><noscript><img alt="Title after customization" class="alignnone size-full wp-image-13085" height="336" src="img/79f7da90cc8512a6f3a09a33020e5481.png" width="773"/><h2><strong>增加堆栈跟踪字体大小</strong></h2><p>我们在发生故障时看到的堆栈跟踪信息非常小，很难读取。 为了增加其字体大小，只需在模板中添加几行名称为 stylesheet.css 的行即可。</p><pre><code class="language-xml">&lt;xsl:template name="stylesheet.css"&gt; .StackTrace { font-size: 100%; }</code></pre><p>然后将该类添加到“ display-failures”模板的“ code”标签中，该模板负责显示堆栈跟踪信息。</p><h4><em>BEFORE</em></h4><pre><code class="language-xml">&lt;code &lt;xsl:call-template name="br-replace"&gt; &lt;xsl:with-param name="word" select="."/&gt; &lt;/xsl:call-template&gt; &lt;/code&gt;</code></pre><p><img alt="Stack trace before customization" class="alignnone size-full wp-image-13086" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/16_CustomStackTraceBefore-1.jpg" height="281" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20704%20281'%3E%3C/svg%3E" width="704"/></p><noscript><img alt="Stack trace before customization" class="alignnone size-full wp-image-13086" height="281" src="img/bb8d2d9cffa6c125da7d189e67916d17.png" width="704"/><h4>之后<i></i></h4><pre><code class="language-xml">&lt;code class="StackTrace"&gt; &lt;xsl:call-template name="br-replace"&gt; &lt;xsl:with-param name="word" select="."/&gt; &lt;/xsl:call-template&gt; &lt;/code&gt;</code></pre><p><img alt="Stack trace after customization" class="alignnone size-full wp-image-13083" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/17_CustomStackTraceAfter-1.jpg" height="308" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20744%20308'%3E%3C/svg%3E" width="744"/></p><noscript><img alt="Stack trace after customization" class="alignnone size-full wp-image-13083" height="308" src="img/aa339356190129736acc86ac3372a513.png" width="744"/><p>现在是时候戴上帽子了。 愿 ANT 的力量与您同在。</p><p>在另一篇文章中再见。 定制愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10d-advanced-webdriver-junit-report-customization-part2/" title="10d. Advanced WebDriver – JUnit Report Customization Contd."> 10d。 高级 WebDriver – JUnit 报告自定义续。 </a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/134.md
浏览文件 @ 6bf5daa3
# 10天 高级WebDriver – JUnit报告自定义续。
# 10 天 高级 WebDriver – JUnit 报告自定义续。
> 原文： [https://javabeginnerstutorial.com/selenium/10d-advanced-webdriver-junit-report-customization-part2/](https://javabeginnerstutorial.com/selenium/10d-advanced-webdriver-junit-report-customization-part2/)
......@@ -51,4 +51,4 @@
![Before adding column](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20703%20219'%3E%3C/svg%3E)
<noscript><img alt="Before adding column" class="alignnone size-full wp-image-13133" height="219" src="img/84b0d9a3e774aca418746f37ade3cea2.png" width="703"/><h3>之后<em></em></h3><p><img alt="After adding a column" class="alignnone size-full wp-image-13134" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/19_CustomColAfter-1.jpg" height="226" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20776%20226'%3E%3C/svg%3E" width="776"/></p><noscript><img alt="After adding a column" class="alignnone size-full wp-image-13134" height="226" src="img/e4eeb80cc04eebc2a725bfb1f5fcb85b.png" width="776"/><h2>改变风格</h2><p>努力思考如何更改生成的报告中的样式？ 无需为此费心！ 因为和其他网页一样，我们也有一个CSS样式表来处理此报告的样式。 只需在“ junit-frames.xsl”文件中搜索名称为“ stylesheet.css”的模板即可。</p><pre><code class="language-xml">&lt;!-- this is the stylesheet css to use for nearly everything --&gt; &lt;xsl:template name="stylesheet.css"&gt;</code></pre><p>主体，表，标题，堆栈跟踪，错误，失败，段落，属性的样式均在此模板中指定。 继续前进，戴上帽子！ 对CSS的每一行进行试验，并查看呈现的更改。 是的，您也可以添加自己的CSS！</p><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>让我们来看一个入门的小例子。 表的详细信息和失败样式如下所示，</p><pre><code class="language-xml">table.details tr th{ font-weight: bold; text-align:left; background:#a6caf0; } .Failure { font-weight:bold; color:purple; }</code></pre><p>让我们将这些更改如下：</p><ol><li>所有表格标题均居中对齐</li><li>表格标题行的背景颜色为“绿色黄色”（＃ADFF2F）</li><li>失败文字颜色变为栗色</li></ol><pre><code class="language-xml">table.details tr th{ font-weight: bold; text-align:center; background:#ADFF2F; } .Failure { font-weight:bold; color:maroon; }</code></pre><h3><em>BEFORE</em></h3><p><img alt="Before changing styles" class="alignnone size-full wp-image-13135" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/20_StylesBefore-1.jpg" height="458" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201095%20458'%3E%3C/svg%3E" width="1095"/></p><noscript><img alt="Before changing styles" class="alignnone size-full wp-image-13135" height="458" src="img/27f8f130e1cca67cd5d99f7988b85882.png" width="1095"/><h3><em>AFTER</em></h3><p><img alt="After changing the styles" class="alignnone size-full wp-image-13136" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/21_StylesAfter.jpg" height="437" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201058%20437'%3E%3C/svg%3E" width="1058"/></p><noscript><img alt="After changing the styles" class="alignnone size-full wp-image-13136" height="437" src="img/fe7ac3a7f76a08a05e580ed21c64bea7.png" width="1058"/><p>我知道，它看起来并不吸引眼球，但我们证明了我们想要的。 所以，你去了！</p><h2><strong>在标头部分</strong>中添加徽标</h2><p>我们大多数人都喜欢生成的报告上的徽标。 谁不喜欢个性化和一点营销？ 如果您懂一点HTML，就非常简单。 在名为“ pageHeader”的模板上，添加一个图像标签，并在src属性中指定路径。 我已将徽标图像放置在生成index.html文件的项目的“ junit”文件夹中。</p><pre><code class="language-xml">&lt;xsl:template name="pageHeader"&gt; &lt;!-- &lt;h1&gt;&lt;xsl:value-of select="$TITLE"/&gt;&lt;/h1&gt; --&gt; &lt;h1&gt;Custom JUnit Report&lt;/h1&gt; &lt;table width="100%"&gt; &lt;tr&gt; &lt;td align="left"&gt;&lt;/td&gt; &lt;td align="right"&gt;&lt;img width="50" height="50" alt="Selenium" src="myLogo.jpg"/&gt; Designed by ninjas!&lt;/td&gt; &lt;/tr&gt; &lt;/table&gt; &lt;hr size="1"/&gt; &lt;/xsl:template&gt;</code></pre><h3><em>结果</em></h3><p><img alt="Adding a Logo" class="alignnone size-full wp-image-13137" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/22_Logo.jpg" height="208" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201089%20208'%3E%3C/svg%3E" width="1089"/></p><noscript><img alt="Adding a Logo" class="alignnone size-full wp-image-13137" height="208" src="img/4d78e6dc472ceb1d9f1e11333fc47113.png" width="1089"/><p><strong>修改静态文本</strong></p><p>这是锦上添花（哦！您现在已经知道了）。 要修改报告中显示的任何静态文本，您只需在“ junit-frames.xsl”文件中进行更改。 是的，你没看错。 就这么简单！</p><p>假设在报告的摘要表中，而不是“测试”，我希望它是“测试数量”。 只需在h2标签上显示“摘要”的正文部分更改文本，</p><pre><code class="language-xml">&lt;table class="details" border="0" cellpadding="5" cellspacing="2" width="95%"&gt; &lt;tr valign="top"&gt; &lt;th&gt;Number of Tests&lt;/th&gt; &lt;th&gt;Failures&lt;/th&gt; &lt;th&gt;Errors&lt;/th&gt; &lt;th&gt;Skipped&lt;/th&gt; &lt;th&gt;Success rate&lt;/th&gt; &lt;th&gt;Time&lt;/th&gt; &lt;/tr&gt;</code></pre><h3><em>RESULT</em></h3><p><img alt="Modifying static text" class="alignnone size-full wp-image-13132" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/23_staticText.jpg" height="243" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201028%20243'%3E%3C/svg%3E" width="1028"/></p><noscript><img alt="Modifying static text" class="alignnone size-full wp-image-13132" height="243" src="img/95e2e8910446d894375595f166f57c3f.png" width="1028"/><p>是时候对我们到目前为止所学到的东西进行反思。</p><p>在另一篇文章中再见。 定制愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10e-advanced-webdriver-generating-pdf-report/" title="10e. Advanced WebDriver – Generating a PDF report"> 10e。 Advanced WebDriver –生成PDF报告</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Before adding column" class="alignnone size-full wp-image-13133" height="219" src="img/84b0d9a3e774aca418746f37ade3cea2.png" width="703"/><h3>之后<em></em></h3><p><img alt="After adding a column" class="alignnone size-full wp-image-13134" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/19_CustomColAfter-1.jpg" height="226" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20776%20226'%3E%3C/svg%3E" width="776"/></p><noscript><img alt="After adding a column" class="alignnone size-full wp-image-13134" height="226" src="img/e4eeb80cc04eebc2a725bfb1f5fcb85b.png" width="776"/><h2>改变风格</h2><p>努力思考如何更改生成的报告中的样式？ 无需为此费心！ 因为和其他网页一样，我们也有一个 CSS 样式表来处理此报告的样式。 只需在“ junit-frames.xsl”文件中搜索名称为“ stylesheet.css”的模板即可。</p><pre><code class="language-xml">&lt;!-- this is the stylesheet css to use for nearly everything --&gt; &lt;xsl:template name="stylesheet.css"&gt;</code></pre><p>主体，表，标题，堆栈跟踪，错误，失败，段落，属性的样式均在此模板中指定。 继续前进，戴上帽子！ 对 CSS 的每一行进行试验，并查看呈现的更改。 是的，您也可以添加自己的 CSS！</p><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>让我们来看一个入门的小例子。 表的详细信息和失败样式如下所示，</p><pre><code class="language-xml">table.details tr th{ font-weight: bold; text-align:left; background:#a6caf0; } .Failure { font-weight:bold; color:purple; }</code></pre><p>让我们将这些更改如下：</p><ol><li>所有表格标题均居中对齐</li><li>表格标题行的背景颜色为“绿色黄色”（＃ADFF2F）</li><li>失败文字颜色变为栗色</li></ol><pre><code class="language-xml">table.details tr th{ font-weight: bold; text-align:center; background:#ADFF2F; } .Failure { font-weight:bold; color:maroon; }</code></pre><h3><em>BEFORE</em></h3><p><img alt="Before changing styles" class="alignnone size-full wp-image-13135" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/20_StylesBefore-1.jpg" height="458" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201095%20458'%3E%3C/svg%3E" width="1095"/></p><noscript><img alt="Before changing styles" class="alignnone size-full wp-image-13135" height="458" src="img/27f8f130e1cca67cd5d99f7988b85882.png" width="1095"/><h3><em>AFTER</em></h3><p><img alt="After changing the styles" class="alignnone size-full wp-image-13136" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/21_StylesAfter.jpg" height="437" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201058%20437'%3E%3C/svg%3E" width="1058"/></p><noscript><img alt="After changing the styles" class="alignnone size-full wp-image-13136" height="437" src="img/fe7ac3a7f76a08a05e580ed21c64bea7.png" width="1058"/><p>我知道，它看起来并不吸引眼球，但我们证明了我们想要的。 所以，你去了！</p><h2><strong>在标头部分</strong>中添加徽标</h2><p>我们大多数人都喜欢生成的报告上的徽标。 谁不喜欢个性化和一点营销？ 如果您懂一点 HTML，就非常简单。 在名为“ pageHeader”的模板上，添加一个图像标签，并在 src 属性中指定路径。 我已将徽标图像放置在生成 index.html 文件的项目的“ junit”文件夹中。</p><pre><code class="language-xml">&lt;xsl:template name="pageHeader"&gt; &lt;!-- &lt;h1&gt;&lt;xsl:value-of select="$TITLE"/&gt;&lt;/h1&gt; --&gt; &lt;h1&gt;Custom JUnit Report&lt;/h1&gt; &lt;table width="100%"&gt; &lt;tr&gt; &lt;td align="left"&gt;&lt;/td&gt; &lt;td align="right"&gt;&lt;img width="50" height="50" alt="Selenium" src="myLogo.jpg"/&gt; Designed by ninjas!&lt;/td&gt; &lt;/tr&gt; &lt;/table&gt; &lt;hr size="1"/&gt; &lt;/xsl:template&gt;</code></pre><h3><em>结果</em></h3><p><img alt="Adding a Logo" class="alignnone size-full wp-image-13137" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/22_Logo.jpg" height="208" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201089%20208'%3E%3C/svg%3E" width="1089"/></p><noscript><img alt="Adding a Logo" class="alignnone size-full wp-image-13137" height="208" src="img/4d78e6dc472ceb1d9f1e11333fc47113.png" width="1089"/><p><strong>修改静态文本</strong></p><p>这是锦上添花（哦！您现在已经知道了）。 要修改报告中显示的任何静态文本，您只需在“ junit-frames.xsl”文件中进行更改。 是的，你没看错。 就这么简单！</p><p>假设在报告的摘要表中，而不是“测试”，我希望它是“测试数量”。 只需在 h2 标签上显示“摘要”的正文部分更改文本，</p><pre><code class="language-xml">&lt;table class="details" border="0" cellpadding="5" cellspacing="2" width="95%"&gt; &lt;tr valign="top"&gt; &lt;th&gt;Number of Tests&lt;/th&gt; &lt;th&gt;Failures&lt;/th&gt; &lt;th&gt;Errors&lt;/th&gt; &lt;th&gt;Skipped&lt;/th&gt; &lt;th&gt;Success rate&lt;/th&gt; &lt;th&gt;Time&lt;/th&gt; &lt;/tr&gt;</code></pre><h3><em>RESULT</em></h3><p><img alt="Modifying static text" class="alignnone size-full wp-image-13132" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/23_staticText.jpg" height="243" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201028%20243'%3E%3C/svg%3E" width="1028"/></p><noscript><img alt="Modifying static text" class="alignnone size-full wp-image-13132" height="243" src="img/95e2e8910446d894375595f166f57c3f.png" width="1028"/><p>是时候对我们到目前为止所学到的东西进行反思。</p><p>在另一篇文章中再见。 定制愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10e-advanced-webdriver-generating-pdf-report/" title="10e. Advanced WebDriver – Generating a PDF report"> 10e。 Advanced WebDriver –生成 PDF 报告</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/135.md
浏览文件 @ 6bf5daa3
# 10e。 高级WebDriver –生成PDF报告
# 10e。 高级 WebDriver –生成 PDF 报告
> 原文： [https://javabeginnerstutorial.com/selenium/10e-advanced-webdriver-generating-pdf-report/](https://javabeginnerstutorial.com/selenium/10e-advanced-webdriver-generating-pdf-report/)
嗨冠军！ 到目前为止，我们在报告方面已经涵盖了很多基础，您已经达到了高潮文章。 如果要将HTML报告附加到电子邮件并将其发送给利益相关者，则生成HTML报告可能没有帮助。 由于ANT生成的JUnit报告具有index.html文件，该文件又嵌入了其他一些HTML文件，例如overview-frame.html，所有类-frame.html和overview-summary.html文件。
嗨冠军！ 到目前为止，我们在报告方面已经涵盖了很多基础，您已经达到了高潮文章。 如果要将 HTML 报告附加到电子邮件并将其发送给利益相关者，则生成 HTML 报告可能没有帮助。 由于 ANT 生成的 JUnit 报告具有 index.html 文件，该文件又嵌入了其他一些 HTML 文件，例如 overview-frame.html，所有类-frame.html 和 overview-summary.html 文件。
在这种情况下我们该怎么办？ 我们如何将其附加到电子邮件？ 我们不能将其作为单个文件而不是一组HTML文件获得吗？ –所有这些问题的唯一答案是，生成一个 **PDF文件**。
在这种情况下我们该怎么办？ 我们如何将其附加到电子邮件？ 我们不能将其作为单个文件而不是一组 HTML 文件获得吗？ –所有这些问题的唯一答案是，生成一个 **PDF 文件**。
让我们看看在不干扰我们到目前为止所做的[定制](https://javabeginnerstutorial.com/selenium/10c-advanced-webdriver-junit-report-customization/)的情况下生成PDF报告的过程，
让我们看看在不干扰我们到目前为止所做的[定制](https://javabeginnerstutorial.com/selenium/10c-advanced-webdriver-junit-report-customization/)的情况下生成 PDF 报告的过程，
## **步骤1：**
## **步骤 1：**
我们需要JUnit PDF报告*要点*分发。 它还包含所有必需的依赖项。 从链接“ https://sourceforge.net/projects/junitpdfreport/files/”下载最新版本的“ essentials” zip文件。
我们需要 JUnit PDF 报告*要点*分发。 它还包含所有必需的依赖项。 从链接“ https://sourceforge.net/projects/junitpdfreport/files/”下载最新版本的“ essentials” zip 文件。
![PDF Essentials Download](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20792%20382'%3E%3C/svg%3E)
<noscript><img alt="PDF Essentials Download" class="alignnone size-full wp-image-13353" height="382" sizes="(max-width: 792px) 100vw, 792px" src="img/f3daaf777964f1e44dde697809da3616.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload.jpg 792w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload-300x145.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload-768x370.jpg 768w" width="792"/><p>将文件内容解压缩到本地文件夹并记下路径。 另外，请确保分发中包含“ build-junitpdfreport.xml”文件和“ lib”文件夹以及某些其他文件和文件夹。</p><h2><strong>步骤2：</strong></h2><p>是时候在Eclipse IDE中浏览“ Build.xml”文件了。 有几行要添加。 首先要做的是告诉我们的项目，该junitpdfreport基本zip文件的内容在哪里提取。 在构建文件的&lt;项目&gt;标签中，将以下行及其路径添加到分发位置。</p><pre><code class="language-xml">&lt;!-- JUnit PDF report installation location --&gt; &lt;import file="E:/junitpdfreport_essentials_1_0/build-junitpdfreport.xml"/&gt;</code></pre><h2><strong>步骤3：</strong></h2><p>将以下目标也添加到构建文件中，以便ANT知道该怎么做。</p><pre><code class="language-xml">&lt;!-- PDF Report --&gt; &lt;target name="pdfReport"&gt; &lt;junitpdfreport todir="${junit.output.dir}" styledir="default"&gt; &lt;fileset dir="${junit.output.dir}"&gt; &lt;include name="TEST-*.xml"/&gt; &lt;/fileset&gt; &lt;/junitpdfreport&gt; &lt;/target&gt;</code></pre><p>让我们尝试一次解密这一行，</p><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span> 1\. <code data-enlighter-language="xml">junitpdfreport todir="${junit.output.dir}"</code></p><p>–这是将生成的pdf报告保存的位置。</p><p>2\. <code data-enlighter-language="xml">fileset dir="${junit.output.dir}" </code></p><p>–提供所有JUnit测试结果所在的位置（请记住为执行的每个测试生成的XML文件，格式为“ TEST-*。xml”）。</p><p>就我而言，我有以下测试文件：TEST-com.blog.junitTests.RadioBtns_Checkboxes.xml，TEST-com.blog.junitTests.SelectItems.xml和TESTS-TestSuites.xml保存在位置'junit / '。</p><h2><strong>步骤4：</strong></h2><p>右键单击并选择“ 2 ANT Build”，然后在“编辑配置”弹出窗口中选中“目标”标签。 确保已选中“ pdfReport”目标，它是执行顺序中提到的最后一个目标。</p><p><img alt="PDF target configuration" class="alignnone size-full wp-image-13358" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/24_pdfTargetConfig.jpg" height="521" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20782%20521'%3E%3C/svg%3E" width="782"/></p><noscript><img alt="PDF target configuration" class="alignnone size-full wp-image-13358" height="521" src="img/3afeff61fc34dbc54a4173a3a68f5898.png" width="782"/><p>点击“运行”以执行构建文件。</p><h2><strong>步骤5：</strong></h2><p>在指定的输出目录（本例中为“ junit /”）中验证生成的PDF报告。</p><p><img alt="JUnit Folder" class="alignnone size-full wp-image-13354" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/26_pdfJnitFolder.jpg" height="397" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20461%20397'%3E%3C/svg%3E" width="461"/></p><noscript><img alt="JUnit Folder" class="alignnone size-full wp-image-13354" height="397" src="img/aa7d07ec593be85f4cb61b59a93dfac6.png" width="461"/><p>生成的PDF文件共有8页。 例如，前5页如下所示，</p><p><img alt="PDF report part 1" class="alignnone size-full wp-image-13355" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/27_pdf_Report1.jpg" height="493" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20872%20493'%3E%3C/svg%3E" width="872"/></p><noscript><img alt="PDF report part 1" class="alignnone size-full wp-image-13355" height="493" src="img/355dee55d351b9aac326eded2118a8db.png" width="872"/><p><img alt="PDF Report part 2" class="alignnone size-full wp-image-13356" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/28_pdf_Report2-1.jpg" height="472" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20873%20472'%3E%3C/svg%3E" width="873"/></p><noscript><img alt="PDF Report part 2" class="alignnone size-full wp-image-13356" height="472" src="img/a9d33aeeff32831e2eb61b9318a47817.png" width="873"/><p>最后但并非最不重要的是，该构建文件的快照显示了HTML报告和PDF报告目标代码，</p><p><img alt="ANT buildfile" class="alignnone size-full wp-image-13357" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/29_pdfBuildFile-1.jpg" height="592" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20873%20592'%3E%3C/svg%3E" width="873"/></p><noscript><img alt="ANT buildfile" class="alignnone size-full wp-image-13357" height="592" src="img/42bef927c7f8c0a40ebd7edc15606835.png" width="873"/><p>在您达到本文结尾时，让我们利用练习的力量。 在另一个主题上再见，让您掌握WebDriver！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10f-advanced-webdriver-taking-screenshot/" title="10f. Advanced WebDriver – Taking a Screenshot"> 10f。 高级WebDriver –截屏</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="PDF Essentials Download" class="alignnone size-full wp-image-13353" height="382" sizes="(max-width: 792px) 100vw, 792px" src="img/f3daaf777964f1e44dde697809da3616.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload.jpg 792w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload-300x145.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload-768x370.jpg 768w" width="792"/><p>将文件内容解压缩到本地文件夹并记下路径。 另外，请确保分发中包含“ build-junitpdfreport.xml”文件和“ lib”文件夹以及某些其他文件和文件夹。</p><h2><strong>步骤 2：</strong></h2><p>是时候在 Eclipse IDE 中浏览“ Build.xml”文件了。 有几行要添加。 首先要做的是告诉我们的项目，该 junitpdfreport 基本 zip 文件的内容在哪里提取。 在构建文件的&lt;项目&gt;标签中，将以下行及其路径添加到分发位置。</p><pre><code class="language-xml">&lt;!-- JUnit PDF report installation location --&gt; &lt;import file="E:/junitpdfreport_essentials_1_0/build-junitpdfreport.xml"/&gt;</code></pre><h2><strong>步骤 3：</strong></h2><p>将以下目标也添加到构建文件中，以便 ANT 知道该怎么做。</p><pre><code class="language-xml">&lt;!-- PDF Report --&gt; &lt;target name="pdfReport"&gt; &lt;junitpdfreport todir="${junit.output.dir}" styledir="default"&gt; &lt;fileset dir="${junit.output.dir}"&gt; &lt;include name="TEST-*.xml"/&gt; &lt;/fileset&gt; &lt;/junitpdfreport&gt; &lt;/target&gt;</code></pre><p>让我们尝试一次解密这一行，</p><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span> 1\. <code data-enlighter-language="xml">junitpdfreport todir="${junit.output.dir}"</code></p><p>–这是将生成的 pdf 报告保存的位置。</p><p>2\. <code data-enlighter-language="xml">fileset dir="${junit.output.dir}" </code></p><p>–提供所有 JUnit 测试结果所在的位置（请记住为执行的每个测试生成的 XML 文件，格式为“ TEST-*。xml”）。</p><p>就我而言，我有以下测试文件：TEST-com.blog.junitTests.RadioBtns_Checkboxes.xml，TEST-com.blog.junitTests.SelectItems.xml 和 TESTS-TestSuites.xml 保存在位置'junit / '。</p><h2><strong>步骤 4：</strong></h2><p>右键单击并选择“ 2 ANT Build”，然后在“编辑配置”弹出窗口中选中“目标”标签。 确保已选中“ pdfReport”目标，它是执行顺序中提到的最后一个目标。</p><p><img alt="PDF target configuration" class="alignnone size-full wp-image-13358" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/24_pdfTargetConfig.jpg" height="521" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20782%20521'%3E%3C/svg%3E" width="782"/></p><noscript><img alt="PDF target configuration" class="alignnone size-full wp-image-13358" height="521" src="img/3afeff61fc34dbc54a4173a3a68f5898.png" width="782"/><p>点击“运行”以执行构建文件。</p><h2><strong>步骤 5：</strong></h2><p>在指定的输出目录（本例中为“ junit /”）中验证生成的 PDF 报告。</p><p><img alt="JUnit Folder" class="alignnone size-full wp-image-13354" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/26_pdfJnitFolder.jpg" height="397" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20461%20397'%3E%3C/svg%3E" width="461"/></p><noscript><img alt="JUnit Folder" class="alignnone size-full wp-image-13354" height="397" src="img/aa7d07ec593be85f4cb61b59a93dfac6.png" width="461"/><p>生成的 PDF 文件共有 8 页。 例如，前 5 页如下所示，</p><p><img alt="PDF report part 1" class="alignnone size-full wp-image-13355" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/27_pdf_Report1.jpg" height="493" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20872%20493'%3E%3C/svg%3E" width="872"/></p><noscript><img alt="PDF report part 1" class="alignnone size-full wp-image-13355" height="493" src="img/355dee55d351b9aac326eded2118a8db.png" width="872"/><p><img alt="PDF Report part 2" class="alignnone size-full wp-image-13356" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/28_pdf_Report2-1.jpg" height="472" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20873%20472'%3E%3C/svg%3E" width="873"/></p><noscript><img alt="PDF Report part 2" class="alignnone size-full wp-image-13356" height="472" src="img/a9d33aeeff32831e2eb61b9318a47817.png" width="873"/><p>最后但并非最不重要的是，该构建文件的快照显示了 HTML 报告和 PDF 报告目标代码，</p><p><img alt="ANT buildfile" class="alignnone size-full wp-image-13357" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/29_pdfBuildFile-1.jpg" height="592" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20873%20592'%3E%3C/svg%3E" width="873"/></p><noscript><img alt="ANT buildfile" class="alignnone size-full wp-image-13357" height="592" src="img/42bef927c7f8c0a40ebd7edc15606835.png" width="873"/><p>在您达到本文结尾时，让我们利用练习的力量。 在另一个主题上再见，让您掌握 WebDriver！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10f-advanced-webdriver-taking-screenshot/" title="10f. Advanced WebDriver – Taking a Screenshot"> 10f。 高级 WebDriver –截屏</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/136.md
浏览文件 @ 6bf5daa3
# 10楼 高级WebDriver –截屏
# 10 楼 高级 WebDriver –截屏
> 原文： [https://javabeginnerstutorial.com/selenium/10f-advanced-webdriver-taking-screenshot/](https://javabeginnerstutorial.com/selenium/10f-advanced-webdriver-taking-screenshot/)
嗨冠军！ 屏幕截图。 在软件测试的拥挤街道上，另一个经常听到的术语。 如果您的环境中出现错误，而开发中没有错误，则无法用截图来证明，这是一个好测试！ 因此，现在是时候该了解如何使用Selenium WebDriver来抓取了。
嗨冠军！ 屏幕截图。 在软件测试的拥挤街道上，另一个经常听到的术语。 如果您的环境中出现错误，而开发中没有错误，则无法用截图来证明，这是一个好测试！ 因此，现在是时候该了解如何使用 Selenium WebDriver 来抓取了。
我知道您想到了几个问题。 最重要的是，“如果是手动测试，那么我只要按一下键盘上的' **PrntScr'**按钮，然后抓取一个漂亮的屏幕截图即可。 但是，当我实现自动化时，如何获得相同的结果？”
猜猜看，这很简单！ 只需按照3个步骤进行操作，您就可以使用屏幕截图。 如果您像我一样，可能会急切地想看看它在代码中是如何工作的。 我的目标是取悦，所以请不要再拖延……
猜猜看，这很简单！ 只需按照 3 个步骤进行操作，您就可以使用屏幕截图。 如果您像我一样，可能会急切地想看看它在代码中是如何工作的。 我的目标是取悦，所以请不要再拖延……
## **步骤1：**
## **步骤 1：**
使用Selenium WebDriver提供的“ TakesScreenshot”界面。 将WebDriver对象强制转换为TakesScreenshot类型。
使用 Selenium WebDriver 提供的“ TakesScreenshot”界面。 将 WebDriver 对象强制转换为 TakesScreenshot 类型。
当您在TakesScreenshot下面看到一条弯曲的线时，只需单击`import org.openqa.selenium.TakesScreenshot;`软件包，您将没有任何错误。
当您在 TakesScreenshot 下面看到一条弯曲的线时，只需单击`import org.openqa.selenium.TakesScreenshot;`软件包，您将没有任何错误。
```java
// Cast driver object to TakesScreenshot
TakesScreenshot screenshot = (TakesScreenshot) driver;
```
## 第2步：
## 第 2 步：
要将屏幕截图获取为图像文件，请调用“ getScreenshotAs”方法。
......@@ -35,9 +35,9 @@ import java.io.File;
File src = screenshot.getScreenshotAs(OutputType.FILE);
```
## **步骤3：**
## **步骤 3：**
将生成的图像文件复制到您选择的目标位置。 使用FileUtils类的copyFile方法可以轻松完成此操作。 重要的是要注意，此方法将引发IOException。 因此，作为一种好习惯，请将这段代码包装在try-catch块中。
将生成的图像文件复制到您选择的目标位置。 使用 FileUtils 类的 copyFile 方法可以轻松完成此操作。 重要的是要注意，此方法将引发 IOException。 因此，作为一种好习惯，请将这段代码包装在 try-catch 块中。
线条更弯曲？ - 点击：
......@@ -48,9 +48,9 @@ import java.text.SimpleDateFormat;
import java.util.Date;
```
确保完全按照指定的方式导入软件包。 通常，您可能需要下载org.apache.commons.io jar（在撰写本文时为[下载位置](https://jar-download.com/explore-java-source-code.php?a=commons-io&g=commons-io&v=2.5&downloadable=1)）并将其添加到项目的构建路径中。 之前，我们已经多次看到此过程，因此，我不再重复（请参阅[本文第3步](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)）。
确保完全按照指定的方式导入软件包。 通常，您可能需要下载 org.apache.commons.io jar（在撰写本文时为[下载位置](https://jar-download.com/explore-java-source-code.php?a=commons-io&g=commons-io&v=2.5&downloadable=1)）并将其添加到项目的构建路径中。 之前，我们已经多次看到此过程，因此，我不再重复（请参阅[本文第 3 步](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)）。
另外，请注意，我们在代码中将图像另存为.jpg文件。 也可以将其另存为.png文件。
另外，请注意，我们在代码中将图像另存为.jpg 文件。 也可以将其另存为.png 文件。
它可以很简单，
......@@ -88,17 +88,17 @@ public static String timestamp() {
## 样本场景
1. 打开Firefox浏览器。
2. 导航到Google帐户创建页面
3. 通过ID找到名字文本框
1. 打开 Firefox 浏览器。
2. 导航到 Google 帐户创建页面
3. 通过 ID 找到名字文本框
4. 输入“ fname01”作为名字
5. 按名称找到姓氏文本框
6. 输入“ lname01”作为姓氏
7. 截取页面截图并将其保存到某个位置。
## JUnit代码：
## JUnit 代码：
1. ### SaveScreenshot.java类
1. ### SaveScreenshot.java 类
```java
package com.blog.junitTests;
......@@ -138,7 +138,7 @@ public class SaveScreenshot {
}
```
### 2\. Screenshot.java类（执行示例方案部分中详细介绍的步骤）
### 2\. Screenshot.java 类（执行示例方案部分中详细介绍的步骤）
```java
package com.blog.junitTests;
......@@ -205,4 +205,4 @@ public class ScreenshotTest {
![Eclipse output](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20815%20362'%3E%3C/svg%3E)
<noscript><img alt="Eclipse output" class="alignnone size-full wp-image-13444" height="362" src="img/d9bba1da5599720cb4111735fe851a62.png" width="815"/><p>在Eclipse IDE中，“ JUnit”窗格清楚地显示了测试用例“ <strong> ScreenshotTest.java </strong>”已通过，并且控制台没有错误。</p><p>如代码中所指定，屏幕快照以上述格式的名称保存在“ <strong> E：/ Selenium / screenshots </strong>”路径中。</p><p><img alt="Saved Screenshot" class="alignnone size-full wp-image-13445" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/2_SavedScreenshot-1.jpg" height="257" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20669%20257'%3E%3C/svg%3E" width="669"/></p><noscript><img alt="Saved Screenshot" class="alignnone size-full wp-image-13445" height="257" src="img/a83607c72020b85243e2b2f56815046b.png" width="669"/><p>这是捕获的屏幕截图，</p><p><img alt="Captured Screenshot" class="alignnone size-full wp-image-13443" data-lazy-sizes="(max-width: 1033px) 100vw, 1033px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken.jpg 1033w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-300x170.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-1024x582.jpg 1024w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-768x436.jpg 768w" height="587" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201033%20587'%3E%3C/svg%3E" width="1033"/></p><noscript><img alt="Captured Screenshot" class="alignnone size-full wp-image-13443" height="587" sizes="(max-width: 1033px) 100vw, 1033px" src="img/09ae5e35e176df55907d645952dba8b3.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken.jpg 1033w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-300x170.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-1024x582.jpg 1024w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-768x436.jpg 768w" width="1033"/><p>现在是时候在您的测试过程中实现这一点并为自己可视化魔术了。</p><p>Happy photographing the screen 😉</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10g-advanced-webdriver-saving-screenshots-to-word-document/" title="10g. Advanced WebDriver – Saving screenshots to a word document"> 10克。 高级WebDriver –将屏幕截图保存到Word文档</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Eclipse output" class="alignnone size-full wp-image-13444" height="362" src="img/d9bba1da5599720cb4111735fe851a62.png" width="815"/><p>在 Eclipse IDE 中，“ JUnit”窗格清楚地显示了测试用例“ <strong> ScreenshotTest.java </strong>”已通过，并且控制台没有错误。</p><p>如代码中所指定，屏幕快照以上述格式的名称保存在“ <strong> E：/ Selenium / screenshots </strong>”路径中。</p><p><img alt="Saved Screenshot" class="alignnone size-full wp-image-13445" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/2_SavedScreenshot-1.jpg" height="257" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20669%20257'%3E%3C/svg%3E" width="669"/></p><noscript><img alt="Saved Screenshot" class="alignnone size-full wp-image-13445" height="257" src="img/a83607c72020b85243e2b2f56815046b.png" width="669"/><p>这是捕获的屏幕截图，</p><p><img alt="Captured Screenshot" class="alignnone size-full wp-image-13443" data-lazy-sizes="(max-width: 1033px) 100vw, 1033px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken.jpg 1033w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-300x170.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-1024x582.jpg 1024w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-768x436.jpg 768w" height="587" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201033%20587'%3E%3C/svg%3E" width="1033"/></p><noscript><img alt="Captured Screenshot" class="alignnone size-full wp-image-13443" height="587" sizes="(max-width: 1033px) 100vw, 1033px" src="img/09ae5e35e176df55907d645952dba8b3.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken.jpg 1033w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-300x170.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-1024x582.jpg 1024w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_ScreenshotTaken-768x436.jpg 768w" width="1033"/><p>现在是时候在您的测试过程中实现这一点并为自己可视化魔术了。</p><p>Happy photographing the screen 😉</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10g-advanced-webdriver-saving-screenshots-to-word-document/" title="10g. Advanced WebDriver – Saving screenshots to a word document"> 10 克。 高级 WebDriver –将屏幕截图保存到 Word 文档</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/137.md
浏览文件 @ 6bf5daa3
# 10克 高级WebDriver –将屏幕截图保存到Word文档
# 10 克 高级 WebDriver –将屏幕截图保存到 Word 文档
> 原文： [https://javabeginnerstutorial.com/selenium/10g-advanced-webdriver-saving-screenshots-to-word-document/](https://javabeginnerstutorial.com/selenium/10g-advanced-webdriver-saving-screenshots-to-word-document/)
嗨冠军！ 希望您度过愉快的时光[截屏并将其保存在本地](https://javabeginnerstutorial.com/selenium/10f-advanced-webdriver-taking-screenshot/)。 今天，让我们看看如何创建Word文档，并将在测试用例中捕获的所有图像插入其中。 每个测试用例都有一个单独的文档，不仅可以帮助我们保持工作空间井井有条，而且搜索特定的屏幕快照也很容易。 最好的部分是，我们将编写代码，以便所有这些事情自动发生而无需任何人工干预。
嗨冠军！ 希望您度过愉快的时光[截屏并将其保存在本地](https://javabeginnerstutorial.com/selenium/10f-advanced-webdriver-taking-screenshot/)。 今天，让我们看看如何创建 Word 文档，并将在测试用例中捕获的所有图像插入其中。 每个测试用例都有一个单独的文档，不仅可以帮助我们保持工作空间井井有条，而且搜索特定的屏幕快照也很容易。 最好的部分是，我们将编写代码，以便所有这些事情自动发生而无需任何人工干预。
请允许我直截了当。
## **步骤1：**
## **步骤 1：**
下载几个JAR，使我们的工作更加轻松。
下载几个 JAR，使我们的工作更加轻松。
**java2word-3.3.jar** -帮助我们创建Word文档并以所需方式对其进行操作。
**java2word-3.3.jar** -帮助我们创建 Word 文档并以所需方式对其进行操作。
**xstream-1.3.1.jar** –处理图片
让我们继续从 [https://code.google.com/archive/p/java2word/downloads](https://code.google.com/archive/p/java2word/downloads) （在撰写本文时的下载位置）下载这两个JAR文件。 我还将这些JAR以及本文中处理的所有其他代码文件一起放在我们的 [GitHub存储库](https://github.com/JBTAdmin/Selenium)中。
让我们继续从 [https://code.google.com/archive/p/java2word/downloads](https://code.google.com/archive/p/java2word/downloads) （在撰写本文时的下载位置）下载这两个 JAR 文件。 我还将这些 JAR 以及本文中处理的所有其他代码文件一起放在我们的 [GitHub 存储库](https://github.com/JBTAdmin/Selenium)中。
## **步骤2：**
## **步骤 2：**
将这些JAR添加到我们的项目构建路径中。
将这些 JAR 添加到我们的项目构建路径中。
之前，我们已经多次看到此过程，因此，我不再重复（有关详细说明，请参阅[文章](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)的步骤3）。
之前，我们已经多次看到此过程，因此，我不再重复（有关详细说明，请参阅[文章](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)的步骤 3）。
## **步骤3：**
## **步骤 3：**
创建一个类“ **SaveDocument.java** ”。
......@@ -116,7 +116,7 @@ public class SaveDocument {
* 从网上插入图片（只是为了证明这种情况也是可行的）
* 将单词文档和测试用例的名称保存在特定位置
## **步骤4：**
## **步骤 4：**
对“ **SaveScreenshot.java** ”文件进行了一些修改。
......@@ -157,19 +157,19 @@ public class SaveScreenshot {
## **示例场景**
1. 打开Firefox浏览器。
2. 导航到Google帐户创建页面
3. 通过ID找到名字文本框
1. 打开 Firefox 浏览器。
2. 导航到 Google 帐户创建页面
3. 通过 ID 找到名字文本框
4. 输入“ fname01”作为名字
5. 截取屏幕截图，并将其命名为“ testCaseName” +“ 1”
6. 按名称找到姓氏文本框
7. 输入“ lname01”作为姓氏
8. 截取屏幕截图并将其命名为“ testCaseName” +“ 2”
9. 在指定位置创建一个word文档，并将这两个屏幕截图都插入其中。
9. 在指定位置创建一个 word 文档，并将这两个屏幕截图都插入其中。
### **JUnit代码：**
### **JUnit 代码：**
WordDocWithScreenshotTest.java类
WordDocWithScreenshotTest.java 类
```java
import java.util.concurrent.TimeUnit;
......@@ -237,8 +237,8 @@ public class WordDocWithScreenshotTest {
}
```
如果遵循注释，该代码是不言自明的。 Eclipse的输出如下，
如果遵循注释，该代码是不言自明的。 Eclipse 的输出如下，
![Document Eclipse output](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20810%20377'%3E%3C/svg%3E)
<noscript><img alt="Document Eclipse output" class="alignnone size-full wp-image-13504" height="377" src="img/cfe92b1c436c1f2d0946c238a4c772f1.png" width="810"/><p>在Eclipse IDE中，“ JUnit”窗格清楚地显示了测试用例“ <strong> WordDocWithScreenshotTest.java </strong>”已通过，并且控制台没有错误。 按预期打印“ Word文档创建成功”。</p><p>按照代码中的指定，屏幕快照将以上述格式的名称保存到“ <strong> E：/ Selenium / screenshots </strong>”路径中。</p><p><img alt="Saved screenshots" class="alignnone size-full wp-image-13505" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/5_WordSavedScreenshots-1.jpg" height="239" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20389%20239'%3E%3C/svg%3E" width="389"/></p><noscript><img alt="Saved screenshots" class="alignnone size-full wp-image-13505" height="239" src="img/5c56b0f1090d7f365f904ce1cb7bc6d6.png" width="389"/><p>还将创建单词文档并将其保存在指定的位置“ <strong> E：/ Selenium / </strong>”中。 该文件如下所示，</p><p><img alt="Created Word Document" class="alignnone size-full wp-image-13503" data-lazy-sizes="(max-width: 1005px) 100vw, 1005px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1.jpg 1005w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1-300x185.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1-768x473.jpg 768w" height="619" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201005%20619'%3E%3C/svg%3E" width="1005"/></p><noscript><img alt="Created Word Document" class="alignnone size-full wp-image-13503" height="619" sizes="(max-width: 1005px) 100vw, 1005px" src="img/c0e8c6605f52e31de7ba508ce15d0086.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1.jpg 1005w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1-300x185.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1-768x473.jpg 768w" width="1005"/><p>创建的Word文档，所有代码文件和JAR文件都放置在<a href="https://github.com/JBTAdmin/Selenium"> GitHub存储库</a>中，以便于访问。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读“ README.md”文件以获取明确说明。</p><p>编码愉快！ 祝你今天愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10h-advanced-webdriver-sending-email-with-attachments/" title="10h. Advanced WebDriver – Sending email with attachments"> 10小时。 高级WebDriver –发送带有附件的电子邮件</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Document Eclipse output" class="alignnone size-full wp-image-13504" height="377" src="img/cfe92b1c436c1f2d0946c238a4c772f1.png" width="810"/><p>在 Eclipse IDE 中，“ JUnit”窗格清楚地显示了测试用例“ <strong> WordDocWithScreenshotTest.java </strong>”已通过，并且控制台没有错误。 按预期打印“ Word 文档创建成功”。</p><p>按照代码中的指定，屏幕快照将以上述格式的名称保存到“ <strong> E：/ Selenium / screenshots </strong>”路径中。</p><p><img alt="Saved screenshots" class="alignnone size-full wp-image-13505" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/5_WordSavedScreenshots-1.jpg" height="239" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20389%20239'%3E%3C/svg%3E" width="389"/></p><noscript><img alt="Saved screenshots" class="alignnone size-full wp-image-13505" height="239" src="img/5c56b0f1090d7f365f904ce1cb7bc6d6.png" width="389"/><p>还将创建单词文档并将其保存在指定的位置“ <strong> E：/ Selenium / </strong>”中。 该文件如下所示，</p><p><img alt="Created Word Document" class="alignnone size-full wp-image-13503" data-lazy-sizes="(max-width: 1005px) 100vw, 1005px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1.jpg 1005w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1-300x185.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1-768x473.jpg 768w" height="619" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201005%20619'%3E%3C/svg%3E" width="1005"/></p><noscript><img alt="Created Word Document" class="alignnone size-full wp-image-13503" height="619" sizes="(max-width: 1005px) 100vw, 1005px" src="img/c0e8c6605f52e31de7ba508ce15d0086.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1.jpg 1005w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1-300x185.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/6_WordCreatedDoc-1-768x473.jpg 768w" width="1005"/><p>创建的 Word 文档，所有代码文件和 JAR 文件都放置在<a href="https://github.com/JBTAdmin/Selenium"> GitHub 存储库</a>中，以便于访问。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读“ README.md”文件以获取明确说明。</p><p>编码愉快！ 祝你今天愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10h-advanced-webdriver-sending-email-with-attachments/" title="10h. Advanced WebDriver – Sending email with attachments"> 10 小时。 高级 WebDriver –发送带有附件的电子邮件</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/138.md
浏览文件 @ 6bf5daa3
# 10小时 高级WebDriver –发送带有附件的电子邮件
# 10 小时 高级 WebDriver –发送带有附件的电子邮件
> 原文： [https://javabeginnerstutorial.com/selenium/10h-advanced-webdriver-sending-email-with-attachments/](https://javabeginnerstutorial.com/selenium/10h-advanced-webdriver-sending-email-with-attachments/)
嗨冠军！ 现在我们已经有了 [PDF格式](https://javabeginnerstutorial.com/selenium/10e-advanced-webdriver-generating-pdf-report/)的JUnit报告，让我们将其附加到电子邮件中并发送给各个项目利益相关者。 因此，今天我们主要将仅使用Java。 大家都来一杯咖啡（Java）！
嗨冠军！ 现在我们已经有了 [PDF 格式](https://javabeginnerstutorial.com/selenium/10e-advanced-webdriver-generating-pdf-report/)的 JUnit 报告，让我们将其附加到电子邮件中并发送给各个项目利益相关者。 因此，今天我们主要将仅使用 Java。 大家都来一杯咖啡（Java）！
我们将研究两个课程。
1. SendMail.java –此类包含用于发送电子邮件的所有代码。
2. InvokeMail.java –通过提供从地址到地址，主题行和一些文本来调用SendMail.java。
2. InvokeMail.java –通过提供从地址到地址，主题行和一些文本来调用 SendMail.java。
## **代码**
......@@ -134,16 +134,16 @@ public class InvokeMail {
直接看一下代码会使我们感到难以接受。 让我们一次了解一个摘要。
与往常一样，我们的第一步是下载几个JAR。
与往常一样，我们的第一步是下载几个 JAR。
1. activation.jar
2. javax.mail-1.6.1.jar
我还将它们都放在了我们的 [**GitHub存储库**](https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver/Sending%20Email) 中，以及作为本文一部分处理的所有其他代码文件中。
我还将它们都放在了我们的 [**GitHub 存储库**](https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver/Sending%20Email) 中，以及作为本文一部分处理的所有其他代码文件中。
将这些JAR添加到我们的项目构建路径中。 我们之前已经多次看到此程序，因此我不再重复（有关详细说明，请参阅此[文章](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)的步骤3）。
将这些 JAR 添加到我们的项目构建路径中。 我们之前已经多次看到此程序，因此我不再重复（有关详细说明，请参阅此[文章](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)的步骤 3）。
### **了解SendMail.java，**
### **了解 SendMail.java，**
1.编写所有代码的方法，以便我们可以从任何类轻松地调用它。
......@@ -152,7 +152,7 @@ public static void send(String from, String tos[], String subject,
String text) throws MessagingException {}
```
2.给定的属性仅适用于Gmail。 如果您根据项目要求使用Outlook或任何其他服务，则应相应地进行更改。
2.给定的属性仅适用于 Gmail。 如果您根据项目要求使用 Outlook 或任何其他服务，则应相应地进行更改。
```java
Properties props = new Properties();
......@@ -204,7 +204,7 @@ message.addRecipient(Message.RecipientType.CC,new InternetAddress(cc));
6.要发送，
* 普通短信`message.setText(text);`
* 实际的HTML消息尽可能多`message.setContent("<h1>This is actual message</h1></br></hr>" + text, "text/html");`
* 实际的 HTML 消息尽可能多`message.setContent("<h1>This is actual message</h1></br></hr>" + text, "text/html");`
* 文本和附件（这就是我们想要的），
```java
......@@ -228,17 +228,17 @@ message.setContent(multipart);
Transport.send(message);
```
### **了解InvokeMail.java，**
### **了解 InvokeMail.java，**
此类很容易理解，因为我们只是通过提供所有必需的参数从SendMail.java调用“ send”方法。
此类很容易理解，因为我们只是通过提供所有必需的参数从 SendMail.java 调用“ send”方法。
```java
String to[] = {"[[email protected]](/cdn-cgi/l/email-protection)"};
SendMail.send("[[email protected]](/cdn-cgi/l/email-protection)", to, "JUnit Report", "Check the PDF attachment.");
```
在“运行方式-> Java应用程序”下，Eclipse IDE控制台的输出如下所示，
在“运行方式-> Java 应用程序”下，Eclipse IDE 控制台的输出如下所示，
![Email eclipse console output](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20499%20131'%3E%3C/svg%3E)
<noscript><img alt="Email eclipse console output" class="alignnone size-full wp-image-13546" height="131" src="img/f86911f5f3e724f4f0f756b02cbb24e2.png" width="499"/><p>该电子邮件将在收件人的收件箱中接收。</p><p><img alt="Email received in Inbox" class="alignnone size-full wp-image-13545" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/1_EmailReceivedInbox-1.jpg" height="298" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201282%20298'%3E%3C/svg%3E" width="1282"/></p><noscript><img alt="Email received in Inbox" class="alignnone size-full wp-image-13545" height="298" src="img/dc54350168b4d2d375448a69dcdf1262.png" width="1282"/><p>显示生成的带有附件的电子邮件，以供您参考。</p><p><img alt="Generated email" class="alignnone size-full wp-image-13547" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_GeneratedEmail-1.jpg" height="525" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20917%20525'%3E%3C/svg%3E" width="917"/></p><noscript><img alt="Generated email" class="alignnone size-full wp-image-13547" height="525" src="img/ec66e3d16d437df63174e68a50e156cb.png" width="917"/><p><strong> <em>即时贴：</em> </strong> <em>当心！ 您可能碰到“ <strong> javax.mail.AuthenticationFailedException </strong>”。 发生此异常的主要原因是Google提供的安全性和保护功能。 一种简单的解决方法是，通过单击链接<a href="https://www.google.com/settings/security/lesssecureapps"> https://www.google.com/settings/security/lesssecureapps </a>来打开“允许安全程度较低的应用程序”的访问以进行测试。 </em></p><p>试试看，让我知道在拍摄电子邮件时是否遇到任何问题。</p><p>实验愉快！ 祝你今天愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10i-advanced-webdriver-property-files/" title="10i. Advanced WebDriver – Using property files"> 10i。 高级WebDriver –使用属性文件</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Email eclipse console output" class="alignnone size-full wp-image-13546" height="131" src="img/f86911f5f3e724f4f0f756b02cbb24e2.png" width="499"/><p>该电子邮件将在收件人的收件箱中接收。</p><p><img alt="Email received in Inbox" class="alignnone size-full wp-image-13545" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/1_EmailReceivedInbox-1.jpg" height="298" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201282%20298'%3E%3C/svg%3E" width="1282"/></p><noscript><img alt="Email received in Inbox" class="alignnone size-full wp-image-13545" height="298" src="img/dc54350168b4d2d375448a69dcdf1262.png" width="1282"/><p>显示生成的带有附件的电子邮件，以供您参考。</p><p><img alt="Generated email" class="alignnone size-full wp-image-13547" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/3_GeneratedEmail-1.jpg" height="525" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20917%20525'%3E%3C/svg%3E" width="917"/></p><noscript><img alt="Generated email" class="alignnone size-full wp-image-13547" height="525" src="img/ec66e3d16d437df63174e68a50e156cb.png" width="917"/><p><strong> <em>即时贴：</em> </strong> <em>当心！ 您可能碰到“ <strong> javax.mail.AuthenticationFailedException </strong>”。 发生此异常的主要原因是 Google 提供的安全性和保护功能。 一种简单的解决方法是，通过单击链接<a href="https://www.google.com/settings/security/lesssecureapps"> https://www.google.com/settings/security/lesssecureapps </a>来打开“允许安全程度较低的应用程序”的访问以进行测试。 </em></p><p>试试看，让我知道在拍摄电子邮件时是否遇到任何问题。</p><p>实验愉快！ 祝你今天愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10i-advanced-webdriver-property-files/" title="10i. Advanced WebDriver – Using property files"> 10i。 高级 WebDriver –使用属性文件</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/139.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/14.md
浏览文件 @ 6bf5daa3
# Java中的数据类型
# Java 中的数据类型
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/data-types-in-java/](https://javabeginnerstutorial.com/core-java-tutorial/data-types-in-java/)
Java是一种静态类型的语言，这意味着必须先声明所有变量，然后才能使用它们。 这意味着变量的名称和类型必须先定义，然后才能在代码中使用。
Java 是一种静态类型的语言，这意味着必须先声明所有变量，然后才能使用它们。 这意味着变量的名称和类型必须先定义，然后才能在代码中使用。
```java
boolean bool = true;
```
通过编写上面的行，我们告诉程序创建了一个名为boolean的布尔类型的变量，其默认值为true。
通过编写上面的行，我们告诉程序创建了一个名为 boolean 的布尔类型的变量，其默认值为 true。
Java有8种原始数据类型。
Java 有 8 种原始数据类型。
## 不同的原始数据类型
Java支持以下提到的原始数据类型。
Java 支持以下提到的原始数据类型。
| | 原始类型 | 默认值 | 包装类 |
| | 布尔值 | 假 | 布尔型 |
......@@ -22,9 +22,9 @@ Java支持以下提到的原始数据类型。
| 整体型 | 字节 | （字节）0 | 字节 |
| 短 | （短）0 | 短 |
| 整型 | 0 | 整数 |
| long | 0升 | Long |
| 浮动类型 | 浮动 | 0.0分 | 浮动 |
| 双 | 0.0天 | 双 |
| long | 0 升 | Long |
| 浮动类型 | 浮动 | 0.0 分 | 浮动 |
| 双 | 0.0 天 | 双 |
### 布尔值
......@@ -32,46 +32,46 @@ Java支持以下提到的原始数据类型。
### 烧焦
`char`数据类型是单个16位Unicode字符。 最小值为`'\u0000'`（或0），最大值为`'\uffff'`（或65,535（含））。
`char`数据类型是单个 16 位 Unicode 字符。 最小值为`'\u0000'`（或 0），最大值为`'\uffff'`（或 65,535（含））。
### 字节
字节数据类型用 ***字节*** 关键字声明。 它的最小值可以为-128，最大值可以为127（含）。 默认值为0。如果假定变量在给定范围内包含较小的值，则可以使用字节数据类型代替int。 它有两个目的
字节数据类型用 ***字节*** 关键字声明。 它的最小值可以为-128，最大值可以为 127（含）。 默认值为 0。如果假定变量在给定范围内包含较小的值，则可以使用字节数据类型代替 int。 它有两个目的
* 以字节节省空间是8位有符号整数，比int小4倍
* 以字节节省空间是 8 位有符号整数，比 int 小 4 倍
* 它们的限制有助于澄清您的代码，变量范围有限的事实可以作为文档的一种形式。
### 短
short数据类型可以使用 ***short*** 关键字声明。 short数据类型是16位带符号的二进制补码整数。 其值介于-32,768到32,767（含）之间。 它的默认值为0。当变量的值介于范围之间时，可以使用short数据类型代替int。 如上所述，它将用于两个目的。
short 数据类型可以使用 ***short*** 关键字声明。 short 数据类型是 16 位带符号的二进制补码整数。 其值介于-32,768 到 32,767（含）之间。 它的默认值为 0。当变量的值介于范围之间时，可以使用 short 数据类型代替 int。 如上所述，它将用于两个目的。
### 整型
默认情况下，`int`数据类型是32位**带符号的**（+/-）二进制补码整数，最小值为-2 <sup>31</sup> ，最大值为2 <sup>31</sup> -1。 在Java SE 8和更高版本中，您可以使用int数据类型表示**无符号**（+）32位整数，其最小值为0，最大值为2 <sup>32 [</sup> -1。
默认情况下，`int`数据类型是 32 位**带符号的**（+/-）二进制补码整数，最小值为-2 <sup>31</sup> ，最大值为 2 <sup>31</sup> -1。 在 Java SE 8 和更高版本中，您可以使用 int 数据类型表示**无符号**（+）32 位整数，其最小值为 0，最大值为 2 <sup>32 [</sup> -1。
请注意，即使在Java 8中，int也是带符号的。 但是有些方法将它们视为未签名，但是无法在Java 8或更高版本中声明Unsigned int。
请注意，即使在 Java 8 中，int 也是带符号的。 但是有些方法将它们视为未签名，但是无法在 Java 8 或更高版本中声明 Unsigned int。
尝试打印以下代码以获得int支持的最小值和最大值。 这些值可以分配给变量。
尝试打印以下代码以获得 int 支持的最小值和最大值。 这些值可以分配给变量。
* 整数。 *MAX_VALUE*
* 整数。 *MIN_VALUE*
### long
`long`数据类型是64位二进制补码**整数**。 有符号长号的最小值为-2 <sup>63</sup> ，最大值为2 <sup>63</sup> -1。 用简单的方式，您可以说它是int的增强版本。 当您需要的值范围比`int`提供的值宽时，应使用此数据类型。
`long`数据类型是 64 位二进制补码**整数**。 有符号长号的最小值为-2 <sup>63</sup> ，最大值为 2 <sup>63</sup> -1。 用简单的方式，您可以说它是 int 的增强版本。 当您需要的值范围比`int`提供的值宽时，应使用此数据类型。
在Java 8及更高版本中，您可以使用`long`数据类型表示无符号的64位长，其最小值为0，最大值为2 <sup>64</sup> -1。
在 Java 8 及更高版本中，您可以使用`long`数据类型表示无符号的 64 位长，其最小值为 0，最大值为 2 <sup>64</sup> -1。
请注意，即使在Java 8中，long也是带符号的。 但是，有些方法将它们视为未签名。 `compareUnsigned`和`divideUnsigned`是Long包装器类中的一些方法，支持无符号long的算术运算。 有关[Unsigned Int]或[Long]的更多详细信息，可以在中找到[。](https://blogs.oracle.com/darcy/unsigned-integer-arithmetic-api-now-in-jdk-8)
请注意，即使在 Java 8 中，long 也是带符号的。 但是，有些方法将它们视为未签名。 `compareUnsigned`和`divideUnsigned`是 Long 包装器类中的一些方法，支持无符号 long 的算术运算。 有关[Unsigned Int]或[Long]的更多详细信息，可以在中找到[。](https://blogs.oracle.com/darcy/unsigned-integer-arithmetic-api-now-in-jdk-8)
### 浮动
float数据类型是单精度（32位）IEEE 754浮点。 当您需要小数部分但不需要很高的精度时，float类型的变量很有用。 在单精度中，小数部分使用23位。 此数据类型可用于常规的日常计算。
float 数据类型是单精度（32 位）IEEE 754 浮点。 当您需要小数部分但不需要很高的精度时，float 类型的变量很有用。 在单精度中，小数部分使用 23 位。 此数据类型可用于常规的日常计算。
### 双
`double`数据类型是双精度（64位）IEEE 754浮点数。 它是浮点数，精度更高。 在双精度中，小数部分使用52位。 由于双精度比单精度需要更多的内存，因此不建议将其用于正常计算。 它主要用于科学计算。
`double`数据类型是双精度（64 位）IEEE 754 浮点数。 它是浮点数，精度更高。 在双精度中，小数部分使用 52 位。 由于双精度比单精度需要更多的内存，因此不建议将其用于正常计算。 它主要用于科学计算。
###### 下一篇文章
##### [Java 11的新功能](https://javabeginnerstutorial.com/core-java-tutorial/java-11-new-features/ "Java 11 new features")
\ No newline at end of file
##### [Java 11 的新功能](https://javabeginnerstutorial.com/core-java-tutorial/java-11-new-features/ "Java 11 new features")
\ No newline at end of file
docs/140.md
浏览文件 @ 6bf5daa3
# 10j。 高级WebDriver –使用POI从excel读取数据
# 10j。 高级 WebDriver –使用 POI 从 excel 读取数据
> 原文： [https://javabeginnerstutorial.com/selenium/10j-advanced-webdriver-reading-data-from-excel-using-poi/](https://javabeginnerstutorial.com/selenium/10j-advanced-webdriver-reading-data-from-excel-using-poi/)
朋友！ 今天，让我们深入研究excel表并了解如何从中读取数据。 作为自动化和构建自动化框架的一部分，我们倾向于将数据以预定义的格式（通常遵循模板）存储在excel表中。 我们存储的数据主要是测试数据，不同的测试URL，发布特定的参数等。在这种情况下，知道如何在我们的代码中处理excel表就变得非常重要。
朋友！ 今天，让我们深入研究 excel 表并了解如何从中读取数据。 作为自动化和构建自动化框架的一部分，我们倾向于将数据以预定义的格式（通常遵循模板）存储在 excel 表中。 我们存储的数据主要是测试数据，不同的测试 URL，发布特定的参数等。在这种情况下，知道如何在我们的代码中处理 excel 表就变得非常重要。
这将是另一篇纯Java文章。 因此，您该喝一杯咖啡（Java）了！！ 我们将使用POI jar来实现此目的。
这将是另一篇纯 Java 文章。 因此，您该喝一杯咖啡（Java）了！！ 我们将使用 POI jar 来实现此目的。
## **步骤1：**
## **步骤 1：**
与往常一样，我们的第一步是下载所需的POI JAR。 转至 [Apache POI](https://poi.apache.org/download.html#POI-3.17) ，然后下载最新稳定版本的二进制发行版（在撰写本文时，3.17是最新稳定发行版）。 单击该zip文件的二进制版本，重定向到实际的[下载页面](https://www.apache.org/dyn/closer.lua/poi/release/bin/poi-bin-3.17-20170915.zip)。
与往常一样，我们的第一步是下载所需的 POI JAR。 转至 [Apache POI](https://poi.apache.org/download.html#POI-3.17) ，然后下载最新稳定版本的二进制发行版（在撰写本文时，3.17 是最新稳定发行版）。 单击该 zip 文件的二进制版本，重定向到实际的[下载页面](https://www.apache.org/dyn/closer.lua/poi/release/bin/poi-bin-3.17-20170915.zip)。
![POI download link](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20859%20433'%3E%3C/svg%3E)
<noscript><img alt="POI download link" class="alignnone size-full wp-image-13586" height="433" sizes="(max-width: 859px) 100vw, 859px" src="img/66dde6eb58d06604bfe3993478f8010c.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_DownloadLink.jpg 859w, https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_DownloadLink-300x151.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_DownloadLink-768x387.jpg 768w" width="859"/><h2><strong>步骤2：</strong></h2><p>将这些JAR添加到我们的项目构建路径中。 确保选择“ poi-x.xx”，“ ooxml-lib”和“ lib”文件夹下的所有JAR。 我还将这些以及其他所有代码文件都放在了我们的<a href="https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver/Reading%20data%20from%20excel"> GitHub存储库</a>中。</p><p>我们之前已经多次看到这种添加JAR来构建路径过程的内容，因此我没有在重复它（有关详细说明，请参阅此<a href="https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/">文章</a>的步骤3）。</p><h2><strong>步骤3：</strong></h2><p>创建一个新类“ <strong> ExcelOperationsUsingPOI.java </strong>”。 在此类中，让我们有一种从特定位置读取excel文件的特定图纸的方法。</p><ul><li>通过传递您要打开的excel文件的完整文件路径来创建File类的对象-<code data-enlighter-language="java">File file = new File(filePath+"\\"+fileName); </code></li><li>下一步是创建一个<em> FileInputStream </em>对象，以获取excel文件的输入字节-<code data-enlighter-language="java">FileInputStream inputStream = new FileInputStream(file); </code></li><li>创建一个工作簿对象-<code data-enlighter-language="java">Workbook myWorkbook = null; </code></li><li>Excel文件在大多数情况下可以具有两个扩展名。 “ .xls”或“ .xlsx”。 通过使用子字符串方法拆分文件名来找到扩展名，并相应地创建Workbook对象。</li></ul><pre><code class="language-java">//indexOf gives the index of . in the file name //substring method splits the string starting from index of . to the end String fileExtensionName = fileName.substring(fileName.indexOf(".")); //Check condition if the file is xlsx file if(fileExtensionName.equals(".xlsx")){ //If it is xlsx file then create object of XSSFWorkbook class myWorkbook = new XSSFWorkbook(inputStream); } //Check condition if the file is xls file else if(fileExtensionName.equals(".xls")){ //If it is xls file then create object of HSSFWorkbook class myWorkbook = new HSSFWorkbook(inputStream); }</code></pre><ul><li>使用传递的确切工作表名称，可以读取特定工作表-<code data-enlighter-language="java">Sheet mySheet = myWorkbook.getSheet(sheetName); </code></li></ul><p>现在，使用行和列很容易，它们的交点将为我们提供我们希望读取的单元格内容。</p><p>现在让我们来看一下实现到目前为止讨论的全部功能的代码，</p><h3><strong> ExcelOperationsUsingPOI.java </strong></h3><pre><code class="language-java">import java.io.File; import java.io.FileInputStream; import java.io.IOException; import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.xssf.usermodel.XSSFWorkbook; public class ExcelOperationsUsingPOI { public static void readExcel(String filePath,String fileName,String sheetName) throws IOException{ //Create a object of File class to open xlsx file File file = new File(filePath+"\\"+fileName); //Create an object of FileInputStream class to read excel file FileInputStream inputStream = new FileInputStream(file); Workbook myWorkbook = null; //Find the file extension by spliting file name in substring and getting only extension name //indexOf gives the index of . in the file name //substring method splits the string starting from index of . to the end String fileExtensionName = fileName.substring(fileName.indexOf(".")); //Check condition if the file is xlsx file if(fileExtensionName.equals(".xlsx")){ //If it is xlsx file then create object of XSSFWorkbook class myWorkbook = new XSSFWorkbook(inputStream); } //Check condition if the file is xls file else if(fileExtensionName.equals(".xls")){ //If it is xls file then create object of HSSFWorkbook class myWorkbook = new HSSFWorkbook(inputStream); } //Read sheet inside the workbook by its name Sheet mySheet = myWorkbook.getSheet(sheetName); //Find number of rows in excel file int rowCount = mySheet.getLastRowNum()- mySheet.getFirstRowNum(); //Create a loop over all the rows of excel file to read it for (int i = 0; i &lt; rowCount+1; i++) { Row row = mySheet.getRow(i); //Create a loop to print cell values in a row for (int j = 0; j &lt; row.getLastCellNum(); j++) { //Print excel data in console System.out.print(row.getCell(j).getStringCellValue()+"|| "); } System.out.println(); } } }</code></pre><h3><strong> ReadExcelData.java </strong></h3><p>用于调用readExcel方法并传递必需的参数。</p><pre><code class="language-java">import java.io.IOException; import com.blog.utility.ExcelOperationsUsingPOI; public class ReadExcelData { public static void main(String[] args) { try { ExcelOperationsUsingPOI.readExcel("E:\\Selenium", "ReadUsingPOI.xlsx", "Demographics"); } catch (IOException e) { e.printStackTrace(); } } }</code></pre><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad ezoic-adl" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>注释使代码不言自明。 所考虑的Excel工作表中的数据如下所示，</p><p><img alt="Excel Sheet" class="alignnone size-full wp-image-13588" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/3_ExcelSheet.jpg" height="287" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20357%20287'%3E%3C/svg%3E" width="357"/></p><noscript><img alt="Excel Sheet" class="alignnone size-full wp-image-13588" height="287" src="img/86b09846221b07ad4f56bd5bde566b64.png" width="357"/><p>使用我们的代码访问此信息将按预期方式打印出所有用管道分隔的值，以便将其控制台。</p><p><img alt="excel console output" class="alignnone size-full wp-image-13587" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/2_ConsoleOutput.jpg" height="177" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20450%20177'%3E%3C/svg%3E" width="450"/></p><noscript><img alt="excel console output" class="alignnone size-full wp-image-13587" height="177" src="img/afeb40dbbf98d4b1f60208d231d21f9c.png" width="450"/><p>如果您想检索代码段，请在注释部分大声疾呼，</p><ol><li>给定条目的从零开始的行和列索引</li><li>使用给定的从零开始的行和列索引的值</li><li>基于给定条目的列表中的所有行值</li><li>基于给定条目的列表中的所有列值</li></ol><p>试用这些功能，让我知道您是否遇到颠簸。</p><p>祝你今天愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10k-advanced-webdriver-using-log4j-part-1/" title="10k. Advanced WebDriver – Using Log4j Part 1"> 10k。 高级WebDriver –使用Log4j第1部分</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="POI download link" class="alignnone size-full wp-image-13586" height="433" sizes="(max-width: 859px) 100vw, 859px" src="img/66dde6eb58d06604bfe3993478f8010c.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_DownloadLink.jpg 859w, https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_DownloadLink-300x151.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_DownloadLink-768x387.jpg 768w" width="859"/><h2><strong>步骤 2：</strong></h2><p>将这些 JAR 添加到我们的项目构建路径中。 确保选择“ poi-x.xx”，“ ooxml-lib”和“ lib”文件夹下的所有 JAR。 我还将这些以及其他所有代码文件都放在了我们的<a href="https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver/Reading%20data%20from%20excel"> GitHub 存储库</a>中。</p><p>我们之前已经多次看到这种添加 JAR 来构建路径过程的内容，因此我没有在重复它（有关详细说明，请参阅此<a href="https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/">文章</a>的步骤 3）。</p><h2><strong>步骤 3：</strong></h2><p>创建一个新类“ <strong> ExcelOperationsUsingPOI.java </strong>”。 在此类中，让我们有一种从特定位置读取 excel 文件的特定图纸的方法。</p><ul><li>通过传递您要打开的 excel 文件的完整文件路径来创建 File 类的对象-<code data-enlighter-language="java">File file = new File(filePath+"\\"+fileName); </code></li><li>下一步是创建一个<em> FileInputStream </em>对象，以获取 excel 文件的输入字节-<code data-enlighter-language="java">FileInputStream inputStream = new FileInputStream(file); </code></li><li>创建一个工作簿对象-<code data-enlighter-language="java">Workbook myWorkbook = null; </code></li><li>Excel 文件在大多数情况下可以具有两个扩展名。 “ .xls”或“ .xlsx”。 通过使用子字符串方法拆分文件名来找到扩展名，并相应地创建 Workbook 对象。</li></ul><pre><code class="language-java">//indexOf gives the index of . in the file name //substring method splits the string starting from index of . to the end String fileExtensionName = fileName.substring(fileName.indexOf(".")); //Check condition if the file is xlsx file if(fileExtensionName.equals(".xlsx")){ //If it is xlsx file then create object of XSSFWorkbook class myWorkbook = new XSSFWorkbook(inputStream); } //Check condition if the file is xls file else if(fileExtensionName.equals(".xls")){ //If it is xls file then create object of HSSFWorkbook class myWorkbook = new HSSFWorkbook(inputStream); }</code></pre><ul><li>使用传递的确切工作表名称，可以读取特定工作表-<code data-enlighter-language="java">Sheet mySheet = myWorkbook.getSheet(sheetName); </code></li></ul><p>现在，使用行和列很容易，它们的交点将为我们提供我们希望读取的单元格内容。</p><p>现在让我们来看一下实现到目前为止讨论的全部功能的代码，</p><h3><strong> ExcelOperationsUsingPOI.java </strong></h3><pre><code class="language-java">import java.io.File; import java.io.FileInputStream; import java.io.IOException; import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.xssf.usermodel.XSSFWorkbook; public class ExcelOperationsUsingPOI { public static void readExcel(String filePath,String fileName,String sheetName) throws IOException{ //Create a object of File class to open xlsx file File file = new File(filePath+"\\"+fileName); //Create an object of FileInputStream class to read excel file FileInputStream inputStream = new FileInputStream(file); Workbook myWorkbook = null; //Find the file extension by spliting file name in substring and getting only extension name //indexOf gives the index of . in the file name //substring method splits the string starting from index of . to the end String fileExtensionName = fileName.substring(fileName.indexOf(".")); //Check condition if the file is xlsx file if(fileExtensionName.equals(".xlsx")){ //If it is xlsx file then create object of XSSFWorkbook class myWorkbook = new XSSFWorkbook(inputStream); } //Check condition if the file is xls file else if(fileExtensionName.equals(".xls")){ //If it is xls file then create object of HSSFWorkbook class myWorkbook = new HSSFWorkbook(inputStream); } //Read sheet inside the workbook by its name Sheet mySheet = myWorkbook.getSheet(sheetName); //Find number of rows in excel file int rowCount = mySheet.getLastRowNum()- mySheet.getFirstRowNum(); //Create a loop over all the rows of excel file to read it for (int i = 0; i &lt; rowCount+1; i++) { Row row = mySheet.getRow(i); //Create a loop to print cell values in a row for (int j = 0; j &lt; row.getLastCellNum(); j++) { //Print excel data in console System.out.print(row.getCell(j).getStringCellValue()+"|| "); } System.out.println(); } } }</code></pre><h3><strong> ReadExcelData.java </strong></h3><p>用于调用 readExcel 方法并传递必需的参数。</p><pre><code class="language-java">import java.io.IOException; import com.blog.utility.ExcelOperationsUsingPOI; public class ReadExcelData { public static void main(String[] args) { try { ExcelOperationsUsingPOI.readExcel("E:\\Selenium", "ReadUsingPOI.xlsx", "Demographics"); } catch (IOException e) { e.printStackTrace(); } } }</code></pre><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad ezoic-adl" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>注释使代码不言自明。 所考虑的 Excel 工作表中的数据如下所示，</p><p><img alt="Excel Sheet" class="alignnone size-full wp-image-13588" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/3_ExcelSheet.jpg" height="287" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20357%20287'%3E%3C/svg%3E" width="357"/></p><noscript><img alt="Excel Sheet" class="alignnone size-full wp-image-13588" height="287" src="img/86b09846221b07ad4f56bd5bde566b64.png" width="357"/><p>使用我们的代码访问此信息将按预期方式打印出所有用管道分隔的值，以便将其控制台。</p><p><img alt="excel console output" class="alignnone size-full wp-image-13587" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/2_ConsoleOutput.jpg" height="177" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20450%20177'%3E%3C/svg%3E" width="450"/></p><noscript><img alt="excel console output" class="alignnone size-full wp-image-13587" height="177" src="img/afeb40dbbf98d4b1f60208d231d21f9c.png" width="450"/><p>如果您想检索代码段，请在注释部分大声疾呼，</p><ol><li>给定条目的从零开始的行和列索引</li><li>使用给定的从零开始的行和列索引的值</li><li>基于给定条目的列表中的所有行值</li><li>基于给定条目的列表中的所有列值</li></ol><p>试用这些功能，让我知道您是否遇到颠簸。</p><p>祝你今天愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10k-advanced-webdriver-using-log4j-part-1/" title="10k. Advanced WebDriver – Using Log4j Part 1"> 10k。 高级 WebDriver –使用 Log4j 第 1 部分</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/141.md
浏览文件 @ 6bf5daa3
# 10k。 高级WebDriver –使用Log4j第1部分
# 10k。 高级 WebDriver –使用 Log4j 第 1 部分
> 原文： [https://javabeginnerstutorial.com/selenium/10k-advanced-webdriver-using-log4j-part-1/](https://javabeginnerstutorial.com/selenium/10k-advanced-webdriver-using-log4j-part-1/)
现在让我来解释一下使用Apache Log4j记录Selenium的过程！ 因此，事不宜迟，让我们开始吧！
现在让我来解释一下使用 Apache Log4j 记录 Selenium 的过程！ 因此，事不宜迟，让我们开始吧！
## 为什么我们需要首先登录？
......@@ -14,18 +14,18 @@
4. 可以作为以后成功执行的证明，因为它们可以轻松地保存到数据库或带有时间戳的外部文件中
5. 所有这些日志都可以在无需人工干预的情况下生成
现在我们了解了将日志语句插入测试用例的重要性，让我们解读一下Log4j的全部含义。
现在我们了解了将日志语句插入测试用例的重要性，让我们解读一下 Log4j 的全部含义。
## 什么是Log4j
## 什么是 Log4j
1. 1996年开发的基于Java的流行日志记录程序包
2. 根据Apache Software License分发，因此它是开源的
1. 1996 年开发的基于 Java 的流行日志记录程序包
2. 根据 Apache Software License 分发，因此它是开源的
3. 具有各种级别的日志记录–允许我们控制日志输出的数量
4. 一切都可以通过编辑简单的配置文件来控制-无需理会应用程序二进制文件
## Log4j日志级别
## Log4j 日志级别
以下是Log4j附带的内置日志级别。
以下是 Log4j 附带的内置日志级别。
1. **OFF** –关闭登录
2. **致命** –严重错误导致应用终止
......@@ -35,7 +35,7 @@
6. **DEBUG** –最常用的日志级别，提供有关系统流程的详细信息
7. **跟踪**-信息的详细程度最高
## Log4j组件
## Log4j 组件
主要包括三个部分：
......@@ -43,32 +43,32 @@
应用程序中用唯一名称标识的记录器可以有多个。 可以将每个记录器配置为特定级别-调试，信息，错误等。
要求我们创建Logger类的实例并指定日志级别。
要求我们创建 Logger 类的实例并指定日志级别。
2. ### 新增的人
创建Logger实例后，我们必须知道在哪里查看生成的日志。 这就是Appender出现的地方。 它们指定消息要记录到的目的地或输出，例如文件，标准输出或另一台计算机等。一些可用的Appender是FileAppender，RollingFileAppender，ConsoleAppender，SocketAppender等。 可以将同一信息记录到多个输出中，即一个Logger可以有多个Appender。
创建 Logger 实例后，我们必须知道在哪里查看生成的日志。 这就是 Appender 出现的地方。 它们指定消息要记录到的目的地或输出，例如文件，标准输出或另一台计算机等。一些可用的 Appender 是 FileAppender，RollingFileAppender，ConsoleAppender，SocketAppender 等。 可以将同一信息记录到多个输出中，即一个 Logger 可以有多个 Appender。
3. ### 版面
既然我们知道如何生成日志并将其保存到特定的目的地，那么我们可能需要将它们呈现为不同的格式。 每个Appender必须映射到特定布局。 一些常用的布局是
既然我们知道如何生成日志并将其保存到特定的目的地，那么我们可能需要将它们呈现为不同的格式。 每个 Appender 必须映射到特定布局。 一些常用的布局是
* **PatternLayout** –使用模式字符串的一次一行日志文件
* **HTMLLayout** –以HTML格式呈现日志
* **XMLLayout** –生成XML格式
* **HTMLLayout** –以 HTML 格式呈现日志
* **XMLLayout** –生成 XML 格式
## Log4j配置
## Log4j 配置
可以在XML，JSON，YAML或属性文件格式的配置文件中配置这三个组件。 在本文中，我们将看到如何使用属性文件格式定义所有组件和记录消息。
可以在 XML，JSON，YAML 或属性文件格式的配置文件中配置这三个组件。 在本文中，我们将看到如何使用属性文件格式定义所有组件和记录消息。
## 环境设定
在Eclipse IDE中创建一个Java项目，在本例中为“ Selenium”。
在 Eclipse IDE 中创建一个 Java 项目，在本例中为“ Selenium”。
### 步骤1：下载Log4j
### 步骤 1：下载 Log4j
第一步（也是第一步）是从[此处](https://logging.apache.org/log4j/1.2/download.html)下载Apache Log4j JAR。 单击镜像的zip文件格式将导航到一个新页面，其中包含实际的镜像站点详细信息，可从该位置将JAR下载到本地计算机。
第一步（也是第一步）是从[此处](https://logging.apache.org/log4j/1.2/download.html)下载 Apache Log4j JAR。 单击镜像的 zip 文件格式将导航到一个新页面，其中包含实际的镜像站点详细信息，可从该位置将 JAR 下载到本地计算机。
![download Apache Log4j](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20657%20634'%3E%3C/svg%3E)
<noscript><img alt="download Apache Log4j" class="alignnone size-full wp-image-14225" height="634" src="img/4d0bd0a2cc1db2cb7f03718ef5c12931.png" width="657"/><p>将下载文件夹的内容提取到特定位置。</p><h3>步骤2：配置Java构建路径</h3><p>将Log4j JAR作为外部库添加到项目的构建路径。</p><p>让我们导航到本地计算机中提取下载的JAR的路径，并将其添加为外部JAR。</p><p><img alt="JAR selection window" class="alignnone size-full wp-image-14226" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2019/05/2_JarSelection-1.jpg" height="318" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20502%20318'%3E%3C/svg%3E" width="502"/></p><noscript><img alt="JAR selection window" class="alignnone size-full wp-image-14226" height="318" src="img/c027190f02b422719b9633917ff29b9d.png" width="502"/><p>之前，我们已经多次看到此过程，因此，我不再重复（请参阅<a href="https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/">文章</a>的步骤3）。</p><h3>步骤3：建立必要的档案</h3><p>我们将创建3个文件。</p><p><strong> Log4j.properties </strong></p><ul><li>右键单击“ src”文件夹-&gt;新建-&gt;其他-&gt;常规-&gt;文件-&gt;下一页</li><li>提供“文件名”作为“ Log4j.properties”，然后点击“完成”</li></ul><p>结果看起来像这样，</p><p><img alt="Log4j.properties file creation" class="alignnone size-full wp-image-14227" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2019/05/3_property-file-creation.jpg" height="186" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20323%20186'%3E%3C/svg%3E" width="323"/></p><noscript><img alt="Log4j.properties file creation" class="alignnone size-full wp-image-14227" height="186" src="img/e27b7184646bb1e673729341bb77e0f8.png" width="323"/><p>我现在已经忽略了三个额外的程序包，因为我出于编码目的创建了它们。</p><p><strong>日志文件</strong></p><ul><li>右键单击“ src”文件夹-&gt;新建-&gt;其他-&gt;常规-&gt;文件夹-&gt;下一页</li><li>提供“文件夹名称”作为“资源”</li><li>右键点击“资源”文件夹并创建两个文件</li><li>将这些文件命名为“ system.log”和“ test.log”</li></ul><ol><li><strong> system.log </strong> –将具有系统生成的所有日志</li><li><strong> test.log </strong> –将包含由于用户提供的手动命令而生成的所有日志</li></ol><p><img alt="Log files created" class="alignnone size-full wp-image-14228" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2019/05/4_log-files.jpg" height="341" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20275%20341'%3E%3C/svg%3E" width="275"/></p><noscript><img alt="Log files created" class="alignnone size-full wp-image-14228" height="341" src="img/7dbb8f2542d3154b6359132207b4d7b9.png" width="275"/><p>现在，所有环境都已准备就绪，我们可以使用Log4j进行一些实验并生成日志。 与往常一样，将JAR放置在GitHub <a href="https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver">存储库</a>中。 让我们在即将发布的帖子中详细了解这一点。</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10l-advanced-webdriver-using-log4j-part-2/" title="10l. Advanced WebDriver – Using Log4j Part 2"> 10升。 高级WebDriver –使用Log4j第2部分</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="download Apache Log4j" class="alignnone size-full wp-image-14225" height="634" src="img/4d0bd0a2cc1db2cb7f03718ef5c12931.png" width="657"/><p>将下载文件夹的内容提取到特定位置。</p><h3>步骤 2：配置 Java 构建路径</h3><p>将 Log4j JAR 作为外部库添加到项目的构建路径。</p><p>让我们导航到本地计算机中提取下载的 JAR 的路径，并将其添加为外部 JAR。</p><p><img alt="JAR selection window" class="alignnone size-full wp-image-14226" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2019/05/2_JarSelection-1.jpg" height="318" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20502%20318'%3E%3C/svg%3E" width="502"/></p><noscript><img alt="JAR selection window" class="alignnone size-full wp-image-14226" height="318" src="img/c027190f02b422719b9633917ff29b9d.png" width="502"/><p>之前，我们已经多次看到此过程，因此，我不再重复（请参阅<a href="https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/">文章</a>的步骤 3）。</p><h3>步骤 3：建立必要的档案</h3><p>我们将创建 3 个文件。</p><p><strong> Log4j.properties </strong></p><ul><li>右键单击“ src”文件夹-&gt;新建-&gt;其他-&gt;常规-&gt;文件-&gt;下一页</li><li>提供“文件名”作为“ Log4j.properties”，然后点击“完成”</li></ul><p>结果看起来像这样，</p><p><img alt="Log4j.properties file creation" class="alignnone size-full wp-image-14227" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2019/05/3_property-file-creation.jpg" height="186" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20323%20186'%3E%3C/svg%3E" width="323"/></p><noscript><img alt="Log4j.properties file creation" class="alignnone size-full wp-image-14227" height="186" src="img/e27b7184646bb1e673729341bb77e0f8.png" width="323"/><p>我现在已经忽略了三个额外的程序包，因为我出于编码目的创建了它们。</p><p><strong>日志文件</strong></p><ul><li>右键单击“ src”文件夹-&gt;新建-&gt;其他-&gt;常规-&gt;文件夹-&gt;下一页</li><li>提供“文件夹名称”作为“资源”</li><li>右键点击“资源”文件夹并创建两个文件</li><li>将这些文件命名为“ system.log”和“ test.log”</li></ul><ol><li><strong> system.log </strong> –将具有系统生成的所有日志</li><li><strong> test.log </strong> –将包含由于用户提供的手动命令而生成的所有日志</li></ol><p><img alt="Log files created" class="alignnone size-full wp-image-14228" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2019/05/4_log-files.jpg" height="341" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20275%20341'%3E%3C/svg%3E" width="275"/></p><noscript><img alt="Log files created" class="alignnone size-full wp-image-14228" height="341" src="img/7dbb8f2542d3154b6359132207b4d7b9.png" width="275"/><p>现在，所有环境都已准备就绪，我们可以使用 Log4j 进行一些实验并生成日志。 与往常一样，将 JAR 放置在 GitHub <a href="https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver">存储库</a>中。 让我们在即将发布的帖子中详细了解这一点。</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10l-advanced-webdriver-using-log4j-part-2/" title="10l. Advanced WebDriver – Using Log4j Part 2"> 10 升。 高级 WebDriver –使用 Log4j 第 2 部分</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/142.md
浏览文件 @ 6bf5daa3
# 10升 高级WebDriver –使用Log4j第2部分
# 10 升 高级 WebDriver –使用 Log4j 第 2 部分
> 原文： [https://javabeginnerstutorial.com/selenium/10l-advanced-webdriver-using-log4j-part-2/](https://javabeginnerstutorial.com/selenium/10l-advanced-webdriver-using-log4j-part-2/)
这是本文的续篇，'[使用Log4j第1部分](https://javabeginnerstutorial.com/selenium/10k-advanced-webdriver-using-log4j-part-1/)'，因此，我建议您先阅读第1部分，然后再继续进行操作，以掌握发生的情况。
这是本文的续篇，'[使用 Log4j 第 1 部分](https://javabeginnerstutorial.com/selenium/10k-advanced-webdriver-using-log4j-part-1/)'，因此，我建议您先阅读第 1 部分，然后再继续进行操作，以掌握发生的情况。
**场景**
1. 配置Log4j.properties文件，
1. 配置 Log4j.properties 文件，
* 日志级别–调试
* 记录器– rootLogger和SeleniumTestLogger
* 记录器– rootLogger 和 SeleniumTestLogger
* Appender – RollingFileAppender
* 布局– PatternLayout
2. 编写一个JUnit4测试用例“ Log4jTest.java”，
* 开启Chrome浏览器。
2. 编写一个 JUnit4 测试用例“ Log4jTest.java”，
* 开启 Chrome 浏览器。
* 导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
* 为Logger类创建一个实例
* 将“打开硒实践网站”登录到test.log
* 为 Logger 类创建一个实例
* 将“打开硒实践网站”登录到 test.log
* 按名称找到“自行车”复选框，然后单击它
* 记录“选择了自行车复选框”
* 使用cssSelector找到“杂志”单选按钮并选择它
* 使用 cssSelector 找到“杂志”单选按钮并选择它
* 记录“单击了杂志单选按钮”
* 日志“ Log4jTest成功执行”
* 日志“ Log4jTest 成功执行”
3. 校验，
* Eclipse IDE控制台输出屏幕
* JUnit窗格可显示成功结果
* log和test.log文件，并检查日志是否按预期更新
* Eclipse IDE 控制台输出屏幕
* JUnit 窗格可显示成功结果
* log 和 test.log 文件，并检查日志是否按预期更新
现在，我们今天的计划已成问题，让我们开始编写代码。
## 步骤1：配置属性文件
## 步骤 1：配置属性文件
首先，让我们看看Log4j的配置文件 **Log4j.properites** 文件中包含什么代码。
首先，让我们看看 Log4j 的配置文件 **Log4j.properites** 文件中包含什么代码。
```java
#Root logger options
......@@ -60,7 +60,7 @@ log4j.appender.dest.Append=false
1. **rootLogger** –处理系统生成的日志，并将它们输出到 **system.log** 文件，然后
2. **SeleniumTestLogger** –处理由于用户手动插入代码而生成的日志，并输出到 **test.log** 文件
这两个记录器都将具有RollingFileAppender和PatterLayout。
这两个记录器都将具有 RollingFileAppender 和 PatterLayout。
`log4j.rootLogger=debug,file` –日志级别指定为`debug`，`file`用作引用此特定记录器的标识符。
......@@ -68,7 +68,7 @@ log4j.appender.dest.Append=false
`log4j.appender.file.File=E:\\Selenium\\resources\\system.log` – `File`用于指定要保存日志的文件的位置，即目的地。
`log4j.appender.file.maxFileSize=900KB` –一个文件最多可以存储900KB的数据，然后创建一个具有相同名称的新文件。 较旧的文件将作为索引添加到最新的文件。
`log4j.appender.file.maxFileSize=900KB` –一个文件最多可以存储 900KB 的数据，然后创建一个具有相同名称的新文件。 较旧的文件将作为索引添加到最新的文件。
`log4j.appender.file.maxBackupIndex=3` –最多将保存三个文件作为备份。
......@@ -82,10 +82,10 @@ log4j.appender.dest.Append=false
* `dd/MM/yyyy` –日期
* `HH:mm:ss` –执行时间
* `%c` –打印作为参数传递给Logger实例的名称
* `%c` –打印作为参数传递给 Logger 实例的名称
* `%m%n` –日志消息
`log4j.appender.file.Append=false` –将此属性设置为false将创建一个新文件，而不是更新现有文件。
`log4j.appender.file.Append=false` –将此属性设置为 false 将创建一个新文件，而不是更新现有文件。
`log4j.logger.SeleniumTestLogger=DEBUG, dest` –日志级别为`debug`，`dest`是此处使用的标识符。
......@@ -93,7 +93,7 @@ log4j.appender.dest.Append=false
其他属性与我们已经讨论过的相似，因此不言自明。
## 步骤2：编写测试用例
## 步骤 2：编写测试用例
下面是测试用例“ `Log4jTest.java`”，涵盖了开头讨论的场景中列出的所有要求。
......@@ -166,19 +166,19 @@ public class Log4jTest {
`import org.apache.log4j.Logger;` –记录程序包已导入。
`log = Logger.getLogger("SeleniumTestLogger");` –创建一个名为的实例，记录Logger类并传递“ SeleniumTestLogger”作为参数。
`log = Logger.getLogger("SeleniumTestLogger");` –创建一个名为的实例，记录 Logger 类并传递“ SeleniumTestLogger”作为参数。
`log.debug("opening selenium-practice-site");` –此语句将记录在`DEBUG`级别中用双引号引起的消息。
每行代码都给出了清晰的注释，使其易于遵循。 如您所见，调试级别的日志语句插入到测试用例的各个位置。
## 步骤3：验证
## 步骤 3：验证
Eclipse IDE输出屏幕显示，
Eclipse IDE 输出屏幕显示，
* “控制台”没有任何错误，并且
* “ JUnit”窗格，带有绿色栏，显示成功执行测试用例
![JUnit Output](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20635%20318'%3E%3C/svg%3E)
<noscript><img alt="JUnit Output" class="alignnone size-full wp-image-14235" height="318" src="img/3d95ae1c1e99ed4e996edb2f746e0831.png" width="635"/><ul><li>system.log和test.log文件都将按预期方式通过属性文件布局中指定的系统日志和带有时间戳的用户编码日志进行更新。</li></ul><p><img alt="Generated Test.log file" class="alignnone size-full wp-image-14236" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2019/05/6_Test.log-file-1.jpg" height="188" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20608%20188'%3E%3C/svg%3E" width="608"/></p><noscript><img alt="Generated Test.log file" class="alignnone size-full wp-image-14236" height="188" src="img/63ba29fc17dd09ce494e16026d76132f.png" width="608"/><p>代码文件，日志文件和相关的JAR一如既往地放置在<a href="https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver"> GitHub存储库</a>中。 我希望您现在已经了解了如何在Selenium WebDriver自动化的测试用例中利用流行的记录器之一。</p><p>祝你今天愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10m-advanced-webdriver-running-tests-in-headless-mode/" title="10m. Advanced WebDriver – Running tests in headless mode"> 10m。 Advanced WebDriver –以无头模式运行测试</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="JUnit Output" class="alignnone size-full wp-image-14235" height="318" src="img/3d95ae1c1e99ed4e996edb2f746e0831.png" width="635"/><ul><li>system.log 和 test.log 文件都将按预期方式通过属性文件布局中指定的系统日志和带有时间戳的用户编码日志进行更新。</li></ul><p><img alt="Generated Test.log file" class="alignnone size-full wp-image-14236" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2019/05/6_Test.log-file-1.jpg" height="188" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20608%20188'%3E%3C/svg%3E" width="608"/></p><noscript><img alt="Generated Test.log file" class="alignnone size-full wp-image-14236" height="188" src="img/63ba29fc17dd09ce494e16026d76132f.png" width="608"/><p>代码文件，日志文件和相关的 JAR 一如既往地放置在<a href="https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver"> GitHub 存储库</a>中。 我希望您现在已经了解了如何在 Selenium WebDriver 自动化的测试用例中利用流行的记录器之一。</p><p>祝你今天愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10m-advanced-webdriver-running-tests-in-headless-mode/" title="10m. Advanced WebDriver – Running tests in headless mode"> 10m。 Advanced WebDriver –以无头模式运行测试</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/143.md
浏览文件 @ 6bf5daa3
......@@ -6,8 +6,8 @@ I am sure you would have heard of headless by now because Google introduced head
您脑海中可能会出现的第一个问题是，为什么我首先需要一个无头的浏览器？ 我收到你的来信。 不用担心 我有答案并且相信我，这些都是很好的答案。 因此，事不宜迟，以下是您无头的几个原因，
1. 如果您的目标是获得更好的**速度**和**性能，那么**别无所求！ 由于无需为每个测试都启动浏览器UI，从而避免了加载JavaScript，CSS和呈现HTML所需的所有时间，因此测试运行速度更快。
2. 通常，在 **CI（连续集成）管道**中，它需要在没有实际GUI的服务器或Linux OS等系统上运行。 无头模式节省了一天！
1. 如果您的目标是获得更好的**速度**和**性能，那么**别无所求！ 由于无需为每个测试都启动浏览器 UI，从而避免了加载 JavaScript，CSS 和呈现 HTML 所需的所有时间，因此测试运行速度更快。
2. 通常，在 **CI（连续集成）管道**中，它需要在没有实际 GUI 的服务器或 Linux OS 等系统上运行。 无头模式节省了一天！
3. 如果您所有的测试都运行了几个小时怎么办？ 在这种情况下，用户必须从字面上看屏幕，让系统执行其工作，直到所有测试占据整个屏幕为止。 相反，如果以无头模式执行，则用户可以在后台运行测试时继续执行其他任务。
4. 当脚本被开发并且稳定时，并不需要真正看到它们正在运行。 以更快的方式在无头模式下运行它们似乎很有意义。 借助日志，可以执行所需的调试。
5. 并行执行–无头可阻止打开多个浏览器，并让您执行多任务。
......@@ -21,7 +21,7 @@ I am sure you would have heard of headless by now because Google introduced head
话虽如此，让我们看一些工作代码！
Chrome无头模式，
Chrome 无头模式，
```java
import org.openqa.selenium.WebDriver;
......@@ -54,7 +54,7 @@ public class HelloWorld_ChromeHeadless {
}
```
Firefox在无头模式下，
Firefox 在无头模式下，
```java
import org.openqa.selenium.WebDriver;
......
docs/145.md
浏览文件 @ 6bf5daa3
# 1.使用Vue.js的Hello World
# 1.使用 Vue.js 的 Hello World
> 原文： [https://javabeginnerstutorial.com/js/vue-js/1-hello-world-with-vue-js/](https://javabeginnerstutorial.com/js/vue-js/1-hello-world-with-vue-js/)
嗨，摇滚明星（音乐不包括在内）！ 激动地进入Vue.js世界？ 那我们还等什么呢？
嗨，摇滚明星（音乐不包括在内）！ 激动地进入 Vue.js 世界？ 那我们还等什么呢？
*好消息：*入门Vue很简单。
*好消息：*入门 Vue 很简单。
今天让我们保持 ***目标*** 非常简单。 遵循古老的传统，让我们旨在使用Vue在我们的网页上显示消息“ Hello World”。
今天让我们保持 ***目标*** 非常简单。 遵循古老的传统，让我们旨在使用 Vue 在我们的网页上显示消息“ Hello World”。
## **环境设置**
由于我们已决定使一切保持简单，因此为什么不使用 **CDN** ，它基本上是从另一台服务器导入Vue.js的。 在本教程系列的后面，我们将使用Vue CLI和Webpack进行更复杂的设置来捆绑所有文件。 但是就目前而言，为了练习，理解和学习Vue的基础知识，CDN会做。 是的，您也可以将这种简单的设置用于非常小的项目。
由于我们已决定使一切保持简单，因此为什么不使用 **CDN** ，它基本上是从另一台服务器导入 Vue.js 的。 在本教程系列的后面，我们将使用 Vue CLI 和 Webpack 进行更复杂的设置来捆绑所有文件。 但是就目前而言，为了练习，理解和学习 Vue 的基础知识，CDN 会做。 是的，您也可以将这种简单的设置用于非常小的项目。
### **选项1：**
### **选项 1：**
```java
<!-- development version -->
......@@ -21,15 +21,15 @@
<script src="https://cdn.jsdelivr.net/npm/[[email protected]](/cdn-cgi/l/email-protection)"></script>
```
### **选项2：**
### **选项 2：**
Vue也可用于unpkg，
Vue 也可用于 unpkg，
```java
<script src="https://unpkg.com/[[email protected]](/cdn-cgi/l/email-protection)/dist/vue.js"></script>
```
在撰写本文时，最新的版本是2.5.16。 建议在URL中包含特定的版本号。 您可以手动将版本编辑为使用中的最新版本。
在撰写本文时，最新的版本是 2.5.16。 建议在 URL 中包含特定的版本号。 您可以手动将版本编辑为使用中的最新版本。
但是，如果您不想提及该版本并使用最新版本，请继续，
......@@ -40,17 +40,17 @@ Vue也可用于unpkg，
<script src="https://unpkg.com/vue/dist/vue.js"></script>
```
### **选项3：**
### **选项 3：**
您可以[将Vue.js的开发或生产版本](https://vuejs.org/v2/guide/installation.html)下载到本地，并使用HTML文件中的<脚本>标签直接将其包含在内。
您可以[将 Vue.js 的开发或生产版本](https://vuejs.org/v2/guide/installation.html)下载到本地，并使用 HTML 文件中的<脚本>标签直接将其包含在内。
***即时贴：*** *开发版本包含控制台警告，这些警告对于调试非常有用。 而生产版本主要针对大小（通过使用vue.js文件的缩小版本等）和速度进行了优化，这对于在实时环境中发布非常重要。*
***即时贴：*** *开发版本包含控制台警告，这些警告对于调试非常有用。 而生产版本主要针对大小（通过使用 vue.js 文件的缩小版本等）和速度进行了优化，这对于在实时环境中发布非常重要。*
## **初始代码**
我使用Visual Studio Code作为IDE。 您可以使用Sublime Text，WebStorm，Atom，Notepad ++或您选择的任何其他IDE。 **我的建议？** 请选择 [***JS Fiddle***](https://jsfiddle.net/) ]标签。 这仅仅是锦上添花。 最好的部分是，您可以在一个屏幕上查看HTML，CSS，JS和输出。 与必须每次刷新一次以反映更改的浏览器不同，JS小提琴会检测到更改并在“结果”窗格中自动呈现输出。
我使用 Visual Studio Code 作为 IDE。 您可以使用 Sublime Text，WebStorm，Atom，Notepad ++或您选择的任何其他 IDE。 **我的建议？** 请选择 [***JS Fiddle***](https://jsfiddle.net/) ]标签。 这仅仅是锦上添花。 最好的部分是，您可以在一个屏幕上查看 HTML，CSS，JS 和输出。 与必须每次刷新一次以反映更改的浏览器不同，JS 小提琴会检测到更改并在“结果”窗格中自动呈现输出。
使用以下代码创建一个HTML文件“ index.html”，
使用以下代码创建一个 HTML 文件“ index.html”，
```java
<!DOCTYPE html>
......@@ -68,10 +68,10 @@ Vue也可用于unpkg，
</html>
```
代码很简单。 我们给页面命名为“ Hello Vue！”。 以及`<head>`部分中使用带有`<script>`标签的CDN的vue.js的开发版本。 我们正在显示“ Hello World！” `<body>`部分中带有`id=”app”`的`<div>`元素内`<h1>`标签内的消息。
代码很简单。 我们给页面命名为“ Hello Vue！”。 以及`<head>`部分中使用带有`<script>`标签的 CDN 的 vue.js 的开发版本。 我们正在显示“ Hello World！” `<body>`部分中带有`id=”app”`的`<div>`元素内`<h1>`标签内的消息。
Chrome浏览器中的当前输出如下，
Chrome 浏览器中的当前输出如下，
![Initial code set up](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20873%20343'%3E%3C/svg%3E)
<noscript><img alt="Initial code set up" class="alignnone size-full wp-image-13684" height="343" sizes="(max-width: 873px) 100vw, 873px" src="img/48f184397978913cd4dba79a25f463b3.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_InitialCode.jpg 873w, https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_InitialCode-300x118.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_InitialCode-768x302.jpg 768w" width="873"/><p>到目前为止和我在一起？ 好的，我听到您说我们已经渲染了“ Hello World！” 带有<code>&lt;h1&gt;</code>标签，但这与我们使用Vue.js进行显示的最初目标不矛盾吗？ <strong> <em>好问题。 </em> </strong></p><h2><strong>让我们现在回答，</strong></h2><h3><strong>步骤1：创建新的Vue实例</strong></h3><p>我们已经使用<code>&lt;script&gt;</code>标签将Vue.js导入了我们的项目，但这并不能解决问题。 这相当于在我们的工作台上有一台笔记本电脑。 要打开它并完成一些工作，我们必须按下电源按钮。 同样，要在我们的项目中使用Vue，我们必须使用<code>new</code>关键字创建Vue对象的实例。 这个实例是Vue的电源按钮！</p><pre><code class="language-javascript">new Vue();</code></pre><h3><strong>步骤2：传递选项对象</strong></h3><p>仅创建实例只会为Vue供电。 但是我们想对 Vue做更多的<em>。 为此，我们必须将选项或配置对象作为参数传递给刚创建的实例。 此选项对象具有Vue可以识别的一些保留属性，它们被指定为<strong>键值对</strong>。 顾名思义，并非所有属性都是必需的，可以在需要时指定。 通常，它们用于存储数据和执行某些操作。</em></p><p><strong>，例如 </strong>：“ el”，“数据”，“方法”等。</p><pre><code class="language-javascript">new Vue({ options/config object });</code></pre><h3><strong>步骤3：建立与DOM的连接</strong></h3><p>我们希望以某种方式获取对我们希望操纵的一部分HTML代码的控制。 在我们的例子中，它是带有<code>id</code>和“ app”的<code>&lt;div&gt;</code>元素，因此我们可以通过Vue显示消息“ Hello World”。</p><p>为了在Vue实例和DOM的一部分之间建立这种连接，以便可以根据我们的需要对其进行控制，我们有一个名为“ el”的保留属性，该属性转换为<em>元素</em>。 此属性将字符串作为值指定为CSS选择器，即<code>id</code>的“＃”和“。” 对于<code>class</code>。</p><pre><code class="language-javascript">new Vue({ el: "#app" });</code></pre><p>通过此简单的代码行，我们现在将带有<code>id</code>的<code>&lt;div&gt;</code>元素，“ app”及其内容链接到Vue实例。 它们现在<em>不可分割</em>！</p><h3><strong>步骤4：指定我们的数据</strong></h3><p>为了存储我们要在此Vue实例及其链接的DOM中使用的所有数据/信息，我们还有一个保留的属性，称为“数据”。 与“ el”不同，“数据”将对象作为其值。 由于我们要向DOM显示消息“ Hello World”，因此让我们在“数据”对象中将其指定为键值对。</p><pre><code class="language-javascript">new Vue({ el: "#app", data: { message: "Hello World" } });</code></pre><h3><strong>步骤5：将此数据呈现到DOM </strong></h3><p>只需使用如下所示的两个大括号即可将Vue实例的数据对象中指定的值呈现到DOM。 （有关更多信息，请参阅下一篇文章！）</p><pre><code class="language-html">&lt;div id="app"&gt; &lt;h1&gt;{{ message }}&lt;/h1&gt; &lt;/div&gt;</code></pre><p>为了区分上一个输出（没有Vue），使用Vue来显示，请让我们显示“ <strong> Hello World！ </strong>”而不是“ Hello World！”。</p><p><img alt="Vue.js output" class="alignnone size-full wp-image-13685" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/2_FinalOutput.jpg" height="480" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20983%20480'%3E%3C/svg%3E" width="983"/></p><noscript><img alt="Vue.js output" class="alignnone size-full wp-image-13685" height="480" src="img/6db1fd39a9ccc23d42cc746ed9c95ad8.png" width="983"/><p>好极了！ 因此，我们创建了第一个Vue应用程序。 <a href="https://github.com/JBTAdmin/vuejs/tree/master/01_Hello%20World%20with%20Vuejs"> GitHub repo </a>中提供了本文讨论的所有代码。</p><p>祝你有美好的一天！</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/2-template-syntax-reactivity/" title="2\. Template syntax and a glimpse into Reactivity"> 2.模板语法和反应性的一瞥</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Initial code set up" class="alignnone size-full wp-image-13684" height="343" sizes="(max-width: 873px) 100vw, 873px" src="img/48f184397978913cd4dba79a25f463b3.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_InitialCode.jpg 873w, https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_InitialCode-300x118.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/07/1_InitialCode-768x302.jpg 768w" width="873"/><p>到目前为止和我在一起？ 好的，我听到您说我们已经渲染了“ Hello World！” 带有<code>&lt;h1&gt;</code>标签，但这与我们使用 Vue.js 进行显示的最初目标不矛盾吗？ <strong> <em>好问题。 </em> </strong></p><h2><strong>让我们现在回答，</strong></h2><h3><strong>步骤 1：创建新的 Vue 实例</strong></h3><p>我们已经使用<code>&lt;script&gt;</code>标签将 Vue.js 导入了我们的项目，但这并不能解决问题。 这相当于在我们的工作台上有一台笔记本电脑。 要打开它并完成一些工作，我们必须按下电源按钮。 同样，要在我们的项目中使用 Vue，我们必须使用<code>new</code>关键字创建 Vue 对象的实例。 这个实例是 Vue 的电源按钮！</p><pre><code class="language-javascript">new Vue();</code></pre><h3><strong>步骤 2：传递选项对象</strong></h3><p>仅创建实例只会为 Vue 供电。 但是我们想对 Vue 做更多的<em>。 为此，我们必须将选项或配置对象作为参数传递给刚创建的实例。 此选项对象具有 Vue 可以识别的一些保留属性，它们被指定为<strong>键值对</strong>。 顾名思义，并非所有属性都是必需的，可以在需要时指定。 通常，它们用于存储数据和执行某些操作。</em></p><p><strong>，例如 </strong>：“ el”，“数据”，“方法”等。</p><pre><code class="language-javascript">new Vue({ options/config object });</code></pre><h3><strong>步骤 3：建立与 DOM 的连接</strong></h3><p>我们希望以某种方式获取对我们希望操纵的一部分 HTML 代码的控制。 在我们的例子中，它是带有<code>id</code>和“ app”的<code>&lt;div&gt;</code>元素，因此我们可以通过 Vue 显示消息“ Hello World”。</p><p>为了在 Vue 实例和 DOM 的一部分之间建立这种连接，以便可以根据我们的需要对其进行控制，我们有一个名为“ el”的保留属性，该属性转换为<em>元素</em>。 此属性将字符串作为值指定为 CSS 选择器，即<code>id</code>的“＃”和“。” 对于<code>class</code>。</p><pre><code class="language-javascript">new Vue({ el: "#app" });</code></pre><p>通过此简单的代码行，我们现在将带有<code>id</code>的<code>&lt;div&gt;</code>元素，“ app”及其内容链接到 Vue 实例。 它们现在<em>不可分割</em>！</p><h3><strong>步骤 4：指定我们的数据</strong></h3><p>为了存储我们要在此 Vue 实例及其链接的 DOM 中使用的所有数据/信息，我们还有一个保留的属性，称为“数据”。 与“ el”不同，“数据”将对象作为其值。 由于我们要向 DOM 显示消息“ Hello World”，因此让我们在“数据”对象中将其指定为键值对。</p><pre><code class="language-javascript">new Vue({ el: "#app", data: { message: "Hello World" } });</code></pre><h3><strong>步骤 5：将此数据呈现到 DOM </strong></h3><p>只需使用如下所示的两个大括号即可将 Vue 实例的数据对象中指定的值呈现到 DOM。 （有关更多信息，请参阅下一篇文章！）</p><pre><code class="language-html">&lt;div id="app"&gt; &lt;h1&gt;{{ message }}&lt;/h1&gt; &lt;/div&gt;</code></pre><p>为了区分上一个输出（没有 Vue），使用 Vue 来显示，请让我们显示“ <strong> Hello World！ </strong>”而不是“ Hello World！”。</p><p><img alt="Vue.js output" class="alignnone size-full wp-image-13685" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/07/2_FinalOutput.jpg" height="480" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20983%20480'%3E%3C/svg%3E" width="983"/></p><noscript><img alt="Vue.js output" class="alignnone size-full wp-image-13685" height="480" src="img/6db1fd39a9ccc23d42cc746ed9c95ad8.png" width="983"/><p>好极了！ 因此，我们创建了第一个 Vue 应用程序。 <a href="https://github.com/JBTAdmin/vuejs/tree/master/01_Hello%20World%20with%20Vuejs"> GitHub repo </a>中提供了本文讨论的所有代码。</p><p>祝你有美好的一天！</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/2-template-syntax-reactivity/" title="2\. Template syntax and a glimpse into Reactivity"> 2.模板语法和反应性的一瞥</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/146.md
浏览文件 @ 6bf5daa3
......@@ -2,9 +2,9 @@
> 原文： [https://javabeginnerstutorial.com/js/vue-js/2-template-syntax-reactivity/](https://javabeginnerstutorial.com/js/vue-js/2-template-syntax-reactivity/)
嘿! 欢迎阅读关于Vue的另一篇有趣的文章！ 我们不仅要了解模板语法，还可以了解Vue的反应性。 这似乎就像我们之前的文章“ [Hello World with Vue.js](https://javabeginnerstutorial.com/js/vue-js/1-hello-world-with-vue-js/) ”的继续。 因此，请确保您快速浏览一下，以了解我们到目前为止讨论的内容。 请参阅 [GitHub存储库](https://github.com/JBTAdmin/vuejs)中的代码。
嘿! 欢迎阅读关于 Vue 的另一篇有趣的文章！ 我们不仅要了解模板语法，还可以了解 Vue 的反应性。 这似乎就像我们之前的文章“ [Hello World with Vue.js](https://javabeginnerstutorial.com/js/vue-js/1-hello-world-with-vue-js/) ”的继续。 因此，请确保您快速浏览一下，以了解我们到目前为止讨论的内容。 请参阅 [GitHub 存储库](https://github.com/JBTAdmin/vuejs)中的代码。
还记得我们如何在HTML代码中使用两个花括号将数据呈现到DOM吗？ 让我们深入了解它，以了解Vue如何在引擎盖下工作。
还记得我们如何在 HTML 代码中使用两个花括号将数据呈现到 DOM 吗？ 让我们深入了解它，以了解 Vue 如何在引擎盖下工作。
来自“ index.html”的摘录，
......@@ -14,7 +14,7 @@
</div>
```
这个“两个大括号”的意思是“ **模板** **语法**”，可以用它声明性地将数据渲染到DOM。 由于系统是Vue.js的核心，因此这是可能的。 模板语法也称为“胡子语法”。
这个“两个大括号”的意思是“ **模板** **语法**”，可以用它声明性地将数据渲染到 DOM。 由于系统是 Vue.js 的核心，因此这是可能的。 模板语法也称为“胡子语法”。
以下是“ index.js”文件中的代码，
......@@ -27,12 +27,12 @@ var app = new Vue({
});
```
每当遇到模板语法时，Vue都会自动查看其数据属性的对象，并将相应的值呈现给DOM。
每当遇到模板语法时，Vue 都会自动查看其数据属性的对象，并将相应的值呈现给 DOM。
您是否注意到我已将Vue实例分配给变量“ app”？ 下一节将使用它来演示Vue附带的一些反应性！
您是否注意到我已将 Vue 实例分配给变量“ app”？ 下一节将使用它来演示 Vue 附带的一些反应性！
到目前为止的输出是（就像我们在上一篇文章中看到的那样），
![Vue.js output](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20983%20480'%3E%3C/svg%3E)
<noscript><img alt="Vue.js output" class="alignnone size-full wp-image-13685" height="480" src="img/6db1fd39a9ccc23d42cc746ed9c95ad8.png" width="983"/><h2><strong>一窥Vue的反应性</strong></h2><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>如果您认为使用模板语法进行渲染本身很棒，那么就准备惊讶吧！ 因为Vue是<strong>反应性</strong>。</p><p><em>反应性</em>实际是什么意思？ 我们知道，在Vue实例中指定的数据链接到HTML代码中“ el”范围内所引用的任何位置。 Vue不仅<strong>会在被引用的DOM中呈现</strong>数据，而且<strong>每当在数据对象中更改其值时也会更新</strong>。</p><p>很难缠住头吗？ 然后，让我们看到所有这些实时发生的反应。</p><ul><li>在Chrome浏览器中打开DevTools（快捷方式：F12）。</li><li>点击“控制台”。</li><li>记住，我们将整个Vue实例分配给变量“ app”。 因此，要从数据对象访问“消息”，只需键入<code data-enlighter-language="js">app.message = "Hey Vue, what's up?"</code></li><li>并且不要忘记单击“控制台”部分中的“ <strong>输入</strong>”以查看其运行情况。</li></ul><p><img alt="reactivity in action" class="alignnone size-full wp-image-13732" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/3_ReactivityInAction-1.jpg" height="363" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20356%20363'%3E%3C/svg%3E" width="356"/></p><noscript><img alt="reactivity in action" class="alignnone size-full wp-image-13732" height="363" src="img/a5f2cebad59f4377dc2a4483d01e4f09.png" width="356"/><h3><strong> <em>即时贴：</em> </strong></h3><p><em>您也可以这样做<code data-enlighter-language="js">app.$data.message = "Hey Vue, what's up?"</code> </em></p><p><em>，然后单击“ Enter”。 它将正常工作。 在即将发布的系列文章中，我们将回答您在太阳下遇到的每个“为什么”和“如何”问题。 现在，只知道这是访问<code>message</code>属性的另一种方法。 </em></p><p>请记住，可以在多个位置引用数据，并且可以在每个位置自动更新数据。 让我们也尝试一下！</p><p>将<code>index.html</code>文件的<code>&lt;div&gt;</code>部分的代码更新为</p><pre><code class="language-html">&lt;div id="app"&gt; &lt;h1&gt;Hey {{ message }}!&lt;/h1&gt; &lt;hr/&gt; &lt;p&gt;This is my first {{ message }} app.&lt;/p&gt; &lt;p&gt;I successfully understood {{ message }}'s reactivity.&lt;/p&gt; &lt;/div&gt; </code></pre><p>另外，让我们将<code>index.js</code>文件中<code>message</code>属性的值更改为“ Vue”，而不是“ Hello World !!!”。 只是为了使这些句子更有意义。</p><pre><code class="language-javascript">var app = new Vue({ el: "#app", data: { message: "Vue" } });</code></pre><p>现在，让我们看一下输出。</p><p><img alt="Template syntax output" class="alignnone size-full wp-image-13730" data-lazy-sizes="(max-width: 919px) 100vw, 919px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1.jpg 919w, https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1-300x173.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1-768x443.jpg 768w" height="530" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20919%20530'%3E%3C/svg%3E" width="919"/></p><noscript><img alt="Template syntax output" class="alignnone size-full wp-image-13730" height="530" sizes="(max-width: 919px) 100vw, 919px" src="img/f0ca1d3ada6af3aff784a475696db25b.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1.jpg 919w, https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1-300x173.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1-768x443.jpg 768w" width="919"/><p>是时候在多个地方看到一些反应发生了。 和以前一样，让我们​​在Chrome浏览器的DevTools控制台中更改<code>message</code>属性的值。</p><p><img alt="Reactivity at multiple places" class="alignnone size-full wp-image-13731" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/2_MultipleReactivity-1.jpg" height="390" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20421%20390'%3E%3C/svg%3E" width="421"/></p><noscript><img alt="Reactivity at multiple places" class="alignnone size-full wp-image-13731" height="390" src="img/ad819e5f91d3748a6b02ab6da1e50ab5.png" width="421"/><p>当您按下<code>Enter</code>时，在我们的HTML代码中引用<code>message</code>的每个位置都将立即更新为新值“ vue.js”，这就是您现在在DOM中看到的内容。</p><p>这不仅令人惊讶吗？ 是的，这就是我们忙于玩Candy Crush时Vue团队或Evan You所要做的！ 在本系列教程中，我们将看到更多示例，以各种其他方式展示了反应性。</p><p>试想一下，如果您使用香草JavaScript或jQuery实现类似这样的功能，将需要多少编码！</p><p>话虽如此，我请假。 祝您有美好的一天！</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/3-vue-directives/" title="3\. Introduction to Vue directives"> 3\. Vue指令简介</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="Vue.js output" class="alignnone size-full wp-image-13685" height="480" src="img/6db1fd39a9ccc23d42cc746ed9c95ad8.png" width="983"/><h2><strong>一窥 Vue 的反应性</strong></h2><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>如果您认为使用模板语法进行渲染本身很棒，那么就准备惊讶吧！ 因为 Vue 是<strong>反应性</strong>。</p><p><em>反应性</em>实际是什么意思？ 我们知道，在 Vue 实例中指定的数据链接到 HTML 代码中“ el”范围内所引用的任何位置。 Vue 不仅<strong>会在被引用的 DOM 中呈现</strong>数据，而且<strong>每当在数据对象中更改其值时也会更新</strong>。</p><p>很难缠住头吗？ 然后，让我们看到所有这些实时发生的反应。</p><ul><li>在 Chrome 浏览器中打开 DevTools（快捷方式：F12）。</li><li>点击“控制台”。</li><li>记住，我们将整个 Vue 实例分配给变量“ app”。 因此，要从数据对象访问“消息”，只需键入<code data-enlighter-language="js">app.message = "Hey Vue, what's up?"</code></li><li>并且不要忘记单击“控制台”部分中的“ <strong>输入</strong>”以查看其运行情况。</li></ul><p><img alt="reactivity in action" class="alignnone size-full wp-image-13732" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/3_ReactivityInAction-1.jpg" height="363" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20356%20363'%3E%3C/svg%3E" width="356"/></p><noscript><img alt="reactivity in action" class="alignnone size-full wp-image-13732" height="363" src="img/a5f2cebad59f4377dc2a4483d01e4f09.png" width="356"/><h3><strong> <em>即时贴：</em> </strong></h3><p><em>您也可以这样做<code data-enlighter-language="js">app.$data.message = "Hey Vue, what's up?"</code> </em></p><p><em>，然后单击“ Enter”。 它将正常工作。 在即将发布的系列文章中，我们将回答您在太阳下遇到的每个“为什么”和“如何”问题。 现在，只知道这是访问<code>message</code>属性的另一种方法。 </em></p><p>请记住，可以在多个位置引用数据，并且可以在每个位置自动更新数据。 让我们也尝试一下！</p><p>将<code>index.html</code>文件的<code>&lt;div&gt;</code>部分的代码更新为</p><pre><code class="language-html">&lt;div id="app"&gt; &lt;h1&gt;Hey {{ message }}!&lt;/h1&gt; &lt;hr/&gt; &lt;p&gt;This is my first {{ message }} app.&lt;/p&gt; &lt;p&gt;I successfully understood {{ message }}'s reactivity.&lt;/p&gt; &lt;/div&gt; </code></pre><p>另外，让我们将<code>index.js</code>文件中<code>message</code>属性的值更改为“ Vue”，而不是“ Hello World !!!”。 只是为了使这些句子更有意义。</p><pre><code class="language-javascript">var app = new Vue({ el: "#app", data: { message: "Vue" } });</code></pre><p>现在，让我们看一下输出。</p><p><img alt="Template syntax output" class="alignnone size-full wp-image-13730" data-lazy-sizes="(max-width: 919px) 100vw, 919px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1.jpg 919w, https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1-300x173.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1-768x443.jpg 768w" height="530" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20919%20530'%3E%3C/svg%3E" width="919"/></p><noscript><img alt="Template syntax output" class="alignnone size-full wp-image-13730" height="530" sizes="(max-width: 919px) 100vw, 919px" src="img/f0ca1d3ada6af3aff784a475696db25b.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1.jpg 919w, https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1-300x173.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/08/1_MultipleRendering-1-768x443.jpg 768w" width="919"/><p>是时候在多个地方看到一些反应发生了。 和以前一样，让我们​​在 Chrome 浏览器的 DevTools 控制台中更改<code>message</code>属性的值。</p><p><img alt="Reactivity at multiple places" class="alignnone size-full wp-image-13731" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/08/2_MultipleReactivity-1.jpg" height="390" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20421%20390'%3E%3C/svg%3E" width="421"/></p><noscript><img alt="Reactivity at multiple places" class="alignnone size-full wp-image-13731" height="390" src="img/ad819e5f91d3748a6b02ab6da1e50ab5.png" width="421"/><p>当您按下<code>Enter</code>时，在我们的 HTML 代码中引用<code>message</code>的每个位置都将立即更新为新值“ vue.js”，这就是您现在在 DOM 中看到的内容。</p><p>这不仅令人惊讶吗？ 是的，这就是我们忙于玩 Candy Crush 时 Vue 团队或 Evan You 所要做的！ 在本系列教程中，我们将看到更多示例，以各种其他方式展示了反应性。</p><p>试想一下，如果您使用香草 JavaScript 或 jQuery 实现类似这样的功能，将需要多少编码！</p><p>话虽如此，我请假。 祝您有美好的一天！</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/3-vue-directives/" title="3\. Introduction to Vue directives"> 3\. Vue 指令简介</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/147.md
浏览文件 @ 6bf5daa3
# 3\. View指令简介
# 3\. View 指令简介
> 原文： [https://javabeginnerstutorial.com/vue-js/3-vue-directives/](https://javabeginnerstutorial.com/vue-js/3-vue-directives/)
今天，我们将探讨Vue指令的全部内容。
今天，我们将探讨 Vue 指令的全部内容。
首先是第一件事。 什么是指令？ 这些是特殊的说明，它们会在附加到HTML元素时更改其行为。 换句话说，这些是附加到HTML元素的特殊属性，这些属性可以更改行为并基于DOM的表达式值提供对DOM的控制。
首先是第一件事。 什么是指令？ 这些是特殊的说明，它们会在附加到 HTML 元素时更改其行为。 换句话说，这些是附加到 HTML 元素的特殊属性，这些属性可以更改行为并基于 DOM 的表达式值提供对 DOM 的控制。
所有Vue指令均以`v-`为前缀。 该前缀用于以下目的：
所有 Vue 指令均以`v-`为前缀。 该前缀用于以下目的：
* 表示它是属于Vue的特殊属性
* 表示它是属于 Vue 的特殊属性
* 帮助保持语法一致
* 为开发人员提供可读性
Vue带有一些内置指令。 请注意，我们可以编写自己的自定义指令，我们将在以后看到。 这些指令可以在许多情况下为我们提供帮助。
Vue 带有一些内置指令。 请注意，我们可以编写自己的自定义指令，我们将在以后看到。 这些指令可以在许多情况下为我们提供帮助。
一些例子是，
* 单向和双向**绑定**：`v-bind`和`v-model`
* **监听DOM事件**：`v-on`
* **监听 DOM 事件**：`v-on`
* **条件渲染**：`v-if`，`v-else`，`v-for`
* **插值**：`v-once`，`v-html`，`v-text`
......@@ -71,4 +71,4 @@ greet（）函数返回的标题和值都将为“ Hi！”。 因为一旦`mess
![without Vue Directives](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20784%20616'%3E%3C/svg%3E)
<noscript><img alt="without Vue Directives" class="alignnone size-full wp-image-13962" height="616" src="img/b61c39cadd45c6bced82a8933db8cda1.png" width="784"/><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>但是，在某些情况下，即使稍后更改属性，您可能仍要显示其初始值。 这是指令生效的地方。 在我们的场景中，我们希望显示<code>message</code>属性的初始值“嗨，大家好！” 作为标题。 因此，通过将指令v-once添加到<code>&lt;h1&gt;</code>元素，该元素内部的所有内容将仅呈现一次。 稍后通过<code>&lt;p&gt;</code>元素中的<code>greet()</code>方法对其进行更改时，将不会对其进行更新。</p><p><img alt="With Vue directives" class="alignnone size-full wp-image-13963" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/2_vOnce.jpg" height="591" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20788%20591'%3E%3C/svg%3E" width="788"/></p><noscript><img alt="With Vue directives" class="alignnone size-full wp-image-13963" height="591" src="img/86f997c82e065ce6c4461f4bd6bd5bfb.png" width="788"/><p>与往常一样，所有代码文件都可以在<a href="https://github.com/JBTAdmin/vuejs"> GitHub存储库</a>中找到。 请随意创建您自己的副本，以尝试使用<code>v-once</code>指令。 不要忘记让您的想象力疯狂。 再见！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/4-vue-devtools-setup/" title="4\. Vue Devtools Setup"> 4\. Vue Devtools设置</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="without Vue Directives" class="alignnone size-full wp-image-13962" height="616" src="img/b61c39cadd45c6bced82a8933db8cda1.png" width="784"/><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>但是，在某些情况下，即使稍后更改属性，您可能仍要显示其初始值。 这是指令生效的地方。 在我们的场景中，我们希望显示<code>message</code>属性的初始值“嗨，大家好！” 作为标题。 因此，通过将指令 v-once 添加到<code>&lt;h1&gt;</code>元素，该元素内部的所有内容将仅呈现一次。 稍后通过<code>&lt;p&gt;</code>元素中的<code>greet()</code>方法对其进行更改时，将不会对其进行更新。</p><p><img alt="With Vue directives" class="alignnone size-full wp-image-13963" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/2_vOnce.jpg" height="591" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20788%20591'%3E%3C/svg%3E" width="788"/></p><noscript><img alt="With Vue directives" class="alignnone size-full wp-image-13963" height="591" src="img/86f997c82e065ce6c4461f4bd6bd5bfb.png" width="788"/><p>与往常一样，所有代码文件都可以在<a href="https://github.com/JBTAdmin/vuejs"> GitHub 存储库</a>中找到。 请随意创建您自己的副本，以尝试使用<code>v-once</code>指令。 不要忘记让您的想象力疯狂。 再见！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/4-vue-devtools-setup/" title="4\. Vue Devtools Setup"> 4\. Vue Devtools 设置</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/148.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/149.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/15.md
浏览文件 @ 6bf5daa3
# Java中的算术运算符
# Java 中的算术运算符
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-arithmetic-operator/](https://javabeginnerstutorial.com/core-java-tutorial/java-arithmetic-operator/)
......@@ -107,12 +107,12 @@ public class OperatorAssociativityExample {
}
```
## Java中的运算符
## Java 中的运算符
让我们分别讨论每个运算符。
赋值（=）和算术运算符（+，-，*，/）的工作方式与其他编程语言相同，因此在此不再赘述。 ' **/** '和' ***** '运算符的优先级高于sum（ **+** ）或减号（ **–** ）或模除 （**％**）
赋值（=）和算术运算符（+，-，*，/）的工作方式与其他编程语言相同，因此在此不再赘述。 ' **/** '和' ***** '运算符的优先级高于 sum（ **+** ）或减号（ **–** ）或模除 （**％**）
###### 下一篇文章
##### [Java异常教程](https://javabeginnerstutorial.com/core-java-tutorial/java-exceptions/ "Java Exceptions Tutorial")
\ No newline at end of file
##### [Java 异常教程](https://javabeginnerstutorial.com/core-java-tutorial/java-exceptions/ "Java Exceptions Tutorial")
\ No newline at end of file
docs/150.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/151.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/152.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/153.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/154.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/155.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/156.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/157.md
浏览文件 @ 6bf5daa3
......@@ -2,9 +2,9 @@
> 原文： [https://javabeginnerstutorial.com/vue-js/13-shorthands-for-v-bind-and-v-on/](https://javabeginnerstutorial.com/vue-js/13-shorthands-for-v-bind-and-v-on/)
欢迎回来！ 有人说速记吗？ 是的，这就是我们今天要关注的重点。 我们已经使用 [Vue指令](https://javabeginnerstutorial.com/js/vue-js/what-is-vuejs/)已有一段时间了。 `v-`前缀有多种帮助。 它直观地表示我们正在处理代码中与Vue相关的属性（最重要的原因）。
欢迎回来！ 有人说速记吗？ 是的，这就是我们今天要关注的重点。 我们已经使用 [Vue 指令](https://javabeginnerstutorial.com/js/vue-js/what-is-vuejs/)已有一段时间了。 `v-`前缀有多种帮助。 它直观地表示我们正在处理代码中与 Vue 相关的属性（最重要的原因）。
到目前为止，您应该已经了解`v-bind`和`v-on`是我们模板中最常用的两个指令。 为什么？ 因为我们一直在处理[事件](https://javabeginnerstutorial.com/vue-js/11-listening-to-dom-events-and-event-modifiers/)（特别是单击）和[数据绑定](https://javabeginnerstutorial.com/vue-js/6-data-binding-p2/)！ 因此，对于这两个最常用的指令，Vue为我们提供了捷径或编写它们的简便方法。
到目前为止，您应该已经了解`v-bind`和`v-on`是我们模板中最常用的两个指令。 为什么？ 因为我们一直在处理[事件](https://javabeginnerstutorial.com/vue-js/11-listening-to-dom-events-and-event-modifiers/)（特别是单击）和[数据绑定](https://javabeginnerstutorial.com/vue-js/6-data-binding-p2/)！ 因此，对于这两个最常用的指令，Vue 为我们提供了捷径或编写它们的简便方法。
## 起始码
......@@ -41,9 +41,9 @@ new Vue({
});
```
## v-bind的简写
## v-bind 的简写
让我们使用`v-bind`属性将HTML `<a>`标记的`href`属性绑定到“ `https://www.google.com`” URL，
让我们使用`v-bind`属性将 HTML `<a>`标记的`href`属性绑定到“ `https://www.google.com`” URL，
*Index.html（摘要）*
......@@ -51,7 +51,7 @@ new Vue({
<a v-bind:href="url" target="_blank">Google</a>
```
然后在Vue实例的数据对象中定义“ `url`”，
然后在 Vue 实例的数据对象中定义“ `url`”，
*Index.js（摘要）*
......@@ -61,7 +61,7 @@ data: {
}
```
这段代码工作得很好。 单击链接“ `Google`”，将打开一个新标签，并导航到Google页面。 但是我们想看起来很酷。 不是吗 因此，编写`v-bind`指令的简短方法是一次性删除`v-bind`一词，而仅使用**冒号**。
这段代码工作得很好。 单击链接“ `Google`”，将打开一个新标签，并导航到 Google 页面。 但是我们想看起来很酷。 不是吗 因此，编写`v-bind`指令的简短方法是一次性删除`v-bind`一词，而仅使用**冒号**。
```java
<!— Cool way of writing v-bind -->
......@@ -70,8 +70,8 @@ data: {
刚开始时可能看起来有些混乱，但是一旦您掌握了它，您很快就会感到赞赏。 这两个代码段（带和不带速记）的工作原理完全相同。 区别只是少了一些字符和更易读的代码。
如下图所示，即使是简写形式，所有受Vue.js支持的浏览器（在我们的示例中为Chrome）都可以正确解析它，并将`url`的值绑定到`href`属性。 请注意，冒号（v-bind的简写语法）没有出现在最终呈现的HTML中，可以在Chrome DevTools扩展坞的“元素”窗格中清楚地看到。
如下图所示，即使是简写形式，所有受 Vue.js 支持的浏览器（在我们的示例中为 Chrome）都可以正确解析它，并将`url`的值绑定到`href`属性。 请注意，冒号（v-bind 的简写语法）没有出现在最终呈现的 HTML 中，可以在 Chrome DevTools 扩展坞的“元素”窗格中清楚地看到。
![v-bind](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20578%20354'%3E%3C/svg%3E)
<noscript><img alt="v-bind" class="alignnone size-full wp-image-14134" height="354" src="img/51f44e5135c07d36919a60b077148ebd.png" width="578"/><h2>v-on的简写</h2><p>为了理解<code>v-on</code>指令的简写语法，让我们有一个按钮。 单击它后，我们将触发名为“ <code>greet</code>”的方法，以在消息<code>Hi</code>和<code>Hello</code>之间切换。</p><p>完整的语法是</p><p><em>Index.html (snippet)</em></p><pre><code class="language-html">&lt;button v-on:click="greet"&gt;Click for a different greeting&lt;/button&gt;</code></pre><p><em>Index.js (snippet)</em></p><pre><code class="language-javascript">data: { message: "Hi", url: "https://www.google.com" }, methods: { greet() { this.message === "Hi" ? this.message = "Hello" : this.message = "Hi"; } }</code></pre><p>好的。 此处的缩写是将单词<code>v-on</code>和冒号替换为<code>@</code>符号。 就这样！ 它是如此简单！！</p><p><em>Index.html (snippet)</em></p><pre><code class="language-html">&lt;!-- Using v-on shorthand --&gt; &lt;button @click="greet"&gt;Click for a different greeting&lt;/button&gt; </code></pre><h2>最终密码</h2><p>Index.html</p><pre><code class="language-html">&lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;title&gt;Hello Vue!&lt;/title&gt; &lt;!-- including Vue with development version CDN --&gt; &lt;script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"&gt;&lt;/script&gt; &lt;/head&gt; &lt;body&gt; &lt;div id="app"&gt; &lt;h2&gt;Welcome&lt;/h2&gt; &lt;!-- Using v-on shorthand --&gt; &lt;button @click="greet"&gt;Click for a different greeting&lt;/button&gt; &lt;p&gt; {{ message }} &lt;/p&gt; &lt;!-- Using v-bind shorthand --&gt; &lt;a :href="url" target="_blank"&gt;Google&lt;/a&gt; &lt;/div&gt; &lt;!-- including index.js file --&gt; &lt;script src="index.js"&gt;&lt;/script&gt; &lt;/body&gt; &lt;/html&gt;</code></pre><p>Index.js</p><pre><code class="language-javascript">new Vue({ el: "#app", data: { message: "Hi", url: "https://www.google.com" }, // define all custom methods within the 'methods' object methods: { greet() { // 'this' keyword refers to the current Vue instance this.message === "Hi" ? this.message = "Hello" : this.message = "Hi"; } } });</code></pre><p>代码看起来更加简洁，优雅且不那么冗长（显然！）。 您将在处理事件负载的实际应用程序中更好地看到它。 请记住，使用速记语法完全是可选的，完全由您决定。 上面讨论的所有代码以及注释都可以在<a href="https://github.com/JBTAdmin/vuejs"> GitHub存储库</a>中找到。</p><p><em>警告：我将在以后的所有代码示例中使用这些简写形式。 与他们合作的次数越多，您就越感到舒适！ </em></p><p><strong>为什么要使用速记？ </strong></p><p>让我们了解使用这些速记来说服您的原因，</p><ol><li>由于经常以完整形式使用这些指令，因此代码变得冗长。</li><li>在将Vue.js用作管理所有前端代码的框架的应用程序（例如<a href="https://en.wikipedia.org/wiki/Single-page_application"> SPA </a>）中，很明显正在使用Vue，而前缀<code>v-</code>并不那么重要。</li><li>干净，易读的代码是每个开发人员最终想要的。</li></ol><p>这使我们到了本文的结尾。 祝你今天愉快。</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/14-two-way-binding-v-model/" title="14\. Two-way data binding with v-model"> 14.使用v模型</a>的双向数据绑定</h5></div></div> </body> </html></noscript>
\ No newline at end of file
<noscript><img alt="v-bind" class="alignnone size-full wp-image-14134" height="354" src="img/51f44e5135c07d36919a60b077148ebd.png" width="578"/><h2>v-on 的简写</h2><p>为了理解<code>v-on</code>指令的简写语法，让我们有一个按钮。 单击它后，我们将触发名为“ <code>greet</code>”的方法，以在消息<code>Hi</code>和<code>Hello</code>之间切换。</p><p>完整的语法是</p><p><em>Index.html (snippet)</em></p><pre><code class="language-html">&lt;button v-on:click="greet"&gt;Click for a different greeting&lt;/button&gt;</code></pre><p><em>Index.js (snippet)</em></p><pre><code class="language-javascript">data: { message: "Hi", url: "https://www.google.com" }, methods: { greet() { this.message === "Hi" ? this.message = "Hello" : this.message = "Hi"; } }</code></pre><p>好的。 此处的缩写是将单词<code>v-on</code>和冒号替换为<code>@</code>符号。 就这样！ 它是如此简单！！</p><p><em>Index.html (snippet)</em></p><pre><code class="language-html">&lt;!-- Using v-on shorthand --&gt; &lt;button @click="greet"&gt;Click for a different greeting&lt;/button&gt; </code></pre><h2>最终密码</h2><p>Index.html</p><pre><code class="language-html">&lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;title&gt;Hello Vue!&lt;/title&gt; &lt;!-- including Vue with development version CDN --&gt; &lt;script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"&gt;&lt;/script&gt; &lt;/head&gt; &lt;body&gt; &lt;div id="app"&gt; &lt;h2&gt;Welcome&lt;/h2&gt; &lt;!-- Using v-on shorthand --&gt; &lt;button @click="greet"&gt;Click for a different greeting&lt;/button&gt; &lt;p&gt; {{ message }} &lt;/p&gt; &lt;!-- Using v-bind shorthand --&gt; &lt;a :href="url" target="_blank"&gt;Google&lt;/a&gt; &lt;/div&gt; &lt;!-- including index.js file --&gt; &lt;script src="index.js"&gt;&lt;/script&gt; &lt;/body&gt; &lt;/html&gt;</code></pre><p>Index.js</p><pre><code class="language-javascript">new Vue({ el: "#app", data: { message: "Hi", url: "https://www.google.com" }, // define all custom methods within the 'methods' object methods: { greet() { // 'this' keyword refers to the current Vue instance this.message === "Hi" ? this.message = "Hello" : this.message = "Hi"; } } });</code></pre><p>代码看起来更加简洁，优雅且不那么冗长（显然！）。 您将在处理事件负载的实际应用程序中更好地看到它。 请记住，使用速记语法完全是可选的，完全由您决定。 上面讨论的所有代码以及注释都可以在<a href="https://github.com/JBTAdmin/vuejs"> GitHub 存储库</a>中找到。</p><p><em>警告：我将在以后的所有代码示例中使用这些简写形式。 与他们合作的次数越多，您就越感到舒适！ </em></p><p><strong>为什么要使用速记？ </strong></p><p>让我们了解使用这些速记来说服您的原因，</p><ol><li>由于经常以完整形式使用这些指令，因此代码变得冗长。</li><li>在将 Vue.js 用作管理所有前端代码的框架的应用程序（例如<a href="https://en.wikipedia.org/wiki/Single-page_application"> SPA </a>）中，很明显正在使用 Vue，而前缀<code>v-</code>并不那么重要。</li><li>干净，易读的代码是每个开发人员最终想要的。</li></ol><p>这使我们到了本文的结尾。 祝你今天愉快。</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/14-two-way-binding-v-model/" title="14\. Two-way data binding with v-model"> 14.使用 v 模型</a>的双向数据绑定</h5></div></div> </body> </html></noscript>
\ No newline at end of file
docs/158.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/159.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/16.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/160.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/161.md
浏览文件 @ 6bf5daa3
# Python教程
\ No newline at end of file
# Python 教程
\ No newline at end of file
docs/162.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/163.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/164.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/165.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/166.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/167.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/168.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/169.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/17.md
浏览文件 @ 6bf5daa3
# 用Java创建对象的不同方法
# 用 Java 创建对象的不同方法
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/different-ways-to-create-an-object-in-java/](https://javabeginnerstutorial.com/core-java-tutorial/different-ways-to-create-an-object-in-java/)
您必须知道使用new关键字创建类的对象，但这不是创建Object的唯一方法。
您必须知道使用 new 关键字创建类的对象，但这不是创建 Object 的唯一方法。
还有其他几种创建类对象的方法：
......@@ -10,12 +10,12 @@
* 使用新实例（反射）
* 使用克隆
* 使用反序列化
* 使用ClassLoader
* 使用 ClassLoader
* … don’t know 🙂
## 使用新关键字
使用new关键字是创建对象的最基本方法。 ***新的**关键字可用于创建类的对象。*
使用 new 关键字是创建对象的最基本方法。 ***新的**关键字可用于创建类的对象。*
```java
public class ObjectCreationExample {
......@@ -33,7 +33,7 @@ class JBT{
## 使用新实例（反射）
您是否曾经尝试使用Java中的JDBC驱动程序连接到数据库？ 如果您的回答是肯定的，那么您必须已经看到“ ***Class.forName*** ”。 我们还可以使用它来创建类的对象。 **Class.forName** 实际上是在Java中加载该类，但未创建任何对象。 要创建对象，必须使用Class类的 ***newInstance*** 方法。
您是否曾经尝试使用 Java 中的 JDBC 驱动程序连接到数据库？ 如果您的回答是肯定的，那么您必须已经看到“ ***Class.forName*** ”。 我们还可以使用它来创建类的对象。 **Class.forName** 实际上是在 Java 中加载该类，但未创建任何对象。 要创建对象，必须使用 Class 类的 ***newInstance*** 方法。
```java
/*
......@@ -79,7 +79,7 @@ class JBTClass {
## 使用克隆
我们还可以使用Clone（）方法创建现有 对象的 *的副本。*
我们还可以使用 Clone（）方法创建现有 对象的 *的副本。*
```java
/*
......@@ -126,16 +126,16 @@ class JBTClassClone implements Cloneable {
**关于克隆** 的其他说明
* 在这里，我们正在创建现有对象而不是任何新对象的克隆。
* 克隆方法在Object类中声明为受保护的。 因此，只能在子类或同一包中对其进行访问。 这就是为什么它在课堂上被覆盖的原因。
* 类需要实现Cloneable接口，否则它将引发CloneNotSupportedException。
* 克隆方法在 Object 类中声明为受保护的。 因此，只能在子类或同一包中对其进行访问。 这就是为什么它在课堂上被覆盖的原因。
* 类需要实现 Cloneable 接口，否则它将引发 CloneNotSupportedException。
## 使用对象反序列化
对象反序列化也可以用于创建对象。 它产生与序列化对象相反的操作。
## 使用ClassLoader
## 使用 ClassLoader
我们也可以使用ClassLoader创建类的对象。 这种方式与 ***Class.forName*** 选项相同。
我们也可以使用 ClassLoader 创建类的对象。 这种方式与 ***Class.forName*** 选项相同。
```java
/*
......
docs/170.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/171.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/172.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/173.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/174.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/175.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/176.md
浏览文件 @ 6bf5daa3
......@@ -4,7 +4,7 @@
现在，让我们编写一个脚本，该脚本实现一个基本的“猜数字”游戏。 游戏规则为：
* 用户选择是否要猜测1到100或1到1000之间的数字
* 用户选择是否要猜测 1 到 100 或 1 到 1000 之间的数字
* 根据数字范围，用户拥有固定数目的猜测
* 应用程序生成一个数字进行猜测
* 用户输入一个数字
......@@ -118,7 +118,7 @@ while True:
如您所见，代码非常繁琐，因为我们包含许多循环来验证输入并处理主游戏循环。 也许您以后会发现此代码根本不可读。 为了解决这个问题，我们将学习函数，然后重构这部分代码以使用函数。
但是，此脚本也有一些替代解决方案。 例如，您可以将中间的while循环更改为for循环：
但是，此脚本也有一些替代解决方案。 例如，您可以将中间的 while 循环更改为 for 循环：
```java
for guesses in range(guess_count):
......@@ -128,4 +128,4 @@ for guesses in range(guess_count):
###### 下一篇文章
##### [Python函数](https://javabeginnerstutorial.com/python-tutorial/python-function/ "Python function")
\ No newline at end of file
##### [Python 函数](https://javabeginnerstutorial.com/python-tutorial/python-function/ "Python function")
\ No newline at end of file
docs/177.md
浏览文件 @ 6bf5daa3
......@@ -20,7 +20,7 @@ def ask_user_for_number(message_text):
如您所见，这是一种非常简单的方法，我们要求用户输入内容，如果输入的是数字，则将其返回。
自然，我们无法使用此方法处理将数字验证为100或1000的情况，因此我们也必须在那里修改代码块。
自然，我们无法使用此方法处理将数字验证为 100 或 1000 的情况，因此我们也必须在那里修改代码块。
在此简单修改的​​最后，我们为应用程序提供了以下代码（并且具有相同的功能）：
......@@ -95,7 +95,7 @@ def user_won(guessed, secret):
print('The secret number is higher...')
```
在user_won函数中，我们使用return语句指示用户是否赢了。 如果不是，则返回隐式None，其结果为false。
在 user_won 函数中，我们使用 return 语句指示用户是否赢了。 如果不是，则返回隐式 None，其结果为 false。
我们可以测试的另一件事是询问用户是否要再玩一轮。
......
docs/178.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/180.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/181.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/182.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/183.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/184.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/185.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/186.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/187.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/188.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/189.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/19.md
浏览文件 @ 6bf5daa3
......@@ -2,9 +2,9 @@
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/inner-class/](https://javabeginnerstutorial.com/core-java-tutorial/inner-class/)
Java内部类是类中的类。 内部类实例与外部类具有特殊关系。 这种特殊的关系使内部类可以访问外部类的成员，就好像它们是外部类的一部分一样。
Java 内部类是类中的类。 内部类实例与外部类具有特殊关系。 这种特殊的关系使内部类可以访问外部类的成员，就好像它们是外部类的一部分一样。
###### 注意：Java内部类实例可以访问外部类的所有成员（公共，私有&受保护）
###### 注意：Java 内部类实例可以访问外部类的所有成员（公共，私有&受保护）
## 创建内部类的语法
......@@ -44,9 +44,9 @@ outer.class
inner$outer.class
```
###### 注意：您无法使用java命令直接执行内部类的.class文件。
###### 注意：您无法使用 java 命令直接执行内部类的.class 文件。
由于它不是静态内部类，因此我们不能对其使用static关键字。
由于它不是静态内部类，因此我们不能对其使用 static 关键字。
## 如何进入内部舱位
......@@ -102,7 +102,7 @@ OuterClass.InnerClass innerClass = new OuterClass.new InnerClass();
### 这个关键字
有一些与[相关的规则，它引用当前正在执行的对象。 因此，在内部类中，“ this”关键字将引用当前正在执行的内部类Object。 但是要获取外部类的代码，请使用“ OuterClass.this”。](https://javabeginnerstutorial.com/core-java-tutorial/this-keyword-java/)
有一些与[相关的规则，它引用当前正在执行的对象。 因此，在内部类中，“ this”关键字将引用当前正在执行的内部类 Object。 但是要获取外部类的代码，请使用“ OuterClass.this”。](https://javabeginnerstutorial.com/core-java-tutorial/this-keyword-java/)
### 应用修饰符
......@@ -141,18 +141,18 @@ i1.getValue();
###### 注意：
* 方法局部内部类可以在定义它的方法内实例化，而不能在其他地方实例化。
* 方法本地内部类不能使用在其ID定义的方法中定义的变量，但仍可以使用实例变量。
* 如果方法局部变量是“ Final”，则方法局部内部类可以使用它。 （*现在变量是Final）
* 方法本地内部类不能使用在其 ID 定义的方法中定义的变量，但仍可以使用实例变量。
* 如果方法局部变量是“ Final”，则方法局部内部类可以使用它。 （*现在变量是 Final）
### 应用于方法本地内部类的修饰符
方法局部内部类可以使用修饰符（例如局部变量），因此方法局部内部类可以具有final或abstract。
方法局部内部类可以使用修饰符（例如局部变量），因此方法局部内部类可以具有 final 或 abstract。
## 备忘单
* ***内部类*** 是包含在*类*中的成员。
* ***外部类*** 引用需要启动内部类。
* 内部类有4种类型。
* 内部类有 4 种类型。
* 在方法内定义的内部类是方法局部内部类。
* 方法局部内部类不能访问方法局部变量。
* ***最终*** & ***摘要*** 是可用于方法内部内部类的唯一修饰符。
......
docs/190.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/191.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/192.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/193.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/2.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/20.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/21.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/22.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/23.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/24.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/25.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/26.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/27.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/28.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/29.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/3.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/30.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/31.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/32.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/33.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/34.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/35.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/36.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/37.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/38.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/39.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/4.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/40.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/41.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/42.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/43.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/44.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/45.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/46.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/47.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/48.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/49.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/5.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/50.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/51.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/52.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/53.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/54.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/55.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/56.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/57.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/58.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/59.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/6.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/60.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/61.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/62.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/63.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/64.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/65.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/66.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/67.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/69.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/7.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/71.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/72.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/73.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/74.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/75.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/77.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/78.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/79.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/8.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/80.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/81.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/82.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/83.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/84.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/85.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/86.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/87.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/88.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/89.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/9.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/90.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/91.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/92.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/93.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/94.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/95.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/96.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/97.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/98.md
浏览文件 @ 6bf5daa3
此差异已折叠。
docs/99.md
浏览文件 @ 6bf5daa3
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或