整合营销服务商

电脑端+手机端+微信端=数据同步管理

免费咨询热线：

「2022」打算跳槽涨薪，必问面试题及答案-VUE篇

「2022」打算跳槽涨薪，必问面试题及答案-VUE篇

、为什么选择VUE，解决了什么问题？

vue.js 正如官网所说的，是一套构建用户界面的渐进式框架。与其它重量级框架不同的是，vue 被设计为可以自底向上逐层应用。vue 的核心库只关注视图层，不仅易于上手，还便于与第三方库或既有项目整合。另外一方面，当与现代化工具链以及各种支持类库结合使用时，vue 也完全能够为复杂的单页应用提供驱动。

vue.js 有声明式，响应式的数据绑定，组件化开发，并且还使用虚拟 DOM 等技术，统一编程规范和模块等，将项目功能模块化更方便组织和构建复杂应用，便于项目的扩展和维护。 vue 框架维护及时，且 Vue 3 将在 2022 年 2 月 7 日 成为新的默认版本。

2、如果加入 keep-alive，第一次进入组件会执行哪些生命周期函数？

会执行的钩子函数以及它们的顺序分别为：

beforeCreat、created、beforeMount、mounted、activated

3、key 的作用和工作原理。

key 的作用主要是为了高效地更新虚拟 DOM，其原理是 vue 中在 patch 过程中，通过 key 可以精准判断两个节点是否是同一个，从而避免频繁更新不同元素，使得整个 patch 过程更加高效，减少 DOM 操作量，提高性能。

另外，若不设置 key 还可能在列表更新时，引发一些隐蔽的 bug 。vue 在使用相同标签名元素的过滤或切换时，也会使用到 key 属性，其目的也是为了让 vue 可以区分它们，否则 vue 只会替换其内部属性而不会触发过滤效果。

4、v-if 和 v-for 的优先级哪个高？

v-for 的优先级更高。

如果 v-if 和 v-for 同时出现，每次渲染都会先执行循环，再判断条件，无论如何循环都不可避免，浪费了性能。

情景一：每次遍历时，都需要执行 v-if 解析一次，浪费性能。

<ul>
  <li
    v-for="user in users"
    v-if="shouldShowUsers"
    :key="user.id"
  >
    {{ user.name }}
  </li>
</ul>

要避免出现这种情况，则在外层嵌套 template ，在这一层进行 v-if 判断，然后在内部进行 v-for 循环。可以改为：

<ul>
  <template v-if="shouldShowUsers">
   <li
     v-for="user in users"
    :key="user.id"
  >
    {{ user.name }}
  </li>
 </template>
</ul>

情景二：v-if 和 v-for 同时出现在一个标签，过滤一个列表中的项目，比如：

<ul>
  <li
    v-for="user in users"
    v-if="user.isActive"
    :key="user.id"
  >
    {{ user.name }}
  </li>
</ul>

在这种情况下，请将 users 替换为一个计算属性，让其返回过滤后的列表。

<ul>
  <li
    v-for="user in activeUsers"
    :key="user.id"
  >
    {{ user.name }}
  </li>
</ul>
computed: {
  activeUsers: function () {
    return this.users.filter(function (user) {
      return user.isActive
    })
  }
}

5、谈谈对 vue 组件化的理解。

5.1、组件化的定义

组件是独立和可复用的代码组织单元，组件系统是 vue 核心特性之一，它使开发者使用小型、独立和通常可复用的组件构建大型应用。

也可以通俗介绍，把一些用户在程序中一些独立的功能和模块单独提取出来，然后切分为更小的块，这些块有独立的逻辑，有更好的复用性。

组件按照分类有：页面组件(导航)、业务组件(登录)、通用组件(输入框)。

5.2、组件化特点

vue 的组件是基于配置的，通常编写的组件是组件配置而非组件，框架后续会生成其构造函数，它们基于 VueComponent 这个类扩展于 vue 。

常见的组件化技术有：prop 属性、自定义事件、插槽等，这些主要用于组件之间的通信等。

组件之间遵循单向数据流原则。

5.3、组件化的优点

组件化的开发能大幅提高开发效率、测试性和复用性等。

合理的划分组件能够大幅提升应用性能，组件应该是高内聚，低耦合的。

6、为什么 data 在组件内必须是函数，而 vue 的根实例则没有此限制？

vue 组件可能存在多个实例，如果使用对象形式定义 data ，则会导致它们公用一个 data 对象，那么状态变更将会影响所有组件实例，这是不合理的。

如果采用函数的形式，在实例化组件时，data 会被当做工厂函数返回一个全新的 data 对象，有效规避多实例之间状态污染问题。

所以在组件中的 data 必须是函数，不能使用对象形式。那为什么 vue 根实例没有限制呢？

在 vue 中根实例只能有一个，所以不需要担心多实例的问题，所以根实例中的 data 可以是函数也可以是对象。

7、你了解哪些 vue 性能优化的方法？

我所了解的 vue 性能优化方法分别有：

1>、路由懒加载

Vue.use(VueRouter)
// 传统写法
import Home from '@/views/login/index.vue'

//路由懒加载
const  Login=()=> import('@/views/login/index.vue') 

const router=new VueRouter({
 routes: [
  { path: '/login', component: Login },
  { path: '/home', component: Home },
  ]
export default router

使用路由懒加载，项目打包的时候体积会大幅减小，访问项目时，这些组件也会按需进行加载，大大提升了项目性能。

2>、keep-alive 缓存页面

<template>
 <keep-alive>
  <router-view /> 
 </keep-alive>  
</template>

使用 keep-alive 之后会缓存页面，第一次加载之后，关闭再次打开，页面不会重新渲染。keep-alive 的属性：

  • include：字符串或正则表达式。如果只缓存个别页面，可以使用 include 属性，只缓存匹配组件。
  • exclude：字符串或正则表达式。如果个别页面不需要缓存时，可以使用 exclude 属性，任何匹配的组件都不会缓存。

3>、v-for遍历避免同时使用 v-if

<ul>
  <li
    v-for="user in activeUsers"
    :key="user.id"
  >
    {{ user.name }}
  </li>
</ul>
computed: {
  activeUsers: function () {
    return this.users.filter(function (user) {
      return user.isActive
    })
  }
}

4>、长列表性能优化

如果列表是纯粹的数据展示，不会有任何的改变，就不需要做响应式。

export default{
 data(){
  return {
   users:[]
  }
 },
 created(){
  const user=await axios("/api/user")
  this.users=Object.freeze(user)
 }
}

Object.freeze() 方法可以冻结一个对象，对象被冻结之后不能被修改，可以让性能大幅度提升。

如果是大数据长列表，可采用虚拟滚动，只渲染少部分区域的内容。可采用三方 vue-virtual-scroll。

5>、事件的销毁

vue组件销毁时，会自动解绑它的全部指令及事件监听器，但是仅限于组件本身的事件。

created(){
 this.timer=setInterval( this.refresh, 2000 )
},
beforeDestory(){
 clearInterval( this.timer )
}

6>、图片懒加载

对于图片过多的页面，为了加快页面的加载速度，所以很多时候，需要把未出现在可视区域的图片暂不进行加载，滚动到可视区域之后再开始加载。

可以使用三方的 vue-lazyload 库。

<img v-lazy="/src/img/01.jpg" />

7>、第三方插件按需引用

使用三方库时，可以按需引入避免体积太大。比如 element-ui ：

import { Button  } from "element-ui"

8>、无状态的组件标记为函数式组件

<template functional>
 <div>组件内容</div>  
</template>

通过 functional 将组件标记为函数式组件，因为函数式组件没有实例，所以运行时耗费资源较少。

另外还有 v-show 复用 DOM、子组件分割、SSR 等。

8、computed 与 methods 、watch 的区别？

computed VS methods

computed:{
 yyds(){
  log("computed show")
  return "计算属性"
 }
},
methods:{
 show(){
  log("method show")
  return "计算属性"
 }
}

computed 是计算属性，methods 内都是方法，所以调用不同分别为：

<div>yyds</div>
<div>show()</div>

computed 是有缓存的，而 methods 没有缓存，所以 computed 性能比 methods 的好。

computed VS watch

computed 是计算某一个属性的改变，如果某一个值改变了，计算属性会监测到，然后进行返回值。

watch 是监听某一个数据或路由，改变了才会响应，只有改变了才会执行操作。

9、你怎么理解 vue 中的 diff 算法？

1.diff算法是虚拟DOM技术的必然产物：通过新旧虚拟DOM作对比（即diff），将变化的地方更新在真实DOM上；

另外，也需要diff高效的执行对比过程，从而降低时间复杂度为O(n)。(what)

2.vue2.x中为了降低Watcher粒度，每个组件只有一个Watcher与之对应，只有引入diff才能精确找到发生变化的地方。(why)

3.vue中diff执行的时刻是组件实例执行其更新函数时，它会比对上一次渲染结果oldVnode和新的渲染结果newVnode,此过程称为patch。(where)

4.diff过程整体遵循深度优先、同层比较的策略；两个节点之间比较会根据它们是否拥有子节点或者文本节点做不同操作；(How)

比较两组子节点是算法的重点，首先假设头尾节点可能相同做4次比对尝试，如果没有找到相同节点才按照通用方式遍历查找，查找结束再按情况处理剩下的节点；

借助key通常可以非常精确找到相同节点，因此整个patch过程非常高效。

10、props 和 data 的优先级谁高？

vue组件内数据相关的属性它们的样式优先级从高到底分别为：

props > methods > data > computed > watch

11、vue 组件之间的通信

vue 组件之间的关系有：父子关系、兄弟关系、隔代关系。

所以 vue 组件之间的通信可分为：父子组件之间通信，兄弟组件之间通信和跨层组件之间通信。

1>、父传子

可使用的方法有：

  • 通过 props 传值
  • 通过 refs 传值
  • 通过 children 传值

2>、子传父

可使用的方法：

  • $emit 自定义事件
  • provide 和 inject

3>、兄弟组件之间

  • 利用中央事件总线 bus 的 $emit 和 $on 。
  • 笨办法，通过父组件共同传值

4>、跨层组件

  • provide 和 inject

5>、没有关系的组件之间通信

  • 可以使用 vuex 进行数据管理

端事件循环是什么

前端事件循环指的是 JavaScript 在浏览器中运行时的一种机制，它用于处理异步事件。事件循环会不断检查是否有事件发生，并调用相应的回调函数来处理这些事件。

事件循环的工作流程如下：

  1. 初始化：浏览器会初始化事件循环，并创建一个事件队列。
  2. 事件发生：当用户操作页面、网络请求完成或计时器超时等情况下，都会产生事件并添加到事件队列中。
  3. 事件处理：事件循环会从事件队列中取出事件，并调用事件的回调函数来处理事件。
  4. 重复：事件循环会不断重复步骤 2 和 3，直到事件队列为空。

事件循环的优点:

  • 高效：事件循环可以高效地处理大量的异步事件。
  • 可扩展：事件循环可以扩展到支持新的事件类型。
  • 跨平台：事件循环可以在不同的浏览器和操作系统上工作。

事件循环的注意点:

  • 事件循环是单线程的：这意味着所有事件都将在同一个线程中处理。
  • 事件循环不会阻塞：即使事件循环正在处理事件，应用程序也可以执行其他操作。
  • 用户需要确保事件回调函数是线程安全的。

浏览器事件循环与 Node.js 事件循环

Node.js 和浏览器都使用事件循环来处理异步事件。但是，两者之间存在一些关键差异：

1. 事件队列

  • 浏览器：只有一个事件队列，用于处理所有类型的事件，包括宏任务和微任务。
  • Node.js：有两个事件队列，一个用于宏任务，另一个用于微任务。

2. 任务执行顺序

  • 浏览器：宏任务和微任务交替执行。在执行完一个宏任务后，浏览器会检查微任务队列，并执行所有待处理的微任务。
  • Node.js：宏任务和微任务是分离的。在事件循环的每个阶段，Node.js 会先执行所有待处理的宏任务，然后再执行所有待处理的微任务。

3. 事件循环的阶段

  • 浏览器：只有一个阶段，用于处理所有类型的事件。
  • Node.js：有多个阶段，每个阶段用于处理特定类型的事件。例如，I/O 操作会在 I/O 阶段处理，计时器会在计时器阶段处理。

4. timers

  • 浏览器：计时器是在浏览器主线程中执行的。
  • Node.js：计时器是在单独的线程中执行的。

5. nextTick

  • 浏览器：nextTick 会将回调函数排队到微任务队列中，在下一次事件循环迭代中执行。
  • Node.js：nextTick 会将回调函数排队到宏任务队列中，在下一次事件循环的下一个阶段执行。

Node.js 与 libuv

Node.js 是一个基于 JavaScript 的运行时环境，用于构建服务器端应用程序。libuv 是一个开源的 C 库，提供了一组异步 I/O 和事件处理 API。

Node.js 与 libuv 的关系:

  • Node.js 是建立在 libuv 之上的。libuv 为 Node.js 提供了底层的异步 I/O 和事件处理功能。
  • Node.js 提供了一组 JavaScript API，用于使用 libuv 的功能。
  • libuv 可以被其他应用程序和库使用，而不仅仅是 Node.js。

libuv 的主要功能:

  • 异步 I/O：libuv 提供了一组异步 I/O API，用于执行网络操作、文件操作和其他类型的 I/O 操作。
  • 事件处理：libuv 提供了一组事件处理 API，用于处理异步事件。
  • 线程池：libuv 提供了一个线程池，用于执行 CPU 密集型任务。
  • 计时器：libuv 提供了一组计时器 API，用于执行定时任务。

Node.js 使用 libuv 的优势:

  • 高效：libuv 提供了高效的异步 I/O 和事件处理功能，这使得 Node.js 应用程序可以非常高效地处理大量的并发连接。
  • 可扩展：libuv 可以扩展到支持新的事件类型和新的 I/O 操作。
  • 跨平台：libuv 是跨平台的，这意味着 Node.js 应用程序可以在不同的操作系统上运行。

事件循环是 libuv 的核心，也是理解 libuv 的关键。事件循环是一种处理事件的机制，它会不断检查是否有事件发生，并调用相应的回调函数来处理这些事件。

libuv 的事件循环是基于 epoll 的，epoll 是 Linux 内核中的一种高效事件通知机制。epoll 可以监视大量的文件描述符，并通知应用程序哪些文件描述符上有事件发生。

libuv 的事件循环主要包含以下几个部分：

  • 事件队列：用于存储待处理的事件。事件队列是一个链表，每个事件节点包含以下信息：事件类型事件源事件回调函数用户数据
  • 事件源：用于生成事件。事件源可以是 I/O 操作、定时器或信号。
  • 事件回调函数：用于处理事件。事件回调函数可以执行任何操作，例如读取数据、写入数据或执行其他任务。

事件循环的工作流程如下：

  1. 初始化事件循环：libuv 会调用 uv_loop_init() 函数来初始化事件循环。
  2. 注册事件源：libuv 会调用 uv_poll()、uv_timer_init() 或 uv_signal_init() 等函数来注册事件源到事件循环。
  3. 启动事件循环：libuv 会调用 uv_run() 函数来启动事件循环。
  4. 等待事件发生：libuv 会调用 epoll_wait() 函数来等待事件发生。
  5. 处理事件：如果有事件发生，libuv 会从事件队列中取出事件节点。libuv 会调用事件节点的回调函数来处理事件。事件回调函数可以执行任何操作，例如读取数据、写入数据或执行其他任务。
  6. 重复步骤 4 和 5：事件循环会一直重复步骤 4 和 5，直到事件循环被停止。

libuv 提供了以下几种事件类型：

  • I/O 事件：用于监视 I/O 操作的完成，例如读写操作。
  • 定时器事件：用于定时执行某个函数。
  • 信号事件：用于处理操作系统信号。

libuv 的事件循环具有以下优点：

  • 高效：epoll 可以高效地监视大量的文件描述符。
  • 可扩展：libuv 支持多种事件类型，可以扩展到新的事件类型。
  • 跨平台：libuv 支持多种操作系统，可以跨平台使用。

以下是一些 libuv 事件循环的示例代码：

static void uv__poll(uv_loop_t *loop) {
  int timeout=loop->time < 0 ? -1 : loop->time;
  int nfds=epoll_wait(loop->epoll_fd, loop->watchers, ARRAY_SIZE(loop->watchers), timeout);

  if (nfds < 0) {
    if (errno !=EAGAIN && errno !=EINTR) {
      uv__set_error(loop, errno);
    }
    return;
  }

  for (i=0; i < nfds; i++) {
    uv_watcher_t *w=loop->watchers[i].data;

    if (w->events & UV_READABLE) {
      w->cb(w, UV_READABLE, 0);
    }

    if (w->events & UV_WRITABLE) {
      w->cb(w, UV_WRITABLE, 0);
    }
  }
}

这段代码是 libuv 的 uv__poll() 函数，用于处理 I/O 事件。

libuv 的事件循环是一种高效、可扩展和跨平台的事件处理机制。理解 libuv 的事件循环对于理解 libuv 的工作原理至关重要。

eautiful Soup 简介

Beautiful Soup 是一个可以从 HTML 或 XML 文件中提取数据的 Python 库，它提供了一些简单的操作方式来帮助你处理文档导航，查找，修改文档等繁琐的工作。因为使用简单，所以 Beautiful Soup 会帮你节省不少的工作时间。

Beautiful Soup 安装

你可以使用如下命令安装 Beautiful Soup。二选一即可。

$ easy_install beautifulsoup4

$ pip install beautifulsoup4

Beautiful Soup 不仅支持 Python 标准库中的 HTML 解析器，还支持很多第三方的解析器，比如 lxml，html5lib 等。初始化 Beautiful Soup 对象时如果不指定解析器，那么 Beautiful Soup 将会选择最合适的解析器（前提是你的机器安装了该解析器）来解析文档，当然你也可以手动指定解析器。这里推荐大家使用 lxml 解析器，功能强大，方便快捷，而且该解析器是唯一支持 XML 的解析器。

你可以使用如下命令来安装 lxml 解析器。二选一即可。

$ easy_install lxml

$ pip install lxml

Beautiful Soup 小试牛刀

Beautiful Soup 使用来起来非常简单，你只需要传入一个文件操作符或者一段文本即可得到一个构建完成的文档对象，有了该对象之后，就可以对该文档做一些我们想做的操作了。而传入的文本大都是通过爬虫爬取过来的，所以 Beautiful Soup 和 requests 库结合使用体验更佳。

# demo 1
from bs4 import BeautifulSoup
# soup=BeautifulSoup(open("index.html"))
soup=BeautifulSoup("<html><head><title>index</title></head><body>content</body></html>", "lxml") # 指定解析器
print(soup.head)

# 输出结果
<head><title>index</title></head>

Beautiful Soup 将复杂的 HTML 文档转换成一个复杂的树形结构，每个节点都是 Python 对象，所有对象可以归纳为 4 种: Tag，NavigableString，BeautifulSoup，Comment。

Tag 就是 HTML 的一个标签，比如 div，p 标签等，也是我们用的最多的一个对象。

NavigableString 指标签内部的文字，直译就是可遍历的字符串。

BeautifulSoup 指一个文档的全部内容，可以当成一个 Tag 来处理。

Comment 是一个特殊的 NavigableString，其输出内容不包括注视内容。

为了故事的顺利发展，我们先定义一串 HTML 文本，下文的所有例子都是基于这段文本的。

html_doc="""
<html><head><title>index</title></head>
<body>
<p class="title"><b>首页</b></p>
<p class="main">我常用的网站
<a href="https://www.google.com" class="website" id="google">Google</a>
<a href="https://www.baidu.com" class="website" id="baidu">Baidu</a>
<a href="https://cn.bing.com" class="website" id="bing">Bing</a>
</p>
<div><!--这是注释内容--></div>
<p class="content1">...</p>
<p class="content2">...</p>
</body>
"""

子节点

Tag 有两个很重要的属性，name 和 attributes。期中 name 就是标签的名字，attributes 是标签属性。标签的名字和属性是可以被修改的，注意，这种修改会直接改变 BeautifulSoup 对象。

# demo 2
soup=BeautifulSoup(html_doc, "lxml");
p_tag=soup.p
print(p_tag.name)
print(p_tag["class"])
print(p_tag.attrs)

p_tag.name="myTag" # attrs 同样可被修改，操作同字典
print(p_tag)

#输出结果
p
['title']
{'class': ['title']}
<myTag class="title"><b>首页</b></myTag>

由以上例子我么可以看出，可以直接通过点属性的方法来获取 Tag，但是这种方法只能获取第一个标签。同时我们可以多次调用点属性这个方法，来获取更深层次的标签。

# demo 3
soup=BeautifulSoup(html_doc, "lxml");
print(soup.p.b)

#输出结果
<b>首页</b>

如果想获得所有的某个名字的标签，则可以使用 find_all(tag_name) 函数。

# demo 4
soup=BeautifulSoup(html_doc, "lxml");
a_tags=soup.find_all("a")
print(a_tags)

#输出结果
[<a class="website" href="https://www.google.com" id="google">Google</a>, <a class="website" href="https://www.baidu.com" id="baidu">Baidu</a>, <a class="website" href="https://cn.bing.com" id="bing">Bing</a>]

我们可以使用 .contents 将 tag 以列表方式输出，即将 tag 的子节点格式化为列表，这很有用，意味着可以通过下标进行访问指定节点。同时我们还可以通过 .children 生成器对节点的子节点进行遍历。

# demo 5
soup=BeautifulSoup(html_doc, "lxml");
head_tag=soup.head
print(head_tag)
print(head_tag.contents)

for child in head_tag.children:
	print("child is : ", child)

#输出结果
<head><title>index</title></head>
[<title>index</title>]
child is :  <title>index</title>

.children 只可以获取 tag 的直接节点，而获取不到子孙节点，.descendants 可以满足你。

# demo 6
soup=BeautifulSoup(html_doc, "lxml");
head_tag=soup.head
for child in head_tag.descendants:
	print("child is : ", child)

# 输出结果
child is :  <title>index</title>
child is :  index

父节点

通过 .parent 属性获取标签的父亲节点。 title 的父标签是 head，html 的父标签是 BeautifulSoup 对象，而 BeautifulSoup 对象的父标签是 None。

# demo 7
soup=BeautifulSoup(html_doc, "lxml");
title_tag=soup.title

print(title_tag.parent)
print(type(soup.html.parent))
print(soup.parent)

# 输出结果
<head><title>index</title></head>
<class 'bs4.BeautifulSoup'>
None

同时，我们可以通过 parents 得到指定标签的所有父亲标签。

# demo 8
soup=BeautifulSoup(html_doc, "lxml");
a_tag=soup.a

for parent in a_tag.parents:
    print(parent.name)

# 输出结果
p
body
html
[document]

兄弟节点

通过 .next_sibling 和 .previous_sibling 来获取下一个标签和上一个标签。

# demo 9
soup=BeautifulSoup(html_doc, "lxml");
div_tag=soup.div

print(div_tag.next_sibling)
print(div_tag.next_sibling.next_sibling)

# 输出结果

<p class="content1">...</p>

你可能会纳闷，调用了两次 next_sibling 怎么只有一个输出呢，这方法是不是有 bug 啊。事实上是 div 的第一个 next_sibling 是div 和 p 之间的换行符。这个规则对于 previous_sibling 同样适用。

另外，我们可以通过 .next_siblings 和 .previous_siblings 属性可以对当前节点的兄弟节点迭代输出。在该例子中，我们在每次输出前加了前缀，这样就可以更直观的看到 dib 的第一个 previous_sibling 是换行符了。

# demo 10
soup=BeautifulSoup(html_doc, "lxml");
div_tag=soup.div

for pre_tag in div_tag.previous_siblings:
	print("pre_tag is : ", pre_tag)

# 输出结果
pre_tag is :  

pre_tag is :  <p class="main">我常用的网站
<a class="website" href="https://www.google.com" id="google">Google</a>
<a class="website" href="https://www.baidu.com" id="baidu">Baidu</a>
<a class="website" href="https://cn.bing.com" id="bing">Bing</a>
</p>
pre_tag is :  

pre_tag is :  <p class="title"><b>首页</b></p>
pre_tag is :

前进和后退

通过 .next_element 和 .previous_element 获取指定标签的前一个或者后一个被解析的对象，注意这个和兄弟节点是有所不同的，兄弟节点是指有相同父亲节点的子节点，而这个前一个或者后一个是按照文档的解析顺序来计算的。

比如在我们的文本 html_doc 中，head 的兄弟节点是 body（不考虑换行符），因为他们具有共同的父节点 html，但是 head 的下一个节点是 title。即soup.head.next_sibling=title soup.head.next_element=title

# demo 11
soup=BeautifulSoup(html_doc, "lxml");

head_tag=soup.head
print(head_tag.next_element)

title_tag=soup.title
print(title_tag.next_element)

# 输出结果
<title>index</title>
index

同时这里还需要注意的是 title 下一个解析的标签不是 body，而是 title 标签内的内容，因为 html 的解析顺序是打开 title 标签，然后解析内容，最后关闭 title 标签。

另外，我们同样可以通过 .next_elements 和 .previous_elements 来迭代文档树。由遗下例子我们可以看出，换行符同样会占用解析顺序，与迭代兄弟节点效果一致。

# demo 12
soup=BeautifulSoup(html_doc, "lxml");
div_tag=soup.div
for next_element in div_tag.next_elements:
	print("next_element is : ", next_element)

# 输出结果
next_element is :  这是注释内容
next_element is :  

next_element is :  <p class="content1">...</p>
next_element is :  ...
next_element is :  

next_element is :  <p class="content2">...</p>
next_element is :  ...
next_element is :  

next_element is :

Beautiful Soup 总结

本章节介绍了 Beautiful Soup 的使用场景以及操作文档树节点的基本操作，看似很多东西其实是有规律可循的，比如函数的命名，兄弟节点或者下一个节点的迭代函数都是获取单个节点函数的复数形式。

同时由于 HTML 或者 XML 这种循环嵌套的复杂文档结构，致使操作起来甚是麻烦，掌握了本文对节点的基本操作，将有助于提高你写爬虫程序的效率。


在线咨询
上一篇：Web前端超出隐藏与显示多种解决方案集锦
下一篇：Kendo UI：2014年移动调查报告：HTML5

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

推荐阅读
友情链接 澜沧拉祜族自治县 固安县 凯里市 古冶区 涪陵区 昆山市 网站制作
Copyright © 2002-2019 雨点网络设计有限公司 版权所有   冀ICP备11025394号
联系电话：   E-mail：279303980@qq.com  
主营业务：技术文章网站建设、网站定制、技术文章营销型网站建设、技术文章网站优化、技术文章微商城制作、三级分销系统开发
电话沟通
在线客服