网页瀑布流布局实现方法及功能扩展（附完整代码）

最新推荐文章于 2024-01-02 10:39:37 发布
最新推荐文章于 2024-01-02 10:39:37 发布
阅读量846 收藏 2
点赞数
分类专栏： Web前端 文章标签： javascript 瀑布流

图片分享网站Pinterest（beta），在不久前获得了2700$的投资，估值已超2亿元（据说现该公司团队有8人）。该网站的一大特色就是每一张分享的图片被拟作“Pin”被钉在页面上面，每一Pin依尺寸智能排列，同时滚动页面时异步加载新Pin，极具效果。这种创新模式被在国内也被广泛copy，其中最有前途的当属Mark之，以“Mark”代“Pin”，也算有些想法。

下面简单模拟下这种布局，这种布局在国内有人称之为瀑布流，当然这个名称主要还是指Pin在异步加载时的效果，而这个在本demo并没有做。(本demo兼容所有浏览器，但还是建议你使用firefox,chrome等浏览器，效果更佳)

<!doctype html>
  <html>
  <head>
  <meta charset="UTF-8" />
  <title>等宽格子堆砌</title>
  <style>
  *{padding:0;margin:0;}
  #wrap{position:relative;zoom:1;margin:0px auto;}
  #wrap li{width:250px;float:left;list-style:none;}
  .boxCont{position:relative;margin:15px;border:1px solid #ccc;background:#eee;
background: -webkit-gradient(linear, 0% 20%, 0% 92%, from(#fff), to(#f3f3f3), color-stop(.1,#fff));
background: -webkit-linear-gradient(0 0 270deg, #f3f3f3, #f3f3f3 10%, #fff);
background: -moz-linear-gradient(0 0 270deg, #f3f3f3, #f3f3f3 10%, #fff);
background: -o-linear-gradient(0 0 270deg, #f3f3f3, #f3f3f3 10%, #fff);
-webkit-border-radius: 60px / 5px;
-moz-border-radius: 60px / 5px;
border-radius:60px / 5px;
-webkit-box-shadow: 0px 0px 35px rgba(0, 0, 0, 0.1) inset;
-moz-box-shadow: 0px 0px 35px rgba(0, 0, 0, 0.1) inset;
box-shadow: 0px 0px 35px rgba(0, 0, 0, 0.1) inset;
}
.boxCont:before{
content: '';
width: 50px;
height: 50px;
top:0; right:0;
position:absolute;
display: inline-block;
z-index:-1;
-webkit-box-shadow: 10px -10px 8px rgba(0, 0, 0, 0.2);
-moz-box-shadow: 10px -10px 8px rgba(0, 0, 0, 0.2);
box-shadow: 10px -10px 8px rgba(0, 0, 0, 0.2);
-webkit-transform: rotate(2deg) translate(-14px,20px) skew(-20deg);
-moz-transform: rotate(2deg) translate(-14px,20px) skew(-20deg);
-o-transform: rotate(2deg) translate(-14px,20px) skew(-20deg);
transform: rotate(2deg) translate(-14px,20px) skew(-20deg);
}
.boxCont:after{
content: '';
width: 100px;
height: 100px;
top:0; left:0;
position:absolute;
z-index:-1;
display: inline-block;
-webkit-box-shadow: -10px -10px 10px rgba(0, 0, 0, 0.2);
-moz-box-shadow: -10px -10px 10px rgba(0, 0, 0, 0.2);
box-shadow: -10px -10px 10px rgba(0, 0, 0, 0.2);
-webkit-transform: rotate(2deg) translate(20px,25px) skew(20deg);
-moz-transform: rotate(2deg) translate(20px,25px) skew(20deg);
-o-transform: rotate(2deg) translate(20px,25px) skew(20deg);
transform: rotate(2deg) translate(20px,25px) skew(20deg);
}
</style>
</head>
<body>
<ul id="wrap"></ul>
</body>
<script type="text/javascript">
var $id = function(o){ return document.getElementById(o) || o};
function sort(el){
var h = [];
var box = el.getElementsByTagName("li");
var minH = box[0].offsetHeight,
boxW = box[0].offsetWidth,
boxH,
n = document.documentElement.offsetWidth / boxW | 0;  //计算页面能排下多少Pin
el.style.width = n * boxW + "px";
for(var i = 0; i < box.length; i++) {
boxh = box[i].offsetHeight; //获取每个Pin的高度
if(i < n) { //第一行Pin以浮动排列，不需绝对定位
h[i] = boxh;
box[i].style.position = '';
} else {
minH =  Math.min.apply({},h); //取得各列累计高度最低的一列
minKey = getarraykey(h, minH);
h[minKey] += boxh ; //加上新高度后更新高度值
box[i].style.position = 'absolute';
box[i].style.top = minH + 'px';
box[i].style.left = (minKey * boxW) + 'px';
}
}
};
/* 返回数组中某一值的对应项数 */
function getarraykey(s, v) {
for(k in s) {
if(s[k] == v) {
return k;
}
}
};
/* 随机创建Pin */
var pin = '';
for(i = 0; i < 30; i++) {
height = Math.floor(Math.random()*200 + 200);
pin += '<li><div class="boxCont" style="height:' + height + 'px;"></div></li>';
};
$id("wrap").innerHTML = pin;
window.onload = window.onresize = function() {
sort($id("wrap"));
};
</script>
</html>

这种布局中虽然每个Pin的高度不尽相同，但是他们的宽度都是一样的。

那么假如，很邪恶的提出一个要求，宽度也不尽相同，只是说宽高都按比例成倍增加，那还怎么排列呢？呵呵，如下：

<!doctype html>
  <html>
  <head>
  <meta charset="UTF-8" />
  <title>宽高尺寸不同的格子堆砌</title>
  <style>
  body{background:#F6F7F8;}
  .myWidget{position:relative;overflow:hidden;zoom:1;margin:0 auto;}
  .MBox{float:left;}
  .widgetBox{position:relative;overflow:hidden;zoom:1;width:186px;height:166px;margin:6px;border:1px solid #E1E1E3;
border-radius:10px;
-moz-border-radius:10px;
-webkit-border-radius:10px;
box-shadow:2px 3px 5px #d3d3d3;
-moz-box-shadow:2px 3px 5px #d3d3d3;
-webkit-box-shadow:2px 3px 5px #d3d3d3;
filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#fefefe, endColorstr=#e0e0e2);
background: linear-gradient(top, #fefefe, #f6f6f6 ,#f3f3f3,#f2f2f2,#e0e0e2);
background: -moz-linear-gradient(top, #fefefe, #f6f6f6 ,#f3f3f3,#f2f2f2,#e0e0e2);
background: -webkit-gradient(linear, 0 0, 0 100% , from(#fefefe),to(#e0e0e2));
background: -webkit-linear-gradient(0 0, #fefefe, #f6f6f6 ,#f3f3f3,#f2f2f2,#e0e0e2);
}
</style>
<script>
var $id = function(o){ return document.getElementById(o) || o ;};
var getElementsByClassName = function(className,parent,tag) {
parent = parent || document;
if(parent.getElementsByClassName){
return  parent.getElementsByClassName(className)
}else{
tag = tag || '*';
var returnElements = []
var els =  parent.getElementsByTagName(tag);
className = className.replace(/\-/g, "\\-");
var pattern = new RegExp("(^|\\s)"+className+"(\\s|$)");
var i = 0;
while(i < els.length){
if (pattern.test(els[i].className) ) {
returnElements.push(els[i]);
}
i++;
}
return returnElements;
}
};
/* 格子排序 */
var box={};
box.gen={w:200,h:180};
box.init=function(el){
box.size=[]; //格子,[1,2]表示1X2的大格子
box.obj={};
box.oArray=[];
box.maxY=-1;
box.mbox = getElementsByClassName("MBox",el,'div');
box.row = document.documentElement.offsetWidth / box.gen.w >> 0;  //每行标准格数
el.style.width = box.row * box.gen.w + "px";
var i = 0 , nx, ny;
while( i < this.mbox.length){
if( getElementsByClassName("bigBox",this.mbox[i],'div').length > 0 ){
nx=Math.ceil(this.mbox[i].offsetWidth / this.gen.w);
nx=(nx > this.row) ? this.row : nx; //大小超出限制
ny=Math.ceil(this.mbox[i].offsetHeight / this.gen.h);
this.size.push([nx,ny]);
}else{
this.size.push(1);
}
i++;
}
box.sort(el);
};
box.setIfr=function(el){  //大格子初始化
var ifr = getElementsByClassName("bigBox",el,'div');;
if(ifr.length==0) return false;
var i = 0, nx, ny, theifr;
while(i < ifr.length){
theifr =  getElementsByClassName("innerBox",ifr[i],'div');
nx=Math.ceil(theifr[0].offsetWidth / this.gen.w); //bigBox横向占的块数
ny=Math.ceil(theifr[0].offsetHeight / this.gen.h);
ifr[i].style.width = nx*this.gen.w-14 + 'px' ;
ifr[i].style.height = ny*this.gen.h-14 + 'px' ;
i++;
}
};
box.sort=function(el){
var y=0, x=0, temp={x:Infinity, y:Infinity}, flag=Infinity, name;
for(var n=0; n < this.size.length ; n++){
if(flag == 0){
x=temp.x;
y=temp.y;
}
flag=flag-1;
if(x>box.row-1){ //换行
x=0;
y++;
}
name=x+'_'+y;  //对象属性名（反映占领的格子）
if(this.hasN(name)) {  //判断属性名是否存在
n--;
x++;
if(flag<Infinity) flag=flag+1;
continue;
}
if(!this.size[n].length){  //普通格子
this.obj[name]=[x,y];  //项值（反映坐标值）
x++;
}
else{  //大格子
if(this.over(x,y,n)) {
if(temp.y > y){
temp.y = y;
temp.x = x;
}
if(temp.y < Infinity){
flag=1;
}
n--;
x++;
continue;
}
this.obj[name]=[x,y];
this.apply(x,y,n);
x+=this.size[n][0];
}
if(flag==-1) {
flag = 	Infinity;
temp.y = Infinity;
temp.x = Infinity;
}
var h=this.size[n][1]-1 || 0;
box.maxY=(box.maxY > y+h)? box.maxY : y+h;
}
for(var i in this.obj){
if(this.obj[i]===0 || !this.obj.hasOwnProperty(i)) continue;
this.oArray.push(this.obj[i]);
}
box.put(el);
};
box.hasN=function(n){
return n in this.obj;
};
box.over=function(x,y,n){  //判断是否会重叠
var name;
if(x+this.size[n][0] > this.row) return true; //超出显示范围
for(var k=1; k<this.size[n][1];k++){
name=x+'_'+(y-0+k);
if(this.hasN(name)) {return true;}  //左侧一列有无重叠
}
for(k=1; k<this.size[n][0];k++){
name=(x-0+k)+'_'+y;
if(this.hasN(name)) {return true;}  //上侧一行有无重叠
}
return false;
};
box.apply=function(x,y,n){  //大格子中多占的位置
var posX=x, //大格子左上角位置
posY=y;
for(var t=0; t<this.size[n][0]; t++) {
for(var k=0; k<this.size[n][1]; k++){
name=(posX+t)+'_'+(posY+k);
if(t==0 && k==0) { continue; }
this.obj[name]=0;   //多占的格子无坐标值
}
}
};
box.put=function(el){
var x,y;
for(var i =0;i< this.oArray.length; i++){
x=box.gen.w*this.oArray[i][0];
y=box.gen.h*this.oArray[i][1];
box.mbox[i].style.cssText = "position:absolute;left:"+ x +"px;top:" + y + "px;";
}
el.style.height= box.gen.h*(box.maxY+1) +'px';
};
</script>
</head>
<body>
<div id="myWidget" class="myWidget"></div>
<script>
var myWidget = $id("myWidget");
//创建随机内容
var content = '';
for(i = 0; i < 30; i++) {
if(!(Math.random()*3 >> 0)){
height = Math.floor(Math.random()*200 + 100);
width = Math.floor(Math.random()*200 + 100);
content += '<div class="MBox"><div class="widgetBox bigBox"><div style="width:' + width +'px;height:' + height +'px;margin:0 auto;" class="innerBox"></div></div></div>';
}else{
content += '<div class="MBox"><div class="widgetBox"></div></div>';
}
};
myWidget.innerHTML = content;
window.onload = function(){
box.setIfr(myWidget);
box.init(myWidget);
};
window.onresize = function(){
box.init(myWidget);
};
</script>
</body>
</html>

现在这种布局已经不能叫瀑布流了，我们称之为格子块，格子块通过算法智能堆砌。 

到最后，说点下睛也好，说添下足也好，我们再加一个拖动交换格子的效果。

<!doctype html>
  <html>
  <head>
  <meta charset="UTF-8" />
  <title>宽高尺寸不同的格子堆砌(可拖动换位)</title>
  <style>
  body{background:#F6F7F8;}
  .myWidget{position:relative;overflow:hidden;zoom:1;margin:0 auto;}
  .MBox{float:left;}
  .widgetBox{position:relative;overflow:hidden;zoom:1;width:186px;height:166px;margin:6px;border:1px solid #E1E1E3;cursor:move;
border-radius:10px;
-moz-border-radius:10px;
-webkit-border-radius:10px;
box-shadow:2px 3px 5px #d3d3d3;
-moz-box-shadow:2px 3px 5px #d3d3d3;
-webkit-box-shadow:2px 3px 5px #d3d3d3;
filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#fefefe, endColorstr=#e0e0e2);
background: linear-gradient(top, #fefefe, #f6f6f6 ,#f3f3f3,#f2f2f2,#e0e0e2);
background: -moz-linear-gradient(top, #fefefe, #f6f6f6 ,#f3f3f3,#f2f2f2,#e0e0e2);
background: -webkit-gradient(linear, 0 0, 0 100% , from(#fefefe),to(#e0e0e2));
background: -webkit-linear-gradient(0 0, #fefefe, #f6f6f6 ,#f3f3f3,#f2f2f2,#e0e0e2);
}
</style>
<script>
var $id = function(o){ return document.getElementById(o) || o ;};
var getElementsByClassName = function(className,parent,tag) {
parent = parent || document;
if(parent.getElementsByClassName){
return  parent.getElementsByClassName(className)
}else{
tag = tag || '*';
var returnElements = []
var els =  parent.getElementsByTagName(tag);
className = className.replace(/\-/g, "\\-");
var pattern = new RegExp("(^|\\s)"+className+"(\\s|$)");
var i = 0;
while(i < els.length){
if (pattern.test(els[i].className) ) {
returnElements.push(els[i]);
}
i++;
}
return returnElements;
}
};
var Util = new Object();
Util.getOffset = function (el, isLeft) {
var retValue = 0;
// while (el != null) {
retValue += el["offset" + (isLeft ? "Left" : "Top")];
//   el = el.offsetParent;
//}
return retValue;
};
Util.bindFunction = function (el, fucName) {
return function () {
return el[fucName].apply(el, arguments);
};
};
Util.re_calcOff = function (el) {
for (var i = 0; i < Util.dragArray.length; i++) {
var ele = Util.dragArray[i];
ele.elm.pagePosLeft = Util.getOffset(ele.elm, true);
ele.elm.pagePosTop = Util.getOffset(ele.elm, false);
}
var nextSib = el.elm.nextSibling;
while (nextSib) {
nextSib.pagePosTop -= el.elm.offsetHeight;
nextSib = nextSib.nextSibling;
}
};
Util.hide = function () {
Util.rootElement.style.display = "none";
};
Util.show = function () {
Util.rootElement.style.display = "";
};
ghostElement = null;
found = null;
getGhostElement = function () {
if (!ghostElement) {
ghostElement = document.createElement("DIV");
ghostElement.className = "MBox ghostBox";
}
return ghostElement;
};
function draggable(el) {
this._dragStart = start_Drag;
this._drag = when_Drag;
this._dragEnd = end_Drag;
this._afterDrag = after_Drag;
this.isDragging = false;
this.elm = el;
this.hasIFrame = this.elm.getElementsByTagName("IFRAME").length > 0;
Drag.init(el, this.elm);
this.elm.onDragStart = Util.bindFunction(this, "_dragStart");
this.elm.onDrag = Util.bindFunction(this, "_drag");
this.elm.onDragEnd = Util.bindFunction(this, "_dragEnd");
};
function start_Drag() {
Util.re_calcOff(this);
this.origNextSibling = this.elm.nextSibling;
var _ghostElement = getGhostElement();
var offH = this.elm.offsetHeight;
var offW = this.elm.offsetWidth;
var offLeft = Util.getOffset(this.elm, true);
var offTop = Util.getOffset(this.elm, false);
// Util.hide();
//this.elm.parentNode.getElementsByTagName('iframe')[0].style.visibility = 'hidden';
this.elm.style.width = offW + "px";
_ghostElement.style.height = offH + "px";
_ghostElement.style.width = offW + "px";
this.elm.parentNode.insertBefore(_ghostElement, this.elm.nextSibling);
this.elm.style.position = "absolute";
this.elm.style.zIndex = 100;
this.elm.style.left = offLeft + "px";
this.elm.style.top = offTop + "px";
//Util.show();
this.isDragging = false;
return false;
};
function when_Drag(clientX, clientY) {
if (!this.isDragging) {
this.elm.style.filter = "alpha(opacity=70)";
this.elm.style.opacity = 0.7;
this.isDragging = true;
}
found = null;
var max_distance = 100000000;
for (var i = 0; i < Util.dragArray.length; i++) {
var ele = Util.dragArray[i];
var distance = Math.sqrt(Math.pow(clientX - ele.elm.pagePosLeft, 2) + Math.pow(clientY -  ele.elm.offsetTop, 2));
if (ele == this) {
continue;
}
if (isNaN(distance)) {
continue;
}
if (distance < max_distance) {
max_distance = distance;
found = ele;
}
};
var _ghostElement = getGhostElement();
if (found != null) {
if(this.elm.pagePosLeft < clientX){
found.elm.parentNode.insertBefore(_ghostElement, found.elm.nextSibling);
}else{
found.elm.parentNode.insertBefore(_ghostElement, found.elm);
}
};
};
function end_Drag() {
//this.elm.parentNode.getElementsByTagName('iframe')[0].style.visibility = 'visible';
if (this._afterDrag()) {
}
return true;
};
function after_Drag() {
var returnValue = false;
// Util.hide();
this.elm.style.position = "";
this.elm.style.width = "";
this.elm.style.zIndex = "";
this.elm.style.filter = "";
this.elm.style.opacity = "";
var ele = getGhostElement();
if (ele.nextSibling != this.origNextSibling) {
ele.parentNode.insertBefore(found.elm, this.elm);
ele.parentNode.insertBefore(this.elm, ele.nextSibling);
returnValue = true;
}
ele.parentNode.removeChild(ele);
//Util.show();
box.init(Util.rootElement);
return returnValue;
};
var Drag = {
obj:null,
init:function (elementHeader, element) {
elementHeader.onmousedown = Drag.start;
elementHeader.obj = element;
if (isNaN(parseInt(element.style.left))) {
element.style.left = "0px";
}
if (isNaN(parseInt(element.style.top))) {
element.style.top = "0px";
}
element.onDragStart = new Function();
element.onDragEnd = new Function();
element.onDrag = new Function();
},
start:function (event) {
var element = Drag.obj = this.obj;
event = Drag.fixE(event);
if (event.which != 1) {
return true;
}
element.onDragStart();
element.lastMouseX = event.clientX;
element.lastMouseY = event.clientY;
document.onmouseup = Drag.end;
document.onmousemove = Drag.drag;
return false;
},
drag:function (event) {
event = Drag.fixE(event);
if (event.which == 0) {
return Drag.end();
}
var element = Drag.obj;
var _clientX = event.clientY;
var _clientY = event.clientX;
if (element.lastMouseX == _clientY && element.lastMouseY == _clientX) {
return false;
};
if(_clientX + document.documentElement.scrollTop + document.body.scrollTop < 0 ||  _clientX > document.documentElement.offsetHeight){
return false;
};
var sTo=0;
if( _clientX < 0 ){
sTo=_clientX;
};
if((_clientX - document.documentElement.clientHeight) > 0){
sTo=_clientX - document.documentElement.clientHeight;
};
window.scrollBy(0,sTo);
var _lastX = parseInt(element.style.top);
var _lastY = parseInt(element.style.left);
var newX, newY;
newX = _lastY + _clientY - element.lastMouseX;
newY = _lastX + _clientX - element.lastMouseY;
element.style.left = newX  + "px";
element.style.top = newY + sTo + "px";
element.lastMouseX = _clientY;
element.lastMouseY = _clientX;
element.onDrag(newX, newY);
return false;
},
end:function (event) {
event = Drag.fixE(event);
document.onmousemove = null;
document.onmouseup = null;
var _onDragEndFuc = Drag.obj.onDragEnd();
Drag.obj = null;
return _onDragEndFuc;
},
fixE:function (ig_) {
if (typeof ig_ == "undefined") {
ig_ = window.event;
}
if (typeof ig_.layerX == "undefined") {
ig_.layerX = ig_.offsetX;
}
if (typeof ig_.layerY == "undefined") {
ig_.layerY = ig_.offsetY;
}
if (typeof ig_.which == "undefined") {
ig_.which = ig_.button;
}
return ig_;
}
};
var initDrag = function (el) {
Util.rootElement = el;
Util.elem = Util.rootElement.children;
Util.dragArray = new Array();
var counter = 0;
for (var i = 0; i < Util.elem.length; i++) {
var elem = Util.elem[i];
Util.dragArray[counter] = new draggable(elem);
counter++;
};
box.setIfr(Util.rootElement);
box.init(Util.rootElement);
};
/* 格子排序 */
var box={};
box.gen={w:200,h:180};
box.init=function(el){
box.size=[]; //格子,[1,2]表示1X2的大格子
box.obj={};
box.oArray=[];
box.maxY=-1;
box.mbox = getElementsByClassName("MBox",el,'div');
box.row = document.documentElement.offsetWidth / box.gen.w >> 0;  //每行标准格数
el.style.width = box.row * box.gen.w + "px";
var i = 0 , nx, ny;
while( i < this.mbox.length){
if( getElementsByClassName("bigBox",this.mbox[i],'div').length > 0 ){
nx=Math.ceil(this.mbox[i].offsetWidth / this.gen.w);
nx=(nx > this.row) ? this.row : nx; //大小超出限制
ny=Math.ceil(this.mbox[i].offsetHeight / this.gen.h);
this.size.push([nx,ny]);
}else{
this.size.push(1);
}
i++;
}
box.sort(el);
};
box.setIfr=function(el){  //大格子初始化
var ifr = getElementsByClassName("bigBox",el,'div');;
if(ifr.length==0) return false;
var i = 0, nx, ny, theifr;
while(i < ifr.length){
theifr =  getElementsByClassName("innerBox",ifr[i],'div');
nx=Math.ceil(theifr[0].offsetWidth / this.gen.w); //bigBox横向占的块数
ny=Math.ceil(theifr[0].offsetHeight / this.gen.h);
ifr[i].style.width = nx*this.gen.w-14 + 'px' ;
ifr[i].style.height = ny*this.gen.h-14 + 'px' ;
i++;
}
};
box.sort=function(el){
var y=0, x=0, temp={x:Infinity, y:Infinity}, flag=Infinity, name;
for(var n=0; n < this.size.length ; n++){
if(flag == 0){
x=temp.x;
y=temp.y;
}
flag=flag-1;
if(x > box.row-1){ //换行
x=0;
y++;
}
name=x+'_'+y;  //对象属性名（反映占领的格子）
if(this.hasN(name)) {  //判断属性名是否存在
n--;
x++;
if(flag<Infinity) flag=flag+1;
continue;
}
if(!this.size[n].length){  //普通格子
this.obj[name]=[x,y];  //（反映坐标值）
x++;
}
else{  //大格子
if(this.over(x,y,n)) {
if(temp.y > y){
temp.y = y;
temp.x = x;
}
if(temp.y < Infinity){
flag=1;
}
n--;
x++;
continue;
}
this.obj[name]=[x,y];
this.apply(x,y,n);
x+=this.size[n][0];
}
if(flag==-1) {
flag = 	Infinity;
temp.y = Infinity;
temp.x = Infinity;
}
var h=this.size[n][1]-1 || 0;
box.maxY=(box.maxY > y+h)? box.maxY : y+h;
}
for(var i in this.obj){
if(this.obj[i]===0 || !this.obj.hasOwnProperty(i)) continue;
this.oArray.push(this.obj[i]);
}
box.put(el);
};
box.hasN=function(n){
return n in this.obj;
};
box.over=function(x,y,n){  //判断是否会重叠
var name;
if(x+this.size[n][0] > this.row) return true; //超出显示范围
for(var k=1; k<this.size[n][1];k++){
name=x+'_'+(y-0+k);
if(this.hasN(name)) {return true;}  //左侧一列有无重叠
}
for(k=1; k<this.size[n][0];k++){
name=(x-0+k)+'_'+y;
if(this.hasN(name)) {return true;}  //上侧一行有无重叠
}
return false;
};
box.apply=function(x,y,n){  //大格子中多占的位置
var posX=x, //大格子左上角位置
posY=y;
for(var t=0; t<this.size[n][0]; t++) {
for(var k=0; k<this.size[n][1]; k++){
name=(posX+t)+'_'+(posY+k);
if(t==0 && k==0) { continue; }
this.obj[name]=0;   //多占的格子无坐标值
}
}
};
box.put=function(el){
var x,y;
for(var i =0;i< this.oArray.length; i++){
x=box.gen.w*this.oArray[i][0];
y=box.gen.h*this.oArray[i][1];
box.mbox[i].style.cssText = "position:absolute;left:"+ x +"px;top:" + y + "px;";
};
el.style.height= box.gen.h*(box.maxY+1) +'px';
};
</script>
</head>
<body>
<div id="myWidget" class="myWidget"></div>
<script>
var myWidget = $id("myWidget");
//创建随机内容
var content = '';
for(i = 0; i < 20; i++) {
if(!(Math.random()*5 >> 0)){
height = Math.floor(Math.random()*200 + 100);
width = Math.floor(Math.random()*200 + 100);
content += '<div class="MBox"><div class="widgetBox bigBox"><div style="width:' + width +'px;height:' + height +'px;margin:0 auto;" class="innerBox">'+ i +'</div></div></div>';
}else{
content += '<div class="MBox"><div class="widgetBox">'+ i +'</div></div>';
}
};
myWidget.innerHTML = content;
//绑定拖动元素
initDrag(myWidget);
window.onresize = function(){box.init(myWidget)};
</script>
</body>
</html>



Div-wang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
横向瀑布流
12-02
这是一款横向的瀑布流插件主要使用插件jquery.capSlide.js布局简单，引用方便，是一款方便快捷的图片排列插件
瀑布流【格子块的智能堆砌】
ustbsmartcar的专栏
10-17 101
&lt;!doctype html&gt; &lt;html&gt; &lt;head&gt; &lt;meta charset="UTF-8" /&gt; &lt;title&gt;宽高尺寸不同的格子堆砌(可拖动换位)&lt;/title&gt; &lt;style&gt; body{background:#F6F7F8;} .myWidget{posit
瀑布流布局及扩展——格子块的智能堆砌
henry_xiajin
10-15 205
图片分享网站[url=http://pinterest.com/]Pinterest（beta）[/url]，在不久前获得了2700$的投资，估值已超2亿元（据说现该公司团队有8人）。该网站的一大特色就是每一张分享的图片被拟作“Pin”被钉在页面上面，每一Pin依尺寸智能排列，同时滚动页面时异步加载新Pin，极具效果。这种创新模式被在国内也被广泛copy，其中最有前途的当属[url=http://...
瀑布流效果展示图片的实现（小demo）
qq_43437571的博客
09-30 976
代码展示： 首先html页面中需要先在head中引入以下文件： <link rel="stylesheet" href="flow.css"> <script src="https://cdn.bootcss.com/jquery/3.4.0/jquery.min.js"></script> <script src="flow.js"></script> html页面： <div class="masonry"> <di
多列不等高布局之横向瀑布流和纵向瀑布流
最新发布
BUG_CONQUEROR_LI的博客
01-02 548
多列不等高布局之横向瀑布流和纵向瀑布流
jQuery+HTML5美女瀑布流布局实现方法
11-24
这是一款JavaScript与HTML5实现美女瀑布流布局，本方法是把图片的路径写在了JS的数组里，不过重点好像不是在这里，而是在图片如何自动排列的问题，你可以运行本实例后，点击“加载瀑布流布局”按钮，即可看到图片的...
网页瀑布流布局jQuery实现代码
10-21
主要为大家详细介绍了网页瀑布流布局jQuery实现方式,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
javascript瀑布流布局实现方法详解
10-22
主要介绍了javascript瀑布流布局实现方法,结合实例形式较为详细的分析了JavaScript实现瀑布流布局的样式与具体功能代码,需要的朋友可以参考下
用CSS3实现瀑布流布局的示例代码
09-24
主要介绍了用CSS3实现瀑布流布局的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
小程序源码 瀑布流布局 (代码+截图)
06-19
小程序源码 瀑布流布局 (代码+截图)小程序源码 瀑布流布局 (代码+截图)小程序源码 瀑布流布局 (代码+截图)小程序源码 瀑布流布局 (代码+截图)小程序源码 瀑布流布局 (代码+截图)小程序源码 瀑布流布局 (代码+截图)小...
横向瀑布流实现
salt_fash的博客
08-01 1544
前几天刚做完竖向的瀑布流，就来了新需求，老板说要让他横过来ヾ(｡｀Д´｡)ﾉ彡，经过一阵激烈的交锋，终于！我还是屈服在了老板的淫威帅气之下，那就做呗，不就横过来，这还不简单，CtrlC+CtrlV呗。然而，年轻的我并不知道代码的险恶。当我打开百度,输入关键词， ...
实现瀑布流布局的四种方法
Smile_666666的博客
05-13 2万+
一、 什么是瀑布流布局 1、是什么 页面上是一种 参差不齐 的多栏布局，类似上图所示随着页面滚动条向下滚动，这种布局还会不断加载数据块并附加至当前尾部，大部分为图片，图片 固定 宽度，高度 不一，根据原比例缩放到宽度达到固定的要求，每行排满后，新的图片添加到后面 2、特点 固定宽度，高度不一 岑参不齐的布局 以图片为主 二、有什么优缺点 1、优点 节省空间：降低页面的复杂 对于 触屏设备非常友好：通过向上滑动浏览，交互方式更符合直觉 良好的视觉体验：浏览时不会被页面整整齐齐的高度影响，
一小时，学习掌握瀑布流页面布局
LIMI_伞梦的博客
12-29 7120
什么是瀑布流 瀑布流，又称瀑布流式布局。是比较流行的一种网站页面布局，视觉表现为参差不齐的多栏布局，随着页面滚动条向下滚动，这种布局还会不断加载数据块并附加至当前尾部。其实瀑布流的特点就是参差不齐的排列方式，以及流式布局的扩展性，可以通过界面展示给用户多条数据，并且让用户可以有向下浏览的冲动。 博主在浏览各个网站总是看到这样的网页布局，它们的布局像瀑布流水一般，瀑布流布局在我们现在的前端页面中经常会用的到，它可以有效的降低页面的复杂度，节省很多的空间，对于整个页面不需要太多的操作，只需要下拉就可以浏览用
CSS总结——瀑布流布局
热门推荐
qq_53008257的博客
05-07 3万+
瀑布流布局 瀑布流布局是一种新型的布局方式，可以将大小不一的图片完整的显示在页面上，并且在杂乱的布局中保持着一定的美感，今天学习了一下如何使用瀑布流布局，总结了有以下三种方式。（瀑布流还可以使用grid布局实现，还没有学习过这种方式） 瀑布流的实现方法可以用纯CSS，也可以用JS实现，如何选取决于需求,这几种方法各有优略，如何选取取决于需求。以下案例均采用如下的html代码 <div class="container" id="con"> <div class="item
10几款网站瀑布流布局图片无限加载动效
weixin_30687587的博客
07-21 370
jQuery选项卡形式图片瀑布流布局选项卡切换效果代码 jquery masonry瀑布流插件制作图片瀑布流布局代码 原生js简单瀑布流图片无限加载带鼠标悬停图片遮罩效果 jquery masonry瀑布流插件制作图片瀑布流布局代码 jquery柔韧性的图片滑动瀑布流布局 jquery时间轴插件文字图片瀑布流布局时间轴特效(...
HTML＋CSS＋JS 瀑布流式布局（实现懒加载）
qq_44386537的博客
12-27 8612
HTML + JS＋CSS实现瀑布流式布局（包含懒加载） 前几天兴致来了想做一个瀑布流布局的网页，然后就有了各种“神操作”，也在网上看了一些相关的知识点；所以这里对自己这几个小时来一个总结 先上效果图 首先来说一下瀑布流的原理吧：瀑布流是许多数据块组成的，可以是图片，可以是div，但是它们都有一个特点，就是等宽不等高，正是因为它等宽不等高，所以如果按部就班的排布的话，才会出现很大的缝隙，特别不好看，说白了瀑布流布局就是充分利用图片之间的空隙来合理的布局，使布局看起来好看，符合人眼的审美。 首先上CSS布局
实现瀑布流布局，就这几行代码？
祈澈菇凉
02-10 847
瀑布流布局是一种比较流行的页面布局方式，表现为参差不齐的多栏卡片。跟网格布局相比，显得更灵动，更具艺术气息。实现瀑布流布局的方式有多种，比如multi-column布局，grid布局，fl...
（转）纯css3实现横向瀑布流
大脑和心脏都要跳动的97
06-13 3680
https://blog.csdn.net/cuiji4724/article/details/83860052 今天要从纵向改横向 纵向用column-count就好了 但是横向嘛 上面帖子帮我解决了 蟹蟹原贴主 想着以后忘了可以再找到看看 留个地址 侵删┗|｀O′|┛ 嗷~~ ...
【学习笔记48】瀑布流代码的实现
yizhiyang
11-28 258
day39：瀑布流代码的实现
瀑布流布局使用grid布局实现 css完整代码
12-03
以下是使用grid布局实现瀑布流布局的CSS代码： ```css .container { display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); grid-gap: 20px; } .item { background-color: #ccc; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值