整合营销服务商

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

免费咨询热线:

「浏览器」HTML、CSS和JS如何变成页面的?

们经常写 HTML 、 CSS 和 JavaScript ,写好这些之后,我们就会在浏览器中看到页面,那浏览器究竟在这背后做了一些什么事情呢?本篇文章将揭晓答案!

了解浏览器的渲染原理是我们在通往更深层次的前端开发中不可缺少的,它可以让我们从更深层次、角度去考虑性能优化等~

下面进入正文~

进程、线程

浏览器会分配一个线程“自上而下,从左到右”依次解析和渲染代码,那么进程和线程是什么,它们之间有着怎样的关系呢?

进程

一个进程就是一个程序运行的实例。当启动一个程序的时候,操作系统会为该程序创建一块内存,用来存放代码,运行中的数据和一个执行任务的主线程,这样的一个运行环境就叫进程

线程

线程不能单独存在,它是由进程来启动和管理的。线程依附于进程,进程中使用多线程并行处理能提升运算效率

两者之间的关系

1、进程中的任意一线程执行出错,都会导致整个进程的崩溃

2、线程之间可以共享数据

3、当一个进程关闭后,操作系统会回收进程所占用的内存

4、进程之间的内容相互隔离

渲染机制

从HTML、CSS和JavaScript开始

了解浏览器的渲染原理,我们就要从理解 HTML 、 CSS 和 JavaScrip 开始,我们先来看一张图

HTML (超文本标记语言),顾名思义,由标记(标签)和文本组成,每个标签都有自己的语意,浏览器会根据标签和文本展示对应的内容。

CSS (层叠样式表),由选择器和属性组成,它可以改变 HTML 的样式,比如上图中,我们改变了 span 的颜色由蓝色为绿色。

JavaScript ,我们可以通过 JS 完成很多事情,例如上图中修改样式。

下面开始分析渲染的原理

渲染流水线

渲染模块由于渲染的机制的复杂,被划分为了很多子阶段,输入的 HTML 经过这些子阶段,最后会输出为像素。这样的处理流程就叫做 渲染流水线

按照渲染的时间顺序,流水线可分为几个子阶段:构建 DOM 树、样式计算、布局阶段、分层、绘制、分块、光栅化和合成

构建DOM树

由于浏览器无法直接理解和使用 HTML ,所以需要将 HTML 转换为浏览器能够理解的结构( DOM 树)

树结构示意图

DOM树的构建过程

我们来分析一下下面这段代码会构建出一棵什么样的 DOM 树

我们先将上面的代码运行,然后在浏览器控制台输入 document ,看看会有什么效果

我们一层级一层级的打开就会看到如上图的效果,我们可以根据这每一层级展开的效果,绘制出一棵 DOM 树结构,如下:

接下来,我们试一下利用 JS 修改一下内容,看有什么改变:

我们可以看到“浏览器”的文字变成了“chrome”

再来看一下 DOM 树是否有改变

我们看到在“浏览器”的位置换成了“chrome”,那么如何让 DOM 节点拥有样式?

样式计算

样式计算,顾名思义,就是 计算出 DOM 节点中每个元素的具体样式 ,这个阶段会分为三部分:

  • 把 CSS 转换为浏览器能够理解的结构
  • 转换样式表中的属性值,使其标准化
  • 计算出 DOM 树中每个节点的样式

CSS样式来源

  • link 导入外部样式资源

浏览器会新开辟一个线程,去服务器获取对应的资源文件(不阻碍主线程的渲染)

  • style 内嵌样式

从上到下解析,解析完继续解析 DOM 结构。在真实项目中,如果 css 代码不是很多,或是移动端项目,我们应该使用内嵌式,以此来减少 http 资源的请求,提高页面渲染速度

  • 行内样式
  • @import 导入

它是同步的,不会开辟新线程去加载资源文件,而是让主线程去获取,这阻碍 DOM 结构的继续渲染;只有把外部样式导入进来,并且解析后,才会继续渲染 DOM 结构

把CSS转换为浏览器能够理解的结构

浏览器就像不能理解 HTML 一样,不理解 CSS ,所以当渲染引擎接收到 CSS 文件时,会执行转换操作,将 CSS 文本转换为浏览器可以理解的 styleSheets 结构。

在 HTML 中,在浏览器中输入 document 可以查看 html 的结构。在 css 中,可以输入 document.styleSheets 看到 css 的结构

现在的结构是空的,我们来加一些样式,看看效果

转换样式表中的属性值,使其标准化

属性值标准化就是将所有值转换为渲染引擎容易理解的、标准化的计算值。我们大致看一下效果:

  • 标准化前
body {
    font-size: 2em;
    color: black;
    font-weight: bold;
    ...
}
复制代码
  • 标准化后
body {
    font-size: 16px;
    color: rgb(0, 0, 0);
    font-weight: 700;
    ...
}
复制代码

计算出DOM树中每个节点的具体样式

样式计算有两个CSS的规则:继承规则和层叠规则

  • CSS继承规则

CSS 继承就是每个 DOM 节点都包含有父节点的样式。我们来看一下下面这段代码中如何应用到 DOM 节点上

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <style>
        h1 {
            color: red;
        }

        div {
            color: blue;
        }

        span {
            font-size: 16px;
        }
    </style>
</head>
<body>
    <h1>掘金</h1>
    <div>
        <span>浏览器</span>
        <span>渲染原理</span>
        构建DOM树
    </div>
</body>
</html>
复制代码

子节点会拥有父节点的样式,由此我们可以画出这样一张图

我们还可以打开控制台,看一下选中 span 标签,都会看到哪些内容

通过上图,我们可看到一个元素的样式、继承过程等, userAgent 样式是浏览器默认的内置样式,如果我们不提供任何样式,就会使用此样式。

  • 样式层叠规则

层叠在 CSS 处于核心地位,它是 CSS 的一个基本特征,它定义了如何合并来自多个源的属性值的算法。

样式计算阶段最终输出的内容是每个 DOM 节点的样式,并且保存在了 ComputedStyle 中。我们可以通过控制台看到某个 DOM 元素最终的计算样式

布局阶段

现在我们不知道 DOM 元素的几何位置信息,所以现在我们需要计算出 DOM 树中可见元素的几何位置,这个计算过程就叫做布局。布局阶段有两个过程:

  • 创建布局树
  • 布局计算

创建布局树

创建布局树的意思就是创建一棵只包含可见元素的树。我们来看下面一段代码创建布局树的过程

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <style>
        h1 {
            color: red;
        }

        div {
            color: blue;
        }

        div span {
            font-size: 16px;
        }

        div span:last-child {
            display: none;
        }
    </style>
</head>
<body>
    <h1>掘金</h1>
    <div>
        <span>浏览器</span>
        <span>渲染原理</span>
        构建DOM树
    </div>
</body>
</html>
复制代码

构建布局树的过程中, DOM 树中所有不可见的节点都不会包含在这棵树中。浏览器会遍历 DOM 树中所有能看见的节点,然后把这些节点加入到布局中;不可见的节点就会被忽略, head 标签下面的内容、 div 下最后一个 span 节点都不会在布局树中,我们看一下这个过程图感受一下~

布局计算

布局计算就是计算布局树节点的坐标位置。这个计算过程极为复杂。

分层

渲染引擎会为特定的节点生成专用的图层,并生成一棵对应的图层树。这样做是因为页面中可能含有很多复杂的效果,我们可以打开控制台看一下页面的分层情况

我们可以看到,渲染引擎给页面分了很多图层,这些图层会按照一定顺序叠加在一起,形成最终的页面

那么图层的来源有哪些?

1、拥有层叠上下文属性的元素会被提升为单独的一层

层叠上下文可以使能够使 HTML 元素具有三维的概念,这些 HTML 元素按照自身属性的优先级分布在垂直于这个二维平面的 z 轴上。哪些元素具有层叠上下文属性?

2、需要剪裁的地方会被创建为图层

当我们创建一个有宽度和高度的 div 时,里面的文字内容可能会超出这个区域,这时候渲染引擎会把裁剪文字内容的一部分用于显示在 div 区域,例如

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        div {
            width: 100px;
            height: 100px;
            background: yellow;
            overflow: auto;
        }
    </style>
</head>
<body>
    <div>
        我们经常写`HTML`、`CSS`和`JavaScript`,写好这些之后,我们就会在浏览器中看到页面,那浏览器究竟在这背后做了一些什么事情呢?本篇文章将揭晓答案!

        了解浏览器的渲染原理是我们在通往更深层次的前端开发中不可缺少的,它可以让我们从更深层次、角度去考虑性能优化等~
    </div>
</body>
</html>
复制代码

运行结果

我们再打开控制台的 layers 看一下效果

可以看到渲染引擎为文字部分单独创建了一个图层。

在布局树中的节点如果拥有对应的图层,这个节点就是一个图层,如果没有,这个节点就属于父节点的图层,如下图:

图层绘制

创建好图层树后,渲染引擎会绘制图层树中的每个图层。渲染引擎会将图层绘制分解为很多小的绘制指令,然后将这些指令按照顺序组成待绘制列表,我们可以打开控制台的 layers ,选择 document 层,看一下效果

栅格化操作

栅格化就是将图块转换位位图,图块是栅格化执行的最小单位。渲染进程维护了一个栅格化的线程池,所有图块的栅格化都是在线程池内执行的。

图层绘制列表准备好之后,主线程会把这个绘制列表提交给合成线程,绘制操作由渲染引擎中的合成线程来完成。

合成线程将图层划分为图块,然后合成线程会按照视口(可见区域)附近的图块优先生成位图。

合成与显示

所有的图块都被光栅化后,合成线程会生成一个绘制图块的命令( DrawQuad ),然后将该命令提交给浏览器进程。浏览器进程里面 viz 组件用来接收 DrawQuad 命令,将其页面内容绘制到内存中,最后将内存显示到屏幕。这个时候,我们就看到了页面

完善渲染流水线示意图

根据上文中描述,我们可以画出这样一张图

我还在网上找到了另外一张图

这两张图都是描述浏览器的渲染流程的。

子页面把整个页面做绝对定位,覆盖整个屏幕,子父页面将 router-view 用 transition 套起来,并加上过渡动画就可以啦。

代码:

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no">
 <title>Document</title>
 <style>
 * { padding: 0; margin: 0; }
 html, body, #app { width: 100%; height: 100%; }
 .one { height: 100%; background-color: yellow; }
 .two { background-color: tomato; position: fixed; top: 0; bottom: 0; left: 0; right: 0; }
 .three { background-color: #ffe69f; position: fixed; top: 0; bottom: 0; left: 0; right: 0; }
 .v-enter-active, .v-leave-active { transition: all 0.3s; }
 .v-enter, .v-leave-to { transform: translateX(100%); }
 </style>
</head>
<body>
 <div id="app">
 <div class="one">
 <p>
 <router-link to="/foo">下一层</router-link>
 </p>
 <h1>第一层</h1>
 </div>
 <transition>
 <router-view></router-view>
 </transition>
 </div>
 
 <script src="https://unpkg.com/vue/dist/vue.js"></script>
 <script src="https://unpkg.com/vue-router/dist/vue-router.js"></script>
 <script>
 const Foo = {
 template: `
 <div class="whole-page two">
 <router-link to="/foo/bar">下一层</router-link>
 <router-link to="/">返回</router-link>
 <h1>第二层</h1>
 <transition>
 <router-view></router-view>
 </transition>
 </div>
 `
 }
 const Bar = {
 template: `
 <div class="whole-page three">
 <router-link to="/foo">返回</router-link>
 <h1>第三层</h1>
 <transition>
 <router-view></router-view>
 </transition>
 </div>
 `
 }
 const routes = [ 
 { path: '/foo', component: Foo, children: [ { path: 'bar', component: Bar } ] }
 ]
 const router = new VueRouter({ routes })
 const app = new Vue({ router }).$mount('#app')
 </script>
</body>
</html>

效果:



有一个问题需要注意一下,

我们知道,在应用transform属性的时候,fixed定位会变成absolute。

这里,页面转换的时候,就变成了相对translation定位。所以如果子页面中有绝对定位的话,移动的过程中页面会变形。

简单举个栗子,

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no">
 <title>Document</title>
 <style>
* { padding: 0; margin: 0; }
html, body, #app { width: 100%; height: 100%; }
#app { padding-top: 50px; }
.one { height: 100%; background-color: yellow;}
.two { background-color: tomato; position: fixed; top: 100px; bottom: 0; left: 0; right: 0; }.v-enter-active, .v-leave-active { transition: all 0.3s; }
.v-enter, .v-leave-to { transform: translateX(100%); }
header { height: 50px; background-color: #000; width: 100%; position: fixed; top: 0; color: #fff; line-height: 50px; text-align: center; }
.two header { top: 50px; background-color: #666; }
 </style>
</head>
<body>
 <div id="app">
 <header>我是一个标题</header>
 <div class="one">
 <p>
 <router-link to="/foo">下一层</router-link>
 </p>
 <h1>第一层</h1>
 <transition>
 <router-view></router-view>
 </transition>
 </div>
 </div>
 
 <script src="https://unpkg.com/vue/dist/vue.js"></script>
 <script src="https://unpkg.com/vue-router/dist/vue-router.js"></script>
 <script>
 const Foo = {
 template: `
 <div class="whole-page two">
 <router-link to="/">返回</router-link>
 <header>我也是一个标题</header>
 <h1>第二层</h1>
 <transition>
 <router-view></router-view>
 </transition>
 </div>
 `
 }
 const routes = [ 
 { path: '/foo', component: Foo }
 ]
 const router = new VueRouter({ routes })
 const app = new Vue({ router }).$mount('#app')
 </script>
</body>
</html>

看下效果:



OKOK,反正就是这种bug嘛。

解决办法就是,就是,尽量让页面fixed定位都是0 0 0 0,然后偏移用padding实现。

大概吧……反正我是这么解决的……

比如上面那个可以把CSS改成这样解决问题。

* { padding: 0; margin: 0; }
html, body, #app { width: 100%; height: 100%; }
#app { padding-top: 50px; }
.one { height: 100%; background-color: yellow;}
.two { background-color: tomato; position: fixed; top: 0; padding-top: 100px; bottom: 0; left: 0; right: 0; }.v-enter-active, .v-leave-active { transition: all 0.3s; }
.v-enter, .v-leave-to { transform: translateX(100%); }
header { height: 50px; background-color: #000; width: 100%; position: fixed; top: 0; color: #fff; line-height: 50px; text-align: center; z-index: 100; }
.two header { top: 50px; background-color: #666; }

嗯嗯 还有一个问题,还有个滑动穿透的问题,(真开心! 这么多问题!

我再举个栗子,

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no">
 <title>Document</title>
 <style>
* { padding: 0; margin: 0; }
html, body, #app { width: 100%; height: 100%; }
.one { min-height: 100%; background-color: yellow;}
.two { background-color: tomato; position: fixed; top: 0; bottom: 0; left: 0; right: 0; }
.three { background-color: #ffe69f; position: fixed; top: 50px; bottom: 0; left: 0; right: 0; }
.v-enter-active, .v-leave-active { transition: all 0.3s; }
.v-enter, .v-leave-to { transform: translateX(100%); }
 </style>
</head>
<body>
 <div id="app">
 <div class="one">
 <p>
 <router-link to="/foo">下一层</router-link>
 </p>
 <h1>第一层</h1><h1>第一层</h1><h1>第一层</h1><h1>第一层</h1><h1>第一层</h1>
 <h1>第一层</h1><h1>第一层</h1><h1>第一层</h1><h1>第一层</h1><h1>第一层</h1>
 <h1>第一层</h1><h1>第一层</h1><h1>第一层</h1><h1>第一层</h1><h1>第一层</h1>
 <transition>
 <router-view></router-view>
 </transition>
 </div>
 </div>
 
 <script src="https://unpkg.com/vue/dist/vue.js"></script>
 <script src="https://unpkg.com/vue-router/dist/vue-router.js"></script>
 <script>
 const Foo = {
 template: `
 <div class="whole-page two">
 <router-link to="/">返回</router-link>
 <h1>第二层</h1>
 <transition>
 <router-view></router-view>
 </transition>
 </div>
 `
 }
 const routes = [ 
 { path: '/foo', component: Foo }
 ]
 const router = new VueRouter({ routes })
 const app = new Vue({ router }).$mount('#app')
 </script>
</body>
</html>

看效果,第二页的高度明明就是视窗的高度,但是它有一个滚动条,实际上那是第一个页面的滚动条。

网上找了好多方法,一一试了,全部不生效。(当然很有可能是我的方法不对。



最后没办法只有找最笨的方法啦,就是通过 v-if 把父页面不显示就好了。

当然不能直接不显示,因为动画还没结束父元素就空白了呀!setTimeout 就好了……

具体代码就不写了,这个应该很容易理解。

最后

以下是总结出来最全前端框架视频,包含: javascript/vue/react/angualrde/express/koa/webpack 等学习资料。

【领取方式】

关注头条 前端全栈架构丶第一时间获取最新前端资讯学习

手机用户可私信关键词 【前端】即可获取全栈工程师路线和学习资料!

寻找热爱表达的你#


"一键将网页截图制作成HTML网页"是指一种技术,它允许用户通过简单的操作,将网页的截图转换成HTML代码的网页。这通常涉及到自动布局、样式提取和代码生成。以下是实现这一功能的相关技术和步骤:

1. 截图捕捉:首先,需要有一个方法来捕捉网页的截图,这可以通过浏览器插件、屏幕捕获工具或专门的应用程序来完成。

2. 图像处理:捕捉到的截图可能需要进行预处理,比如裁剪、压缩或调整分辨率,以确保图像的质量。

3. 元素识别:使用图像识别技术来分析截图,识别网页中的元素,比如文本、按钮、图片等。

4. 布局分析:基于识别出的元素,分析页面的布局信息,包括元素的大小、位置和层级。

5. 样式解析:提取页面的样式信息,包括颜色、字体、间距等,并将它们转换为CSS代码。

6. HTML生成:根据布局和样式信息,生成HTML结构代码,将截图中的元素转换为HTML标签。

7. 代码优化:对生成的HTML代码进行优化,确保代码的可读性、维护性和性能。

8. 响应式设计:确保生成的网页代码能够适应不同的屏幕尺寸和设备,实现响应式布局。

9. 交互性实现:如果截图中的页面包含交互元素,需要添加相应的JavaScript代码来实现这些交互。

10. 一键操作:提供一个简单的用户界面,用户只需点击一个按钮,就可以完成截图到HTML的转换。

11. 预览功能:在转换过程中提供实时预览,让用户可以实时看到转换效果。

12. 自定义选项:允许用户对生成的HTML代码进行自定义,比如修改布局、添加额外的样式或功能。

13. 保存和导出:用户可以保存或导出生成的HTML代码,以便进一步使用或分享。

14. 错误处理:在转换过程中识别和处理潜在的错误,比如布局冲突或样式问题。

15. 兼容性测试:确保生成的网页在不同的浏览器和设备上都能正常显示和工作。

16. 安全性考虑:生成的代码应遵循安全最佳实践,避免潜在的安全风险。

17. 用户反馈:收集用户反馈,不断改进转换算法和用户体验。

18. 开源和社区支持:作为开源项目,鼓励社区参与贡献代码和改进功能。

这种一键转换技术可以大大提高网页开发的效率,尤其是对于快速原型设计和演示目的。然而,需要注意的是,自动生成的代码可能需要进一步的人工审查和调整,以确保最终产品的质量和性能。此外,一些复杂的网页效果和动态交互可能需要手动编写代码来实现。