精华内容
参与话题
问答
  • Flex

    千次阅读 2017-03-05 16:51:48
    Flex应运而生,它可以简便、完整、响应式地实现各种页面布局。 Chrome 21,FF22,IE 10,Safari 6.1及以上的浏览器都支持FlexFlex布局将成为未来布局的首选方案。基本概念任何一个容器都可以指定为Flex

    传统的网页布局基于盒装模型,使用display,position,float属性来达成各种布局。
    对于一些特殊的布局使用这些来实现不是很方便,比如垂直居中。
    Flex应运而生,它可以简便、完整、响应式地实现各种页面布局。
    Chrome 21,FF22,IE 10,Safari 6.1及以上的浏览器都支持Flex。
    Flex布局将成为未来布局的首选方案。

    基本概念

    任何一个容器都可以指定为Flex布局。
    块级元素:

    .box{
      display: -webkit-flex; /* Safari chrome*/
      display: flex;
    }

    行内元素:

    .box{
      display: -webkit-inline-flex;
      display: inline-flex;
    }

    设为Flex布局以后,子元素的float、clear和vertical-align属性将失效。
    采用Flex布局的元素,称为Flex容器(flex container)。它的所有子元素自动成为容器成员,称为Flex项目(flex item)。
    容器默认存在两根轴:水平的主轴(main axis)和垂直的交叉轴(cross axis)。主轴的开始位置(与边框的交叉点)叫做main start,结束位置叫做main end;交叉轴的开始位置叫做cross start,结束位置叫做cross end。
    项目默认沿主轴排列。单个项目占据的主轴空间叫做main size,占据的交叉轴空间叫做cross size。

    容器的属性

    以下6个属性设置在容器上,用来控制容器中项目的排列方式和位置:

    • flex-direction
    • flex-wrap
    • flex-flow
    • justify-content
    • align-items
    • align-content

    flex-direction

    flex-direction属性决定主轴的方向(即项目的排列方向)。

    .box {
      flex-direction: row | row-reverse | column | column-reverse;
    }

    它可能有4个值。

    • row(默认值):主轴为水平方向,起点在左端。
    • row-reverse:主轴为水平方向,起点在右端。
    • column:主轴为垂直方向,起点在上沿。
    • column-reverse:主轴为垂直方向,起点在下沿。

    flex-wrap

    默认情况下,项目都排在一条线(又称”轴线”)上。flex-wrap属性定义,如果一条轴线排不下,如何换行。

    .box{
      flex-wrap: nowrap | wrap | wrap-reverse;
    }

    它可能取三个值

    • nowrap(默认):不换行。
    • wrap:换行,第一行在上方,或者第一列在左
    • wrap-reverse:换行,第一行在下方,或者第一列在右

    flex-flow

    flex-flow属性是flex-direction属性和flex-wrap属性的简写形式,默认值为row nowrap。

    justify-content

    justify-content属性定义了项目在主轴上的对齐方式。注意,主轴可能是水平的也可能是垂直的。

    .box {
      justify-content: flex-start | flex-end | center | space-between | space-around;
    }

    它可能取5个值,具体对齐方式与轴的方向有关。下面假设主轴为从左到右,其他方向类比即可:

    • flex-start(默认值):左对齐
    • flex-end:右对齐
    • center: 居中
    • space-between:两端对齐,项目之间的间隔都相等。
    • space-around:每个项目两侧的间隔相等。所以,项目之间的间隔比项目与边框的间隔大一倍。

    align-items

    align-items属性定义项目在交叉轴上如何对齐,交叉轴是和主轴垂直的轴

    .box {
      align-items: flex-start | flex-end | center | baseline | stretch;
    }
    • flex-start:交叉轴的起点对齐。
    • flex-end:交叉轴的终点对齐。
    • center:交叉轴的中点对齐。
    • baseline: 项目的第一行文字的基线对齐。
    • stretch(默认值):如果项目未设置高度或设为auto,将占满整个容器的高度。

    align-content

    align-content属性定义了多根轴线的对齐方式。这个和之前的align-items不太一样,后者是规定元素相对本轴线的行为,

    .box {
      align-content: flex-start | flex-end | center | space-between | space-around | stretch;
    }

    该属性可能取6个值:

    • flex-start:与交叉轴的起点对齐。
    • flex-end:与交叉轴的终点对齐。
    • center:与交叉轴的中点对齐。
    • space-between:与交叉轴两端对齐,轴线之间的间隔平均分布。
    • space-around:每根轴线两侧的间隔都相等。所以,轴线之间的间隔比轴与边框的间隔大一倍。
    • stretch(默认值):轴线占满整个交叉轴。

    项目的属性

    以下6个属性设置在项目上,用来设置项目的大小,对齐,次序等:

    • order
    • flex-grow
    • flex-shrink
    • flex-basis
    • flex
    • align-self

    order

    order属性定义项目的排列顺序。数值越小,排列越靠前,当然,这个前是相对于主轴顺序来说的,默认值为0。

    .item {
      order: <integer>;
    }

    flex-grow

    flex-grow属性定义项目的放大比例,默认为0,即如果存在剩余空间,也不放大。
    如果所有项目的flex-grow属性都为x,则它们将等分剩余空间(如果有的话,值为0的元素不参加等分)。如果一个项目的flex-grow属性为2x,其他项目都为x,则前者占据的剩余空间将比其他项多一倍。

    flex-shrink

    flex-shrink属性定义了项目的缩小比例,默认为1,即如果空间不足,该项目将缩小。
    如果所有项目的flex-shrink属性都为1,当空间不足时,都将等比例缩小。如果一个项目的flex-shrink属性为0,其他项目都为1,则空间不足时,前者不缩小。

    flex-basis

    flex-basis属性定义了在分配多余空间之前,项目占据的主轴空间(main size)。浏览器根据这个属性,计算主轴是否有多余空间。它的默认值为auto,即项目的本来大小。
    它可以设为跟width(主轴横向)或height属性一样的值,则项目将占据固定空间。

    flex

    flex属性是flex-grow, flex-shrink 和 flex-basis的简写,默认值为0 1 auto。后两个属性可选。
    该属性有两个快捷值:auto (1 1 auto) 和 none (0 0 auto)。
    建议优先使用这个属性,而不是单独写三个分离的属性,因为浏览器会推算相关值。这点一定要注意,你设置flex-grow:1和flex:1效果不一样的。

    align-self

    align-self属性允许单个项目有与其他项目不一样的对齐方式,可覆盖align-items属性。默认值为auto,表示继承父元素的align-items属性,如果没有父元素,则等同于stretch。

    .item {
      align-self: auto | flex-start | flex-end | center | baseline | stretch;
    }

    该属性可能取6个值,除了auto,其他都与align-items属性完全一致。

    实例

    骰子布局

    我们的骰子和骰子上的点的结构是这样的:

    <div class="one-container">
        <div class="point"></div>
        <div class="point"></div>
        <!--...-->
    </div>

    骰子的公共样式:

    div{
      display: flex;
      width:104px;
      height:104px;
      margin:16px;
      padding:4px;
      background-color: #e7e7e7;
      box-shadow:
              inset 0 5px white,
              inset 0 -5px #bbb,
              inset 5px 0 #d7d7d7,
              inset -5px 0 #d7d7d7;
      border-radius: 10%;
      .point{
        width: 24px;
        height: 24px;
        border-radius: 50%;
        margin: 4px;
        background-color: #333;
        box-shadow: inset 0 3px #111, inset 0 -3px #555;
      }
    }

    左上一个点

    Flex布局默认就是首行左对齐,所以啥都不用写,里面放一个point就好。

    中上一个点

    设置项目在主轴上的对齐方式可以调整点的水平位置:

    .one-container{
      //top center
      justify-content:center;
    }

    右上一个点

    同理

    .one-container{
      //top right
      justify-content:flex-end;
    }

    中间行,下行一个点

    设置项目在交叉轴上的对齐方式,可以将点移到中间行和最下行,再配合刚才的justify-content,9个位置的单独点就都可以达成了。

    .one-container{
      //top left
    
      //top center
      justify-content:center;
    
      //top right
      justify-content:flex-end;
    
      //center left
      align-items:center;
    
      //center center
      align-items:center;
      justify-content:center;
    
      //center right
      align-items:center;
      justify-content:flex-end;
    
      //bottom left
      align-items:flex-end;
    
      //bottom center
      align-items:flex-end;
      justify-content:center;
    
      //bottom right
      align-items:flex-end;
      justify-content:flex-end;
    }

    两个点

    当有两个项目的时候,我们先来看看一行上放两个点,两个点排在一行的两端。
    使用justify-content,你有两个选择,space-around和space-between。
    一个两边不留空等分间距,一个两边留空

    .two-container{
     justify-content:space-between;
    }

    竖着排列:

    .two-container{
      //row two sperad
      justify-content:space-between;
      //column
      flex-direction: column;
    }

    我们知道骰子的两个点是斜着排列的,那怎么办呢,这时align-self就起作用了:

    .two-container{
      //row two sperad
      justify-content:space-between;
      //column
      flex-direction: column;
      .point:nth-child(2) {
        align-self: flex-end;
      }
    }

    三个点

    这里主轴水平,第2个和第3个点使用align-self放到中间行和最下行,这里注意调整一下项目在主轴上的分布,这样3个点就会在水平的中央不偏了。

    .third-container{
      justify-content:space-between;
      .point:nth-child(2) {
        align-self: center;
      }
      .point:nth-child(3) {
        align-self: flex-end;
      }
    }

    四个点

    骰子的4个点是分布在四个角上的这个有两种实现方法
    如果你的骰子是固定大小的,给第一第三个点增加一个右外边距使得一行只能容下两个点:

    .four-container{
      justify-content:space-between;
      align-content: space-between;
      flex-wrap:wrap;
      .point:nth-child(2n+1) {
        margin-right:40px;
      }
    }

    或者你使用两个flex布局嵌套:

    <div class="four-container-other">
        <div class="row">
            <div class="point"></div>
            <div class="point"></div>
        </div>
        <div class="row">
            <div class="point"></div>
            <div class="point"></div>
        </div>
    </div>
    .four-container-other{
      align-content:space-between;
      flex-wrap: wrap;
      .row{
        width:100%;
        display: flex;
        justify-content:space-between;
      }
    }

    五个点

    由四个点递推,第一个方法不行了,只能使用第二个办法。

    <div class="five-container">
        <div class="row">
            <div class="point"></div>
            <div class="point"></div>
        </div>
        <div class="row">
            <div class="point"></div>
        </div>
        <div class="row">
            <div class="point"></div>
            <div class="point"></div>
        </div>
    </div>
    .five-container{
      align-content:space-between;
      flex-wrap: wrap;
      .row{
        width:100%;
        display: flex;
        justify-content:space-between;
      }
      .row:nth-child(2) {
        justify-content: center;
      }
    }

    六个点

    这个反倒简单了,因为3个点自己就会排满一行:

    <div class="six-container">
        <div class="point"></div>
        <div class="point"></div>
        <div class="point"></div>
        <div class="point"></div>
        <div class="point"></div>
        <div class="point"></div>
    </div>
    .six-container{
      flex-wrap: wrap;
      align-content:space-between;
      justify-content:space-between;
    }

    网格布局

    基本网格布局

    最简单的网格布局,就是平均分布。在容器里面平均分配空间。只要给项目设置了相同的flex-basis(不能是auto),flex-grow和flex-shrink,不管是多少个项目都会均分空间。或者你干脆设置一个flex:1,这样浏览器会自动推算出:

    flex-basis: 0px;
    flex-grow: 1;
    flex-shrink: 1;

    如果你只设置了flex-grow是不行的,虽然flex-shrink默认就是1可以不管,但是由于flex-basis默认为auto,所以内容比较多的元素会占比较大的主轴空间。

    <div class="row even">
        <div class="cell">
            <div class="cell">1/2</div>
        </div>
        <div class="cell">
            <div class="cell">1/2</div>
        </div>
    </div>
    <div class="row even">
        <div class="cell">
            <div class="cell">1/3</div>
        </div>
        <div class="cell">
            <div class="cell"></div>
        </div>
        <div class="cell">
            <div class="cell">1/3</div>
        </div>
    </div>
    .row{
      display: flex;
      flex-wrap: nowrap;
      margin: -1em 0 1em -1em;
      .cell{
        padding: 1em 0 0 1em;
        text-align: center;
        flex: 1;
        //flex-basis: 0px;
        //flex-grow: 1;
        //flex-shrink: 1;
        color:white;
        display: flex;
        .item{
          background-color: hsla(31,15%,50%,.2);
          border-radius: 4px;
          padding: .8em 1em 0;
          width:100%;
          &:after {
            content: '\00a0';
            display: block;
            margin-top: 1em;
            height: 0;
            visibility: hidden;
          }
        }
      }
    }

    这里设置了flex=1。
    你会注意到,这里的cell只是一个容器,项目的样子是由cell里的item设置的,cell之所以设置了display:flex是为了使cell里的item的高度利用align-items的默认值stretch填充满cell,即使没有内容或内容不够。
    还有这里的row的margin、cell的padding、item的伪元素是有讲究的,是为了在flex布局嵌套时互相抵消用的,这个会在下面解释

    百分比布局

    某个网格的宽度为固定的百分比,其余网格平均分配剩余的空间。
    平均分配剩余空间的项目其实还是靠的flex都为相同的值,对于那个要占固定位置的,通过给flex-basis一个百分比来设置它占主轴多宽,flex-shrink和flex-grow都设为0来保证其大小不会自适应的调整。如果你的项目是有margin的,那么这个百分比是不准的,和width一样,所以项目之间的间距最好使用padding来达成。

    <div class="row fix-precentage">
        <div class="cell c-100">
            <div class="item">full</div>
        </div>
        <div class="cell">
            <div class="item">nowhere to go</div>
        </div>
    </div>
    <div class="row fix-precentage">
        <div class="cell c-50">
            <div class="item">full</div>
        </div>
        <div class="cell">
            <div class="item">even rest</div>
        </div>
        <div class="cell">
            <div class="item">even rest</div>
        </div>
        <div class="cell">
            <div class="item">even rest</div>
        </div>
    </div>
    .c-100{
      flex: 0 0 100%;
    }
    .c-50{
      flex: 0 0 50%;
    }

    响应式布局

    利用媒体查询加flex就可以做到响应式的布局咯:

    .row.responsive{
      flex-wrap: wrap;
      @media all and (max-width: 768px)  {
        .cell {
          flex:0 0 100%;
        }
      }
    }

    网格布局嵌套

    在一个flex项目div中再嵌套一个row的时候,row的左上负margin会和div的padding抵消。
    row下面的正margin-bottom会和div的伪元素的margin-top重合。
    这样一个row就正常的放在了div里,没有任何多于的边距。

    <div class="row nest">
        <div class="cell">
            <div class="item">
                <div class="row">
                    <div class="cell">
                        <div class="item">1/2</div>
                    </div>
                    <div class="cell">
                        <div class="item">
                            <div class="row">
                                <div class="cell">
                                    <div class="item">1/2</div>
                                </div>
                                <div class="cell">
                                    <div class="item">1/2</div>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
        <div class="cell">
            <div class="item">responsive</div>
        </div>
        <div class="cell">
            <div class="item">responsive</div>
        </div>
    </div>

    圣杯布局

    圣杯布局指的是一种最常见的网站布局。页面从上到下,分成三个部分:头部(header),躯干(body),尾部(footer)。其中躯干又水平分成三栏,从左到右为:导航、主栏、副栏。
    我们使用一个总的垂直的flex布局,放上header,body,footer。
    其中header和footer固定高度,flex:none
    body自动拉伸,在内容不够时配合整个容器的最小高度100vh使footer处于页面最底;在内容多时拉伸配合内容,flex:flex: 1 0 auto;

    .HolyGrail{
      display: flex;
      flex-direction: column;
      min-height: 100vh;
      //height:100%;
      header,
      footer {
        flex: none;
      }
      .HolyGrail-body {
        display: flex;
        flex: 1 0 auto; /* 2 */
      }
    }

    在body中,flex水平布局,左右边栏固定宽度,中间内容随屏幕铺开:

    .HolyGrail-content {
      flex: 1;
    }
    .HolyGrail-nav, .HolyGrail-ads {
      /* two aside fix to 12em */
      flex: 0 0 12em;
    }

    nav放在最左侧:

    .HolyGrail-nav {
      /* nav left */
      order: -1;
    }

    在屏幕宽度太小时,body中内容竖直排列比较合适

    @media all and (max-width: 768px) {
      .HolyGrail-body {
        flex-direction: column;
        flex: 1;
      }
      .HolyGrail-nav,
      .HolyGrail-ads,
      .HolyGrail-content {
        flex: auto;
      }
    }

    输入框布局

    我们常常需要在输入框的前方添加提示,后方添加按钮。
    我们想让这个提示或按钮是固定宽度的,然后input填满剩下的宽度,但是在以前这并不容易,现在有了 flex一切就变得简单了

    <!-- appending -->
    <div class="InputAddOn">
        <input class="InputAddOn-field">
        <button class="InputAddOn-item">Submit</button>
    </div>
    
    <!-- prepending -->
    <div class="InputAddOn">
        <span class="InputAddOn-item">Hint:</span>
        <input class="InputAddOn-field">
    </div>
    
    <!-- both -->
    <div class="InputAddOn">
        <span class="InputAddOn-item">Hint:</span>
        <input class="InputAddOn-field">
        <button class="InputAddOn-item">Submit</button>
    </div>

    核心就两个

    .InputAddOn {
      display: flex;
    }
    
    .InputAddOn-field {
      flex: 1;
    }

    不过当然要美化一下啦~

    .InputAddOn {
      margin:1em;
      display: flex;
    }
    .InputAddOn-field:first-child, .InputAddOn-item:first-child {
      border-radius: 2px 0 0 2px;
    }
    .InputAddOn-field:not(:last-child), .InputAddOn-item:not(:last-child) {
      border-right: 0;
    }
    .InputAddOn-field:last-child, .InputAddOn-item:last-child {
      border-radius: 0 2px 2px 0;
    }
    .InputAddOn-field, .InputAddOn-item {
      border: 1px solid hsla(31,15%,50%,.25);
      padding: .5em .75em;
    }
    .InputAddOn-field {
      flex: 1;
    }
    .InputAddOn-item {
      background-color: hsla(31,15%,50%,.1);
      color: #666;
      font: inherit;
      font-weight: 400;
    }

    悬挂式布局

    左边是头像,右边是文章的布局用flex实现也很合适:

    <div class="media">
        <img class="media-figure" src="kitten.jpg" />
        <div class="media-body">
            <h3>Media Object Title</h3>
            <p>Phasellus vel felis purus. Aliquam consequat pellentesque dui, non mollis erat dictum sit amet. Curabitur non quam dictum, consectetur arcu in, vehicula justo.</p>
        </div>
    </div>
    .media {
      display: flex;
      align-items: flex-start;
    }
    
    .media-figure {
      margin-right: 1em;
    }
    
    .media-body {
      flex: 1;
    }

    可以套用刚才的grid系统实现多列和嵌套:

    <div class="hang-layout grid">
        <div class="row nest">
            <div class="cell c-50">
                <div class="item">
                    <div class="media">
                        <img class="media-figure" src="kitten.jpg" />
                        <div class="media-body">
                            <h3>Media Object Title</h3>
                            <p>Phasellus vel felis purus. Aliquam consequat pellentesque dui, non mollis erat dictum sit amet. Curabitur non quam dictum, consectetur arcu in, vehicula justo.</p>
                        </div>
                    </div>
                </div>
            </div>
            <div class="cell">
                <div class="item">
                    <div class="media">
                        <img class="media-figure" src="kitten.jpg" />
                        <div class="media-body">
                            <h3>Media Object Title</h3>
                            <p>Phasellus vel felis purus. Aliquam consequat pellentesque dui, non mollis erat dictum sit amet. Curabitur non quam dictum, consectetur arcu in, vehicula justo.</p>
                            <div class="row nest">
                                <div class="cell">
                                    <div class="item">
                                        <div class="media">
                                            <img class="media-figure" src="kitten.jpg" />
                                            <div class="media-body">
                                                <h3>Media Object Title</h3>
                                                <p>Phasellus vel felis purus. Aliquam consequat pellentesque dui, non mollis erat dictum sit amet. Curabitur non quam dictum, consectetur arcu in, vehicula justo.</p>
                                            </div>
                                        </div>
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </div>
    .hang-layout{
      display: flex;
      flex-wrap: wrap;
      background-color: white;
      .media{
        display: flex;
        flex-basis: 50%;
        align-items: flex-start;
        padding:10px;
        text-align: left;
        color: #2b2d2f;
        .media-figure {
          margin-right: 1em;
          width:50px;
        }
        .media-body {
          flex: 1;
        }
      }
    }

    流式布局

    即每行的项目数固定,自动分行,以前是用float实现的。
    主要就是设置项目的flex-grow,flex-shrink,flex-basis。

    <div class="flowLayout">
        <div class="flowItem"></div>
        <div class="flowItem"></div>
        <div class="flowItem"></div>
        <div class="flowItem"></div>
        <div class="flowItem"></div>
    </div>
    .flowLayout{
      display: flex;
      flex-wrap: wrap;
      .flowItem{
        border: 2px solid red;
        padding:2em;
        flex: 0 0 25%;
      }
    }

    垂直居中

    这个一直是网页布局的噩梦,如果你想垂直居中一个大小不定的元素,还有一些hack的办法,如果你想垂直一组大小不定,数目不定的元素。。。。good luck
    而使用flex,这实在太轻松了,使用align-items,align-self,justify-content你可以居中任何东西!

    <div class="vertical">
        <div class="item">
            <h3>We are Centered Anyway</h3>
            <p contenteditable="true">click me and try</p>
        </div>
        <div class="item">
            <h3>We are Centered Anyway</h3>
            <p contenteditable="true">click me and try</p>
        </div>
        <div class="item">
            <h3>We are Centered Anyway</h3>
            <p contenteditable="true">click me and try</p>
        </div>
    </div>
    .vertical{
      background-color: hsla(31,15%,50%,.1);
      /*only these importent*/
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      /*only these importent*/
      padding:1em;
      min-height: 900px;
      .item{
        background-color: hsla(31,15%,50%,.1);
        max-width:50%;
        padding:1em;
        margin: 1em;
        border-radius: 4px;
      }
    }
    展开全文
  • flex

    千次阅读 2011-08-04 15:54:07
    通过Adobe Flex 4.5 SDK发行版,开发人员可以将Flex用于多屏幕应用程序开发,进一步改进Flex 4中引入的Spark架构和组件集,并对核心Flex基础结构作出大量改进以简化大型应用程序开发。开发人员可以使用Adobe Flex ...
    Adobe Flex 4.5是用于构建和维护在所有主要浏览器、桌面和操作系统一致地部署的极具表现力的Web应用程序的高效率的开放源码框架。通过Adobe Flex 4.5 SDK发行版,开发人员可以将Flex用于多屏幕应用程序开发,进一步改进Flex 4中引入的Spark架构和组件集,并对核心Flex基础结构作出大量改进以简化大型应用程序开发。开发人员可以使用Adobe Flex Builder 4.5软件来显著促进开发。

    Flex的技术专题,从入门到开发、学习教程下载、常见问题探讨、Flex的优势与实例…… 资源很丰富啊!跟大家分享一下!有时间浏览一下肯定会学到很多知识的哦!
    http://www.cn-java.com/www1/flex.php/
    展开全文
  • flex布局

    千次阅读 多人点赞 2019-04-25 17:19:34
    flex布局flex布局flex布局flex布局flex布局flex布局

    flex

    什么是flex?
    flex意味“弹性盒子”,用来为盒状模型提供最大的灵活性,任何一个容器都可以指定为flex布局。
    采用flex布局的元素,称为flex容器,它的所有子元素自动成为容器成员。
    作用:
    如果需要将容器设为flex容器,则第一步如下将div设置为flex容器:

    div
    {
     display: flex;
    }
    

    容器的属性

    flex-direction决定子元素的排列方向

    决定主轴的方向(即项目的排列方向)。它有4个可能的值 :
    (1)row默认值,主轴为水平方向,子元素从左向右排列
    实例:

     <div class="mydiv">
    <div>我是1</div>
    <div>我是2</div>
    <div>我是3</div>
     </div>
    
    .mydiv
    {
     width: 400px;
     border: 2px solid pink;
     padding: 10px;
     display: flex;
      flex-direction: row;
    }
    

    在这里插入图片描述
    (2)row-reverse:主轴为水平方向,起点在容器的右端。

    .mydiv{
     flex-direction: row-reverse;
    }
    

    在这里插入图片描述
    (3)column:主轴为垂直方向,起点在容器的上沿。

    .mydiv{
    flex-direction: column;
    }
    

    在这里插入图片描述
    (4)column-reverse:主轴为垂直方向,起点在容器的下沿。

    .mydiv{
    flex-direction: column-reverse;
    }
    

    在这里插入图片描述

    flex-wrap规定如果一行放不下如何换行。

    默认情况下容器里变得额所有项目都排在一条线上,flex-wrap定义如果一行排不下 如何换行。它可能的值有三个:
    (1)nowrap(默认):不换行。

    div{
     flex-direction: row;
     flex-wrap: nowrap;
    }
    

    如果不换行,则会挤压子元素,放在一条线上。
    在这里插入图片描述
    (2)wrap:换行,第一行在上方。

    div{
     flex-direction: row;
     flex-wrap: wrap;
    }
    

    在这里插入图片描述
    (3)wrap-reverse:换行,第一行在下方。

    div{
     flex-direction: row;
     flex-wrap: wrap-reverse;
    }
    

    在这里插入图片描述

    flex-flow是上面两个属性的简写形式

    是flex-direction属性和flex-wrap属性的简写形式,默认值为row nowrap。
    例如:

    flex-flow:row wrap;
    

    justify-content定义在主轴上的对齐方式

    justify-content 定义了项目在主轴上的对齐方式。它可能的值有5个:
    (1)flex-start向主轴的起始位置对齐,也就是从主轴的起始位置开始排列。

    div{
     display: flex;
     flex-direction: row;
     justify-content: flex-start;
    }
    

    在这里插入图片描述
    (2)flex-end:向主轴结束位置对齐,也就是从主轴结束的位置开始排列。

    div{
     display: flex;
     flex-direction: row;
     justify-content: flex-end;
    }
    

    在这里插入图片描述
    (3)center: 居中

    div{
     display: flex;
     flex-direction: row;
     justify-content: center;
    }
    

    在这里插入图片描述
    (4)space-between:如果有两个以上的项目,则容器主轴的开始和结束位置各一个,其他的项目均匀排列,项目之间的间隔相等。排列顺序同样和flex-direction有关。如果只有两个项目则一边一个。如果只有一个项目则只在容器主轴的开始位置排列

    div{
     display: flex;
     flex-direction: row;
     justify-content: space-between;
    }
    

    在这里插入图片描述
    (5)space-around:每个项目两侧的间隔相等。所以,项目之间的间隔比项目与边框的间隔大一倍。排列顺序同样和flex-direction有关。如果只有一个项目则排列在中间。

    div{
     display: flex;
     flex-direction: row;
     justify-content: space-around;
    }
    

    在这里插入图片描述

    align-items定义项目在交叉轴(纵轴)上如何对齐

    align-items属性定义项目在交叉轴(纵轴)上如何对齐。它可能取5个值。具体的对齐方式与交叉轴的方向有关,下面假设交叉轴从上到下。
    (1)flex-start:交叉轴的起点对齐。

    div{
    display: flex;
    flex-direction: row;
    align-items: flex-start;
    }
    

    在这里插入图片描述
    (2)flex-end:交叉轴的终点对齐。

    div{
    display: flex;
    flex-direction: row;
    align-items: flex-end;
    }
    

    在这里插入图片描述
    (3)center:交叉轴的中点对齐。

    div{
    display: flex;
    flex-direction: row;
    align-items: center;
    }
    

    在这里插入图片描述
    (4)baseline: 项目的第一行文字的基线对齐。

    div{
    display: flex;
    flex-direction: row;
    align-items: baseline;
    }
    

    如下图效果,使第一行文字基线对齐。
    在这里插入图片描述
    (5)stretch(默认值):如果项目未设置高度或设为auto,将占满整个容器的高度。

    div{
    display: flex;
    flex-direction: row;
    align-items: stretch;
    }
    

    如下图未设置高度,元素自动填满整个容器。
    在这里插入图片描述

    align-content定义了多根轴线(多行)的对齐方式

    align-content属性定义了多根轴线(多行)的对齐方式。如果项目只有一根轴线(一行),该属性不起作用。
    如果flex-direction的值是column,则该属性定义了多列的对齐方式。如果项目只有一列,该属性不起左右。
    属性值包括:
    (1)stretch(默认值):多行占满整个交叉轴。

    div{
    display: flex;
    flex-direction: row;
     align-content: stretch;
    }
    

    在这里插入图片描述
    (2)flex-start:与交叉轴的起点对齐。

    div{
     display: flex;
     flex-wrap: wrap;
     align-content: flex-start;
    }
    

    在这里插入图片描述
    (3)flex-end:与交叉轴的终点对齐。

    div{
     display: flex;
     flex-wrap: wrap;
     align-content: flex-end;
    }
    

    在这里插入图片描述
    (4)center:与交叉轴的中点对齐。

    div{
     display: flex;
     flex-wrap: wrap;
     align-content:center;
    }
    

    在这里插入图片描述
    (5)space-between:与交叉轴两端对齐,轴线之间的间隔平均分布。

    div{
     display: flex;
     flex-wrap: wrap;
     align-content:space-between;
    }
    

    在这里插入图片描述
    (6)space-around:每根轴线两侧的间隔都相等。所以,轴线之间的间隔比轴线与边框的间隔大一倍。

    div{
     display: flex;
     flex-wrap: wrap;
     align-content:space-around;
    }
    

    在这里插入图片描述

    瓜分父容器的空间

    1.先了解什么是剩余空间
    现在有一个容器A,它的里面有三个元素a1,a2,a3,剩余空间=容器A的宽度-a1-a2-a3
    在这里插入图片描述

    flex-grow用于瓜分父容器的剩余空间

    flex-grow设置在flex容器的子项目上。

    flex-grow默认为0。
    上述例子中,如果A容器宽度为500px,a1的宽度为100px,a2的宽度为200px,a3的宽度为40px,那么剩余宽度为500-100-200-40=170px;
    例子1:
    如果此时我们队a1设置flex-grow:1,那么剩余的170px都会分给a1,a1原来有100px此时会有100px+170px=270px;
    例子2:
    如果a2此时也来瓜分剩余空间,a2中设置了flex-grow:2,那么父容器会把剩余空间分成三份,a1分1/3,a2分2/3

    flex-basis设置或检索弹性盒伸缩基准值。

    它的属性值可以设置:
    (1)一个长度单位或者一个百分比,规定灵活项目的初始长度
    (2)auto,默认值,长度等于灵活项目的长度,如果该项目未指定长度,则长度将根据内容决定。
    实例:现在在一个flex容器中有3个div

    <div class="mydiv">
    <div>我是1</div>
    <div>我是2哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈</div>
    <div>我是3哈哈哈哈哈哈哈哈</div>
    </div>
    

    这三个div都没有设置宽度,第二个div设置了flex-basis: 80px;

    .mydiv
    {
     width: 350px;
     border: 2px solid pink;
     padding: 10px;
     display: flex;
     flex-wrap: wrap;
     align-content:space-around;
    }
    .mydiv div
    {
      height: 100px;
    }
    .mydiv div:first-child
    {
      background-color: red;
    }
    .mydiv div:nth-child(2)
    {
      background-color: green;
      flex-basis: 80px;
    }
    .mydiv div:nth-child(3)
    {
      background-color: orange;
    }
    

    效果如下:
    在这里插入图片描述
    综上所述,第一个div宽度会根据内容的多少来显示,第二个div设置了flex-basis为80px,所以它的宽度不会根据内容多而变宽,第三个div未设置宽度,它内容多了后会自动把它的宽度撑开。
    也就是说,在分配空间钱,如果子容器设置了flex-basis或者width,它会先跟父容器预约这么多的空间,然后剩下的才是归到剩余空间,然后父容器再把剩余空间分配给设置了flex-grow的容器,注:如果同时设置了flex-basis和width,那么width属性会被覆盖,也就是说flex-basis的优先级比width高,如果flex-basis和width其中有一个是auto,那么另外一个非auto的属性优先级会更高。

    flex-shrink指定flex容器中子元素的收缩规则

    一个flex容器,中有三个子容器,如果三个子容器的宽度和超过了父容器,这时候该怎么处理呢?
    flex环境默认是不换行的,即使父容器宽度不够也不会,除非设置了flex-wrap来换行。
    例如:
    现在有一个父容器,宽度是500px,三个子容器,A的宽度是200px,B的宽度是300px,C的宽度是150px;
    剩余空间是500-200-300-150结果为-150,即使B设置了flex-grow,由于没有剩余空间,所以B分配到的剩余空间是0
    由于父容器的宽度500不会变,解决办法:1.使子容器换行,2.压缩子容器使之刚好撑满父容器的宽度。
    采用第二种解决方法就可以使用flex-shrink,这个属性就是定义一个子容器的压缩比例。它的默认值是1,所以A,B,C,三个子容器的压缩比例是一样的1:1:1,如果此刻把B的压缩比例设为2,会怎样呢?
    可以发现B被压缩的更多了,A和C得到了更多的空间,计算方式如下:
    剩余空间为:500-200-300-150=-150
    如果A设为flex-shrink:1,B为flex-shrink:2,C为flex-shrink:1
    那么A被压缩的空间为1501/4,A的实际空间为200-1501/4
    那么B被压缩的空间为1502/4,B的实际空间为300-1502/4
    那么C被压缩的空间为1501/4,C的实际空间为150-1501/4

    ##总结 通过上面的分析,我们就可以得出这样几个结论:
    1、剩余空间=父容器空间-子容器1.flex-basis/width - 子容器2.flex-basis/width - …
    2、如果父容器空间不够,就走压缩flex-shrink,否则走扩张flex-grow;
    3、如果你不希望某个容器在任何时候都不被压缩,那设置flex-shrink:0;
    4、如果子容器的的flex-basis设置为0(width也可以,不过flex-basis更符合语义),那么计算剩余空间的时候将不会为子容器预留空间。
    5、如果子容器的的flex-basis设置为auto(width也可以,不过flex-basis更符合语义),那么计算剩余空间的时候将会根据子容器内容的多少来预留空间。
    https://www.cnblogs.com/ghfjj/p/6529733.html

    2.使用flex实现水平垂直居中

    设置如下,需要在被居中层的父级中设置:

    .parent{
    	justify-content:center;
    	align-items:center;
    	display:flex;
    }
    
    展开全文
  • flex4.6-api.chm

    千次下载 热门讨论 2012-07-23 13:04:19
    我见到过的最好用的flex4 chm api,非常完整,超级帮 最新Flex4.6中文API,离线帮助文档,无js错误
  • Flex布局

    千次阅读 2017-11-13 11:46:32
    Flex布局常用的布局方式有3种: display:css内联和块级布局。 position:绝对、相对定位布局。 float:浮动布局。 传统的布局方式存在一个很明显的问题,那就是垂直居中不易实现。flex:弹性盒子布局,可以更好的实现...

    Flex布局

    常用的布局方式有3种:

    • display:css内联和块级布局。
    • position:绝对、相对定位布局。
    • float:浮动布局。

    传统的布局方式存在一个很明显的问题,那就是垂直居中不易实现。

    flex:弹性盒子布局,可以更好的实现响应式布局。

    Flex的使用

    Flex容器

    任何容器都可以flex布局。Flex容器的所有子元素也自动成为容器的成员,成为Flex项目Flex容器默认存在2根轴线(水平主轴和垂直交叉轴),布局就是根据这2根轴来排列项目显示的。

    块级元素:display:flex;

    内联元素:display:inlne-flex;

    使用了flex布局后,项目的float、clear、vertical-align都将失去效果。

    Flex容器属性

    1.flex-direction

    设置项目的排列方向。

    flex-direction: row | row-reverse | column | column-reverse;
    
    • row(默认值):主轴为水平方向,起点在左端。

      从左往右排。如果超出容器宽度,容器会根据项目的宽度进行等比缩放

    • row-reverse:主轴为水平方向,起点在右端。

      从右往左排,如果超出容器宽度,容器会根据项目的宽度进行等比缩放

    • column:主轴为垂直方向,起点在上沿。

      从上往下排。

    • column-reverse:主轴为垂直方向,起点在下沿。

      从下往上排。

    2.flex-wrap

    设置项目是否换行排列。

    flex-wrap: nowrap | wrap | wrap-reverse;
    
    • nowrap(默认值):不换行。
    • wrap:换行,第一行在上方。
    • wrap-reverse:换行,第一行在下方。

    3.flex-flow

    flex-flow属性是flex-direction属性和flex-wrap属性的简写形式,默认值为row nowrap

    flex-flow: <flex-direction> || <flex-wrap>;
    

    4.justify-content

    设置项目的水平对齐方式。

    justify-content: flex-start | flex-end | center | space-between | space-around;
    
    • flex-start(默认值):左对齐
    • flex-end:右对齐
    • center: 居中
    • space-between:两端对齐,项目之间的间隔都相等。
    • space-around:每个项目两侧的间隔相等。所以,项目之间的间隔比项目与边框的间隔大一倍。

    5.align-items

    设置项目垂直方向对齐方式。

    align-items: flex-start | flex-end | center | baseline | stretch;
    
    • flex-start:交叉轴的起点对齐。
    • flex-end:交叉轴的终点对齐。
    • center:交叉轴的中点对齐。
    • baseline: 项目的第一行文字的基线对齐。
    • stretch(默认值):如果项目未设置高度或设为auto,将占满整个容器的高度。

    6.align-content

    当项目定义了横竖2根轴的时候生效,相当于justify-contentalign-items的简写。

    Flex项目属性

    a.order

    定义项目的排列顺序,值越小越考前,默认为0。

    order: <integer>;
    

    b.flex-grow

    定义项目的放大比例,默认为0(不放大),大于0则自动填充剩余区域,大于0的时候照数值大小的倍数填充相应区域。例如2个平级div,一个flex-grow:1,另一个flex-grow:2,则第一个div是第2个div的2倍宽度,且2个div共同填充满剩余宽度。如果数值都相等且大于0,那么久平分剩余区域。

    flex-grow: <number>; 
    

    c.flex-shrink

    定义项目的缩小比例,默认为1,如果空间不足将自动缩小。

    不能和flex-wrap共用,如果项目换行,那么缩小的计算方式将无法生效。

    flex-shrink: <number>; 
    

    d.flex-basis

    定义项目主轴空间,相当于设置width,默认为auto。

    flex-basis: <length> | auto;
    

    e.flex

    flex属性是flex-grow, flex-shrinkflex-basis的简写,默认值为0 1 auto。后两个属性可选。

    flex: none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]
    

    flex:auto => flex:1 1 auto;
    flex:none =>flex:0 0 auto;
    flex:1 => flex:1 1 0%;
    当设置 flex:1时,如果子元素宽度的和大于了父元素的宽度,将自动缩小子元素,若果子元素宽度的和小于父元素宽度,则自动放大子元素。
    所以如果遇到了定宽的子元素,一样要单独设置flex-shrink:0,否则它将随父元素改变而改变。

    f.align-self

    定义项目的对齐方式。可覆盖align-items。默认值:auto。

    align-self: auto | flex-start | flex-end | center | baseline | stretch;
    
    展开全文
  • Flex 布局详解 - Flex布局的常用属性

    千次阅读 多人点赞 2019-05-14 19:33:22
    flex布局中的一些基本概念容器和项目项目在容器中的显示容器的一些属性flex-direction 属性flex-wrap属性flex-flow属性justify-content 属性align-items 属性项目的一些属性order属性flex-grow 属性flex-shrink 属性...
  • Flex 布局全解

    万次阅读 多人点赞 2018-06-19 13:40:16
    一、Flex布局是什么?Flex是Flexible Box的缩写,意为”弹性布局”,用来为盒状模型提供最大的灵活性。任何一个容器都可以指定为Flex布局。.box{ display: flex; }行内元素也可以使用Flex布局。.box{ display: ...
  • flex-grow、flex-shrink、flex-basis三个属性的作用:在flex布局中,父元素在不同宽度下,子元素是如何分配父元素空间的。(注意:这三个属性都是在子元素上设置的,下面小编要讲的是父元素,指以flex布局的元素...
  • FLEX布局

    千次阅读 2020-04-04 13:25:30
    FLEX布局 FLEX布局也称弹性布局,可以为盒状模型提供最大的灵活性,是布局的首选方案,现已得到所有现代浏览器的支持。 基础 通过指定display: flex来标识一个弹性布局盒子,称为FLEX容器,容器内部的盒子就成为FLEX...
  • 在MDN上有关Flex布局的属性中。 对于flex-basis、flex-grow、flex-shrink三个属性结合起来测试。 附链接,直接在CodePen中修改测试。 flex-shrink(MDN): ...
  • Flex弹性布局

    万次阅读 2020-07-03 13:48:32
    通过给父盒子设置flex属性、来控制子盒子的位置和排列的方式 任何容器都可以指定为flex布局 为父盒子设置了之后、子元素的float、clear和vertical-align属性将失效 设为flex布局的元素、为flexcentainer容器、它的...
  • 深入理解css3中的flex-grow、flex-... 感谢他的整理 flex为css的布局带来了新的时代,作为一个重构工程师,我们再也不用局限于float和position,特别是在移动端,我们可以利用flex轻松实现以往float和psition很难...
  • flex:none 和 flex:1

    千次阅读 2020-03-03 14:35:14
    不允许项目压缩、放大 flex: none 如果我们希望项目排在一行里,但是项目的宽度又不被压缩,那么我们应该给项目设置 flex:none,使项目不能被压缩或放大。 我们接触到的属性,justify-content、align-items、flex-...
  • flex详解-flex:1详解

    千次阅读 2020-01-08 10:58:27
    flex详解-flex:1详解 flex:有如下属性 -----begin 属性-------- flex-grow 一个数字,规定项目将相对于其他灵活的项目进行扩展的量。 flex-shrink 一个数字,规定项目将相对于其他灵活的项目进行收缩的量。 flex-...
  • flex布局 flex-wrap:wrap 自动换行属性,导致两行div中间有大空行。
  • flex-grow、flex-shrink、flex-basis详解

    千次阅读 2017-12-13 15:42:26
    flex-grow、flex-shrink、flex-basis这三个属性的作用是:在flex布局中,父元素在不同宽度下,子元素是如何分配父元素的空间的。 其中,这三个属性都是在子元素上设置的。 注:下面讲的父元素,指以flex布局的元素...
  • flex 中的flex-basis

    千次阅读 2017-10-18 19:33:47
    概述flex-basis 指定了 flex 元素在主轴方向上的初始大小。如果不使用 box-sizing 来改变盒模型的话,那么这个属性就决定了 flex 元素的内容盒(content-box)的宽或者高(取决于主轴的方向)的尺寸大小。语法/* ...
  • flex中的flex-direction

    2017-10-18 17:15:12
    html部分: <div class="flex-item flex-item1">1 1 <div class="flex-item flex-item2">1 2 <div class="flex-item flex-item3">1 3 <div cla
  • 用css3的flex好久了,虽然用的没问题,但还是很纠结,其他属性大都明白,但是flex-grow、flex-shrink、flex-basis始终搞不清,最经搜集了大量的聊天,总算是明白了。 网上大部分解释是 flex-grow 是扩展比率 flex...
  • 之前在使用flex布局的时候,为了让flex项之间产生间距,设置了如下属性: ul{ display:flex; flex-wrap:wrap; justify-content:space-around; } li{ width:30%; height:100px; } 设置之后发现中间的间距确实...
  • flex 设置换行flex-wrap

    2017-09-01 10:00:00
    flex 设置flex-wrap 换行 本来预想的正常情况下,代码应该如下: 1 ul { 2 width: 100%; 3 display: flex; 4 flex-wrap: wrap; 5 li { 6 flex: 1; 7 width: 25%; 8 } 但是这样的代码的宽度不生效,...
  • display:box box-flex 和 display:flex flex 有什么区别?
  • flex布局,flex:1的计算

    千次阅读 2019-02-26 17:22:10
    一、flex的属性梳理 注意,设为 Flex 布局以后,子元素的float、clear和vertical-align属性将失效。 (1)flex1的计算规则 第一步:先明确:flexflex-grow | flex-shrink | flex-basis 的缩写。 1、默认...
  • flex:1和flex:auto详解

    2019-10-13 00:04:27
    首先明确一点是, flexflex-grow、flex-shrink、flex-basis的缩写。 flex-grow属性定义项目的放大比例,默认为0,即如果存在剩余空间,也不放大。 flex-shrink属性定义了项目的缩小比例,默认为1,即如果空间...
  • flex:1 阮一峰flex教程
  • flex与inline-flex属性的使用详解

    千次阅读 2019-08-31 23:55:54
    这篇文章主要介绍了flex与inline-flex的一些差别,感兴趣的朋友们可以看一下。 flex:将对象作为弹性伸缩盒显示 inline-flex:将对象作为内联弹性伸缩盒显示 先来看flex: .contain{ background: red; display...

空空如也

1 2 3 4 5 ... 20
收藏数 92,254
精华内容 36,901
关键字:

flex