对 CSS 布局掌握程度决定你在Web开发中的开发页面速度。随着Web技术的不断革新，实现各种布局的方式已经多得数不胜数了。
这里总结了四十二种CSS的常见布局，这四十二种布局可以细分为如下几类：

  • 水平居中
  • 垂直居中
  • 水平垂直居中
  • 两列布局
  • 三列布局
  • 等分布局
  • Sticky Footer布局
  • 全屏布局

这些内容也正是本篇文章的目录。

水平居中

实现水平布局比较简单，方法也比较多，这里总结了7种常用的布局方法，其公共的CSS代码如下所示：

  1. .parent { background: #ff8787; }
  2. .child { height: 300px; width: 300px; background: #e599f7; }

其 HTML 结构也是固定的，就是一个父级，其宽度继承了 <body> 的宽度，还有一个子级，这里是固定的300px*300px，代码如下：

  1. <div class="parent">
  2.   <div class="child"></div>
  3. </div>

上图中玫瑰色的块是父级，随页面宽度增加的；淡紫色是子级，相对于父级居中的。

1、使用text-align属性

若元素为行内块级元素，也就是 display: inline-block 的元素，可以通过为其父元素设置 text-align: center 实现水平居中。实现的CSS代码如下：

  1. .parent {
  2.   /* 对于子级为 display: inline-block; 可以通过 text-align: center; 实现水平居中 */
  3.   text-align: center;
  4. }
  6. .child {
  7.   display: inline-block;
  8. }

2、定宽块级元素水平居中(方法一)

对于定宽的的块级元素实现水平居中，最简单的一种方式就是 margin: 0 auto;，但是值得注意的是一定需要设置宽度。实现 CSS 代码如下：

  1. .child {
  2.   /* 对于定宽的子元素，直接 margin:0 auto; 即可实现水平居中 */
  3.   margin: 0 auto;
  4. }

3、定宽块级元素水平居中(方法二)

对于开启定位的元素，可以通过 left 属性 和 margin 实现。实现CSS代码如下：

  1. .child {
  2.   /* 开启定位 */
  3.   position: relative;
  4.   left: 50%;
  5.   /* margin-left 为 负的宽度的一半 */
  6.   margin-left: -150px;
  7. }

4、定宽块级元素水平居中(方法三)

当元素开启决定定位或者固定定位时， left 属性和 right 属性一起设置就会拉伸元素的宽度，在配合 width 属性与 margin 属性就可以实现水平居中。
实现 CSS 代码如下：

  1. .parent {
  2.   position: relative;
  3.   height: 300px;
  4. }
  6. .child {
  7.   /* 开启定位 父相子绝 */
  8.   position: absolute;
  9.   /* 水平拉满屏幕 */
  10.   left: 0;
  11.   right: 0;
  12.   width: 300px;
  13.   /* 拉满屏幕之后设置宽度，最后通过 margin 实现水平居中 */
  14.   margin: auto;
  15. }

5、定宽块级元素水平居中(方法四)

当元素开启决定定位或者固定定位时， left 属性和 transform 属性即可实现水平居中。
实现CSS代码如下：

  1. .parent {
  2.   position: relative;
  3. }
  5. .child {
  6.   /* 开启定位 */
  7.   position: absolute;
  8.   /* 该方法类似于 left 于 -margin 的用法，但是该方法不需要手动计算宽度。 */
  9.   left: 50%;
  10.   transform: translateX(-50%);
  11. }

6、Flex方案

通过 Flex 可以有很多方式实现这个居中布局的效果。
实现 CSS 代码如下

  1. .parent {
  2.   height: 300px;
  3.   /* 开启 Flex 布局 */
  4.   display: flex;
  5.   /* 通过 justify-content 属性实现居中 */
  6.   justify-content: center;
  7. }
  9. .child {
  10.   /* 或者 子元素 margin: auto*/
  11.   margin: auto;
  12. }

7、Grid方案

通过Grid实现居中布局比通过Flex实现的方式更多一些。
实现CSS代码如下：

  1. .parent {
  2.   height: 300px;
  3.   /* 开启 Grid 布局 */
  4.   display: grid;
  5.   /* 方法一 */
  6.   justify-items: center;
  7.   /* 方法二 */
  8.   justify-content: center;
  9. }
  11. .child {
  12.   /* 方法三 子元素 margin: auto*/
  13.   margin: auto;
  14. }

以上就是水平居中布局常用的几种方式。

垂直居中

实现垂直布局也是比较简单的，方法也比较多，这里总结了6种常用的布局方法，其公共的 CSS 代码如下所示：

  1. .parent {
  2.   height: 500px;
  3.   width: 300px;
  4.   margin: 0 auto;
  5.   background-color: #ff8787;
  6. }
  7. .child {
  8.   width: 300px;
  9.   height: 300px;
  10.   background-color: #91a7ff;
  11. }

其 HTML 结构也是固定的，就是一个父级包裹一个子级，这里的子级是固定的300px*300px，代码如下：

  1. <div class="parent">
  2.   <div class="child"></div>
  3. </div>

1、行内块级元素垂直居中

若元素是行内块级元素, 基本思想是子元素使用display: inline-block, vertical-align: middle;并让父元素行高等同于高度。
实现CSS代码如下：

  1. .parent {
  2.   /* 为父级容器设置行高 */
  3.   line-height: 500px;
  4. }
  6. .child {
  7.   /* 将子级元素设置为 inline-block 元素 */
  8.   display: inline-block;
  9.   /* 通过 vertical-align: middle; 实现居中 */
  10.   vertical-align: middle;
  11. }

2、定位方式实现(方法一)

第一种通过定位的方式实现就比较简单，实际就是通过top: 50%; margin-top: 等于负的高度的一半就可以实现垂直居中。
实现CSS代码如下：

  1. .parent {
  2.   /* 为父级容器开启相对定位 */
  3.   position: relative;
  4. }
  6. .child {
  7.   position: absolute;
  8.   top: 50%;
  9.   /* margin-top: 等于负高度的一半 */
  10.   margin-top: -150px;
  11. }

3、定位方式实现(方法二)

第二种通过定位的方式实现实现思路：top 和 bottom 将子元素拉伸至100%，设置指定的高度，通过margin:auto;即可实现垂直居中。
实现CSS代码如下：

  1. .parent {
  2.   /* 为父级容器开启相对定位 */
  3.   position: relative;
  4. }
  6. .child {
  7.   height: 300px;
  8.   position: absolute;
  9.   /* 垂直拉满 */
  10.   top: 0;
  11.   bottom: 0;
  12.   /* margin: auto 即可实现 */
  13.   margin: auto;
  14. }

4、定位方式实现(方法三)

第三种通过定位的方式就比较灵活，适用于多种场合，使用 top 配合 tansform 即可。
实现CSS代码如下：

  1. .parent {
  2.   /* 为父级容器开启相对定位 */
  3.   position: relative;
  4. }
  6. .child {
  7.   position: absolute;
  8.   top: 50%;
  9.   transform: translateY(-50%);
  10. }

5、Flex方案

通过 Flex 可以有很多方式实现这个垂直居中布局的效果。
实现CSS代码如下：

  1. .parent {
  2.   /* 开启 flex 布局 */
  3.   display: flex;
  4.   /* 方法一 */
  5.   /* align-items: center; */
  6. }
  8. .child {
  9.   /* 方法二 */
  10.   margin: auto;
  11. }

通过 Flex 布局实现不仅仅只有上面两种，这里只介绍最简单的方式。

6、Grid方案

通过 Grid 实现居中布局比通过 Flex 实现的方式更多一些。
实现CSS代码如下：

  1. .parent {
  2.   display: grid;
  3.   /* 方法一 */
  4.   /* align-items: center; */
  5.   /* 方法二 */
  6.   /* align-content: center; */
  7. }
  9. .child {
  10.   /* 方法三 */
  11.   /* margin: auto; */
  12.   /* 方法四 */
  13.   align-self: center;
  14. }

以上就是垂直居中布局常用的几种方式。

水平垂直居中

实现水平垂直布局基本就是将上面几种方式结合使用，这里总结了7种常用的布局方法，其公共的 CSS 代码如下所示：

  1. body {
  2.   margin: 0;
  3. }
  4. .parent {
  5.   height: 500px;
  6.   width: 500px;
  7.   background-color: #eebefa;
  8.   margin: 0 auto;
  9. }
  10. .child {
  11.   height: 300px;
  12.   width: 300px;
  13.   background-color: #f783ac;
  14. }

其 HTML 结构也是固定的，就是一个父级包裹一个子级，这里的子级是固定的300px*300px，代码如下：

  1. <div class="parent">
  2.   <div class="child"></div>
  3. </div>

1、行内块级水平垂直居中方案

步骤如下：

  • 容器元素行高等于容器高度
  • 通过 text-align: center; 实现水平居中
  • 将子级元素设置为水平块级元素
  • 通过 vertical-align: middle; 实现垂直居中

实现CSS代码如下：

  1. .parent {
  2.   /* 1. 设置行高等于容器高度 */
  3.   line-height: 500px;
  4.   /* 通过 text-align: center; 实现水平居中 */
  5.   text-align: center;
  6. }
  7. .child {
  8.   /* 将子级元素设置为水平块级元素 */
  9.   display: inline-block;
  10.   /* 通过 vertical-align: middle; 实现垂直居中 */
  11.   vertical-align: middle;
  12. }

2、定位实现水平垂直居中方案(一)

步骤如下：

  • 使子元素相对于容器元素定位
  • 子元素开启绝对定位
  • 设置该元素的偏移量，值为50% 减去宽度/高度的一半

实现CSS代码如下：

  1. .parent {
  2.   /* 1. 使子元素相对于本元素定位 */
  3.   position: relative;
  4. }
  5. .child {
  6.   /* 2. 开启绝对定位 */
  7.   position: absolute;
  8.   /* 3. 设置该元素的偏移量，值为 50%减去宽度/高度的一半 */
  9.   left: calc(50% - 150px);
  10.   top: calc(50% - 150px);
  11. }

3、定位实现水平垂直居中方案(二)

步骤如下：

  • 使子元素相对于容器元素定位
  • 子元素开启绝对定位
  • 设置该元素的偏移量，值为50%
  • 通过外边距-值的方式将元素移动回去

实现CSS代码如下：

  1. .parent {
  2.   /* 1. 使子元素相对于本元素定位 */
  3.   position: relative;
  4. }
  5. .child {
  6.   /* 2. 开启绝对定位 */
  7.   position: absolute;
  8.   /* 3. 设置该元素的偏移量，值为 50% */
  9.   left: 50%;
  10.   top: 50%;
  11.   margin-left: -150px;
  12.   margin-top: -150px;
  13. }

4、定位实现水平垂直居中方案(三)

步骤如下：

  • 使子元素相对于容器元素定位
  • 子元素开启绝对定位
  • 将子元素拉满整个容器
  • 通过margin:auto实现水平垂直居中

实现CSS代码如下：

  1. .parent {
  2.   /* 1. 使子元素相对于本元素定位 */
  3.   position: relative;
  4. }
  5. .child {
  6.   /* 2. 开启绝对定位 */
  7.   position: absolute;
  8.   /* 3. 将子元素拉满整个容器 */
  9.   top: 0;
  10.   left: 0;
  11.   right: 0;
  12.   bottom: 0;
  13.   /* 4. 通过 margin:auto 实现水平垂直居中 */
  14.   margin: auto;
  15. }

5、定位实现水平垂直居中方案(四)

步骤如下：

  • 使子元素相对于容器元素定位
  • 子元素开启绝对定位
  • 设置该元素的偏移量，值为50%
  • 通过 translate 反向偏移的方式，实现居中

实现 CSS 代码如下：

  1. .parent {
  2.   /* 1. 使子元素相对于本元素定位 */
  3.   position: relative;
  4. }
  5. .child {
  6.   /* 2. 开启绝对定位 */
  7.   position: absolute;
  8.   /* 3. 设置该元素的偏移量，值为 50%*/
  9.   left: 50%;
  10.   top: 50%;
  11.   /* 通过translate反向偏移的方式，实现居中 */
  12.   transform: translate(-50%, -50%);
  13. }

6、Flex方案

步骤如下：

  • 将元素设置为 Flex 布局
  • 通过 justify-content: center 以及 align-items: center 实现或者 margin: auto; 实现。

实现CSS代码如下：

  1. .parent {
  2.   /* 1. 将元素设置为 Flex 布局 */
  3.   display: flex;
  4.   /* 2. 通过 justify-content 以及 align-items: center 实现 */
  5.   /* justify-content: center;
  6.   align-items: center; */
  7. }
  8. .child {
  9.   /* 或者通过 margin auto 实现 */
  10.   margin: auto;
  11. }

7、Grid方案

Grid 方案的实现方式相对来说比较简单，方式也较多。
实现CSS代码如下：

  1. .parent {
  2.   /* 1. 元素设置为Grid 元素 */
  3.   display: grid;
  4.   /* 通过 items 属性实现*/
  5.   /* align-items: center; */
  6.   /* justify-items: center; */
  7.   /* items 的缩写 */
  8.   /* place-items: center; */
  10.   /* 或者通过 content 属性 */
  11.   /* align-content: center; */
  12.   /* justify-content: center; */
  13.   /* content 的缩写 */
  14.   /* place-content: center; */
  15. }
  16. .child {
  17.   /* 或者通过 margin auto 实现 */
  18.   /* margin: auto; */
  19.   /* 或者通过 self 属性 */
  20.   /* align-self: center;
  21.   justify-self: center; */
  22.   /* self 的缩写 */
  23.   place-self: center;
  24. }

实现水平垂直居中布局的方式大多是通过上面两种布局的方式相结合。

两列布局

所谓的两列布局就是一列定宽(也有可能由子元素决定宽度)，一列自适应的布局。最终效果如下所示：
image.png
这里用到的 HTML 结构如下：

  1. <!-- 解决高度塌陷 -->
  2. <div class="container clearfix">
  3.   <div class="left">定宽</div>
  4.   <div class="right">自适应</div>
  5. </div>

公共的 CSS 代码如下:

  1. body {
  2.   margin: 0;
  3. }
  4. .container {
  5.   height: 400px;
  6.   background-color: #eebefa;
  7. }
  8. .left {
  9.   height: 400px;
  10.   width: 200px;
  11.   background-color: #f783ac;
  12.   font-size: 70px;
  13.   line-height: 400px;
  14.   text-align: center;
  15. }
  16. .right {
  17.   height: 400px;
  18.   background-color: #c0eb75;
  19.   font-size: 70px;
  20.   line-height: 400px;
  21. }
  22. /* 清除浮动 */
  23. .clearfix:after {
  24.   content: '';
  25.   display: block;
  26.   height: 0;
  27.   clear: both;
  28.   visibility: hidden;
  29. }

1、float+calc()函数完成左列定宽右列自适应

步骤如下：

  • 左边列开启浮动
  • 右边列开启浮动
  • 右边列宽度为父级 100%减去左列的宽度

实现CSS代码如下：

  1. .left {
  2.   /* 左边列开启浮动 */
  3.   float: left;
  4. }
  5. .right {
  6.   /* 右边列开启浮动 */
  7.   float: left;
  8.   /* 宽度减去左列的宽度 */
  9.   width: calc(100% - 200px);
  10. }

2、float+margin-left完成左列定宽右列自适应

步骤如下：

  • 左边列开启浮动
  • 通过外边距的方式使该容器的左边有左边列容器的宽度的外边距

实现CSS代码如下：

  1. .left {
  2.   /* 左边列开启浮动 */
  3.   float: left;
  4. }
  5. .right {
  6.   /* 通过外边距的方式使该容器的左边有200px */
  7.   margin-left: 200px;
  8. }

3、absolute+margin-left完成左列定宽右列自适应

步骤如下：

  • 开启定位脱离文档流
  • 通过外边距的方式使该容器的左边有左边列容器的宽度的外边距

实现CSS代码如下：

  1. .left {
  2.   /* 开启定位脱离文档流 */
  3.   position: absolute;
  4. }
  5. .right {
  6.   /* 通过外边距的方式使该容器的左边有200px */
  7.   margin-left: 200px;
  8. }

值得注意的是 以上几种方案左边列必须定宽，才可以实现，下面这几种方案左边列可以由子级撑起。

4、float+overflow完成左列定宽右列自适应

步骤如下：

  • 左侧元素开始浮动
  • 右侧自适应元素设置overflow会创建一个BFC完成自适应

实现CSS代码如下：

  1. .left {
  2.   /* 1. 左侧元素开始浮动 */
  3.   float: left;
  4. }
  5. .right {
  6.   /* 2. 右侧自适应元素设置 overflow 会创建一个BFC 完成自适应 */
  7.   overflow: hidden;
  8. }

5、Flex方案

通过Flex布局实现该功能主要是通过 flex 属性来实现示例代码如下：

  1. .container {
  2.   display: flex;
  3. }
  4. .right {
  5.   flex: 1;
  6.   /* flex: 1; 表示 flex-grow: 1; 即该项占所有剩余空间 */
  7. }

6、Grid方案

通过 Grid 布局实现该功能主要是通过template属性实现，具体代码如下所示：

  1. .container {
  2.   display: grid;
  3.   /* 将其划分为两行，其中一列有本身宽度决定， 一列占剩余宽度*/
  4.   grid-template-columns: auto 1fr;
  5. }

三列布局

三列布局主要分为两种：

  • 第一种是前两列定宽，最后一列自适应，这一种本质上与两列布局没有什么区别，可以参照两列布局实现。
  • 第二种是前后两列定宽，中间自适应

公共 CSS 如下：

  1. body {
  2.   margin: 0;
  3. }
  4. .container {
  5.   height: 400px;
  6.   background-color: #eebefa;
  7. }
  8. .left {
  9.   height: 400px;
  10.   width: 200px;
  11.   background-color: #f783ac;
  12. }
  13. .content {
  14.   height: 400px;
  15.   background-color: #d9480f;
  16. }
  17. .right {
  18.   height: 400px;
  19.   width: 200px;
  20.   background-color: #c0eb75;
  21. }
  22. .left,
  23. .content,
  24. .right {
  25.   font-size: 70px;
  26.   line-height: 400px;
  27.   text-align: center;
  28. }
  29. /* 清除浮动 */
  30. .clearfix:after {
  31.   content: '';
  32.   display: block;
  33.   height: 0;
  34.   clear: both;
  35.   visibility: hidden;
  36. }

HTML 结构如下：

  1. <!-- 解决高度塌陷 -->
  2. <div class="container clearfix">
  3.   <div class="left">左</div>
  4.   <div class="content">内容</div>
  5.   <div class="right">右</div>
  6. </div>

1、通过float实现(一)

实现步骤：

  • 为了完成效果需要调整HTML结构，调整后如下：

    1. <!-- 解决高度塌陷 -->
    2. <div class="container clearfix">
    3. <div class="left">左</div>
    4. <div class="right">右</div>
    5. <div class="content">内容</div>
    6. </div>

  • 左列容器开启左浮动

  • 右列容器开启右浮动
  • 自适应元素设置overflow会创建一个BFC完成自适应

实现CSS代码如下

  1. .left {
  2.   /* 1. 左列容器开启左浮动 */
  3.   float: left;
  4. }
  5. .content {
  6.   /* 自适应元素设置 overflow 会创建一个BFC 完成自适应 */
  7.   overflow: hidden;
  8. }
  9. .right {
  10.   /* 2. 右列容器开启右浮动 */
  11.   float: right;
  12. }

2、通过float实现(二)

实现步骤：

  • 为了完成效果需要调整 HTML 结构，调整后如下：

    1. <!-- 解决高度塌陷 -->
    2. <div class="container clearfix">
    3. <div class="left">左</div>
    4. <div class="right">右</div>
    5. <div class="content">内容</div>
    6. </div>

  • 左列容器开启左浮动

  • 右列容器开启右浮动
  • 使中间自适应的宽度为父级容器减去两个定宽的列

实现CSS代码如下：

  1. .left {
  2.   /* 1. 左列容器开启左浮动 */
  3.   float: left;
  4. }
  5. .content {
  6.   /* 3. 使中间自适应的宽度为父级容器减去两个定宽的列 */
  7.   width: calc(100%-400px);
  8. }
  9. .right {
  10.   /* 2. 右列容器开启右浮动 */
  11.   float: right;
  12. }

3、通过position实现

实现步骤

  • 左右两列脱离文档流，并通过偏移的方式到达自己的区域
  • 使中间自适应的宽度为父级容器减去两个定宽的列
  • 通过外边距将容器往内缩小

实现CSS代码如下：

  1. .left {
  2.   /* 1. 左右两列脱离文档流，并通过偏移的方式到达自己的区域 */
  3.   position: absolute;
  4.   left: 0;
  5.   top: 0;
  6. }
  7. .content {
  8.   /* 2. 使中间自适应的宽度为父级容器减去两个定宽的列 */
  9.   width: calc(100%-400px);
  10.   /* 3. 通过外边距将容器往内缩小 */
  11.   margin-right: 200px;
  12.   margin-left: 200px;
  13. }
  14. .right {
  15.   position: absolute;
  16.   right: 0;
  17.   top: 0;
  18. }

4、Flex方案

通过 Flex 布局实现该功能主要是通过 flex 属性来实现。
实现CSS代码如下：

  1. .container {
  2.   display: flex;
  3. }
  4. .right {
  5.   flex: 1;
  6.   /* flex: 1; 表示 flex-grow: 1; 即该项占所有剩余空间 */
  7. }

5、Grid方案

通过 Grid 布局实现该功能主要是通过 template 属性实现。
实现CSS代码如下：

  1. .container {
  2.   display: grid;
  3.   /* 将其划分为两行，其中一列有本身宽度决定， 一列占剩余宽度*/
  4.   grid-template-columns: auto 1fr auto;
  5. }

等分布局

等分布局就是将一个容器平均分成几等份，这里以 4 等分为例，主要介绍4种方法。
公共CSS部分如下：

  1. body {
  2.   margin: 0;
  3. }
  4. .container {
  5.   height: 400px;
  6.   background-color: #eebefa;
  7. }
  8. .item {
  9.   height: 100%;
  10. }
  11. .item1 {
  12.   background-color: #eccc68;
  13. }
  14. .item2 {
  15.   background-color: #a6c1fa;
  16. }
  17. .item3 {
  18.   background-color: #fa7d90;
  19. }
  20. .item4 {
  21.   background-color: #b0ff70;
  22. }
  23. /* 清除浮动 */
  24. .clearfix:after {
  25.   content: '';
  26.   display: block;
  27.   height: 0;
  28.   clear: both;
  29.   visibility: hidden;
  30. }

公共HTML代码如下：

  1. <!-- 父元素清除浮动 -->
  2. <div class="container clearfix">
  3.   <div class="item item1"></div>
  4.   <div class="item item2"></div>
  5.   <div class="item item3"></div>
  6.   <div class="item item4"></div>
  7. </div>

1、浮动+百分比方式

这种方式比较简单，开启浮动，使每个元素占25%的宽度。
实现CSS代码如下：

  1. .item {
  2.   /* 开启浮动，每个元素占 25% 的宽度 */
  3.   width: 25%;
  4.   float: left;
  5. }

2、行内块级+百分比方式

这种方式与上面那种方式类似，不过需要注意的是行内块级元素有一些类似于边距的几个像素，导致各25%会超出容器。
实现CSS代码如下：

  1. .item {
  2.   /* 设置每个元素为行内块级元素，每个元素占 24.5% 的宽度 */
  3.   width: 24.5%;
  4.   /* 因为行内块级元素有一些类似于边距的几个像素，导致各占25会超出容器 */
  5.   display: inline-block;
  6. }

3、Flex方案

通过 Flex 布局实现该功能主要是通过 flex 属性来实现。
实现CSS代码如下：

  1. .container {
  2.   /* 开启 flex 布局 */
  3.   display: flex;
  4. }
  5. .item {
  6.   /* 每个元素占相同的宽度 */
  7.   flex: 1;
  8. }

4、Grid方案

通过 Grid 布局实现该功能主要是通过 template 属性实现。
实现CSS代码如下

  1. .container {
  2.   /* 开启 grid 布局 */
  3.   display: grid;
  4.   grid-template-columns: repeat(4, 1fr);
  5.   /* 使用 repeat 函数生成如下代码 */
  6.   /* grid-template-columns: 1fr 1fr 1fr 1fr; */
  7. }

Sticky Footer布局

所谓的 Sticky Footer 布局并不是一种新的前端技术和概念，它就是一种网页布局。如果页面内容不够长时，底部栏就会固定到浏览器的底部；如果足够长时，底部栏就后跟随在内容的后面。
这里来介绍实现该布局的4种方式
公共的CSS代码如下：

  1. body {
  2.   margin: 0;
  3. }
  4. .container {
  5.   height: 400px;
  6.   display: flex;
  7. }
  8. .left {
  9.   height: 400px;
  10.   width: 200px;
  11.   background-color: #f759ab;
  12. }
  13. .content {
  14.   height: 400px;
  15.   background-color: #52c41a;
  16.   flex: 1;
  17. }
  18. .right {
  19.   height: 400px;
  20.   width: 200px;
  21.   background-color: #f759ab;
  22. }
  23. .left,
  24. .content,
  25. .right {
  26.   font-size: 70px;
  27.   line-height: 400px;
  28.   text-align: center;
  29. }
  30. .header {
  31.   height: 100px;
  32.   background-color: #70a1ff;
  33. }
  34. .footer {
  35.   height: 100px;
  36.   background-color: #ff7a45;
  37. }
  38. .header,
  39. .footer {
  40.   line-height: 100px;
  41.   font-size: 52px;
  42.   text-align: center;
  43. }

公共的HTML如下：

  1. <div class="main">
  2.   <div class="header">header</div>
  3.   <div class="container">
  4.     <div class="left">left</div>
  5.     <div class="content">content</div>
  6.     <div class="right">right</div>
  7.   </div>
  8.   <div class="footer">footer</div>
  9. </div>

1、绝对定位的方式

通过绝对定位的方式实现Sticky Footer布局的步骤如下：

  • 设置最外层容器高度为100%；
  • 让子元素元素相对于容器元素进行定位，并设置容器元素最小高度为100%；
  • 在中间区域设置padding-bottom为footer的高度 ；
  • 底部栏绝对定位，并一直吸附在底部即可实现。

实现CSS代码如下：

  1. /* 1. 设置最外层容器为100% */
  2. html,
  3. body {
  4.   height: 100%;
  5. }
  6. /* 2. 让子元素元素相对于容器元素进行定位，并设置容器元素最小高度为100% */
  7. .main {
  8.   position: relative;
  9.   min-height: 100%;
  10. }
  11. /* 3. 在中间区域设置 padding-bottom 为footer 的高度 */
  12. .container {
  13.   padding-bottom: 100px;
  14. }
  15. /* 由于开启了绝对定位，宽度成了自适应，设置为100% bottom:0 始终保持底部 */
  16. .footer {
  17.   position: absolute;
  18.   width: 100%;
  19.   bottom: 0;
  20. }

2、使用calc函数实现

使用 calc 函数实现的方式会比较简单，中间的容器最少高度为视口宽度的100% - 头部和底部两部分的高度即可完成该功能。
实现CSS代码如下：

  1. .container {
  2.   /* 这里的 中间 部分的容器最少为视口宽度的 100% - 头部和底部两部分的高度即可完成该功能 */
  3.   min-height: calc(100vh - 200px);
  4. }

3、Flex方案

实现步骤如下

  • 开启 flex 布局
  • 将子元素布局方向修改为垂直排列
  • 设置最小高度为当前视口，使不管中间部分有多高，始终都可以保持在底部
  • 设置中间部分容器高度为自适应

实现CSS代码如下：

  1. .main {
  2.   /* 开启flex布局 */
  3.   display: flex;
  4.   /* 将子元素布局方向修改为垂直排列 */
  5.   flex-flow: column;
  6.   /* 设置最小高度为当前视口，使不管中间部分有多高，始终都可以保持在底部 */
  7.   min-height: 100vh;
  8. }
  9. .container {
  10.   /* 设置 中间 部分自适应 */
  11.   flex: 1;
  12. }

4、Grid方案

实现步骤如下

  • 开启 grid 布局
  • 置最小高度为当前视口，使不管中间部分有多高，始终都可以保持在底部

实现CSS代码如下：

  1. .main {
  2.   /* 开启grid布局 */
  3.   display: grid;
  4.   grid-template-rows: auto 1fr auto;
  5.   /* 设置最小高度为当前视口，使不管中间部分有多高，始终都可以保持在底部 */
  6.   min-height: 100vh;
  7. }

全屏布局

全部布局主要应用在后台，这里介绍三种全屏布局的实现方法。
公共的CSS代码如下：

  1. body {
  2.   margin: 0;
  3. }
  4. body,
  5. html,
  6. .container {
  7.   height: 100vh;
  8.   box-sizing: border-box;
  9.   text-align: center;
  10.   overflow: hidden;
  11. }
  12. .content {
  13.   background-color: #52c41a;
  14.   /* * 中间部门的布局可以参考 两列 三列 布局 */
  15.   display: grid;
  16.   grid-template-columns: auto 1fr;
  17. }
  18. .left {
  19.   width: 240px;
  20.   background-color: #52c41a;
  21.   font-size: 80px;
  22.   line-height: calc(100vh - 200px);
  23. }
  24. .right {
  25.   background-color: #f759ab;
  26.   font-size: 60px;
  27. }
  28. .header {
  29.   height: 100px;
  30.   background-color: #70a1ff;
  31. }
  32. .footer {
  33.   height: 100px;
  34.   background-color: #ff7a45;
  35. }
  36. .header,
  37. .footer {
  38.   line-height: 100px;
  39.   font-size: 52px;
  40. }

HTML结构如下：

  1. <div class="container">
  2.   <div class="header">header</div>
  3.   <div class="content">
  4.     <div class="left">导航</div>
  5.     <div class="right">
  6.       <div class="right-in">自适应，超出高度出现滚动条</div>
  7.     </div>
  8.   </div>
  9.   <div class="footer">footer</div>
  10. </div>

1、使用calc函数实现

实现步骤如下：

  • 通过 calc 函数计算出中间容器的高度。
  • 中间出现滚动条的容器设置overflow: auto即出现滚动条的时候出现滚动条。

实现CSS代码如下：

  1. .content {
  2.   overflow: hidden;
  3.   /* 通过 calc 计算容器的高度 */
  4.   height: calc(100vh - 200px);
  5. }
  6. .left {
  7.   height: 100%;
  8. }
  9. .right {
  10.   /* 如果超出出现滚动条 */
  11.   overflow: auto;
  12.   height: 100%;
  13. }
  14. .right-in {
  15.   /* 假设容器内有500px的元素 */
  16.   height: 500px;
  17. }

2、Flex 方案

使用 Flex 方式实现该布局比较简单。
实现CSS代码如下

  1. .container {
  2.   /* 开启flex布局 */
  3.   display: flex;
  4.   /* 将子元素布局方向修改为垂直排列 */
  5.   flex-flow: column;
  6. }
  7. .content {
  8.   /* 如果超出出现滚动条 */
  9.   overflow: auto;
  10.   /* 设置 中间 部分自适应 */
  11.   flex: 1;
  12. }
  13. .right-in {
  14.   /* 假设容器内有500px的元素 */
  15.   height: 500px;
  16. }

3、Grid 方案

grid布局对于这种布局来说，实现起来是非常得心应手的，通过template属性即可实现。
实现CSS代码如下

  1. .container {
  2.   /* 开启grid布局 */
  3.   display: grid;
  4.   grid-template-rows: auto 1fr auto;
  5. }
  6. .content {
  7.   /* 如果超出出现滚动条 */
  8.   overflow: auto;
  9. }
  10. .right-in {
  11.   /* 假设容器内有500px的元素 */
  12.   height: 500px;
  13. }