前端js

css+js解决文本两端对齐以及分散对齐

一个很简单的设计排版样式,A图表示居左对其,但实际上我们想要的可能是B所示的对齐方式。

这就是传说中的两端对齐 还有一种更确切的说法是两端分散对齐。

问题

最开始的时候 ,我试图使用CSS来解决这个小问题,查阅了很多办法,发现没有一种完美兼容的解决方式。

在一些csser使用了css的两端对齐方案是基于 text-align:justify 及 text-align-last:justify 实现来解决这个问题,但是需要在每个字的后面加上空格。

这个办法是这样的:

原理:是通过调整字之间的空格大小来达成的,所以需要事先在每个单词和汉字间都插入一个空格。

ie下 text-align:justify; 是可以产生作用的。所以在ie下很容易实现:

p { 
text-align:justify;
text-align-last:justify;
}

text-align-last 在Firefox12-17下仍处理实验支持阶段,需加前缀 -moz-,FF下这样实现

p{
text-align:justify;
-moz-text-align-last:justify;
}
Chrome, Safari, Opera实现比较麻烦:Chrome23, Safari5.1.7, Opera12.11 不支持 text-align-last, 但支持 text-align 的 jsutify, text-align:justify 不处理块内的最后一行文本(包括块内仅有一行文本的情况,这时既是第一行也是最后一行)及被强制打断的行的两端对齐,但会处理除此之外的其它行,所以只需要将这里的单行变成多行即可,那么我们可以使用伪对象的方式派生出新行,这样不需要额外处理html代码,然后再将派生出的新行隐藏!!
p{
overflow:hidden;
height:20px;
text-align:justify;
}
p:after{
display:inline-block;
content:'';
overflow:hidden;
width:100%;
height:0;
}

这样的,基本上可以实现我们想要的效果了。
但是,我今天想要推荐的方法并不是上面的办法,上面的办法在静态页面中确实可以使用,但是无端端的增加空格对于 数据比较多的情况下 就有点麻烦,而且 ,如果文本如果是动态的或者文本是用户提交的情况,我们就很难控制在文本增加空格了。所以,我的思路是通过脚本改变文本的letter-spacing来实现文本两端分散对齐。
重点是算法:
首先我们看下面图
问题
四行,汉字的个数分别是 2、2、4、3
我们想要达到B的效果只需要 其他几个长度都与最长的4个汉字保持一致,这里我们要通过增加其他行的间隙,我们使用em单位来实现。
很显然,我们给第1-2行分别增加2em的letter-spacing来对齐;给第四行增加多少em才能对齐呢?
计算办法  需要增加的空隙长度=(4-3)/2 也就是 (最大文本个数-当前文本个数)/(当前文本个数-1)
验证一下:
姓名需要增加的letter-spacing值=(4-2)/(2-1)=2 同理性别也是 这样计算
公式就是:当前文本需要增加的长度=(最大长度-当前长度)/(当前长度-1)
这样算法出来就好办了
HTML中代码如下

<p class="t1">姓名</p>
<p class="t1">性别</p>
<p class="t1">兴趣爱好</p>
<p class="t1">座右铭</p>

JQ做了一个脚本,针对指定样式的行实现两端对齐。

function justify_Let(obj){
 	var obj=$(obj);
    var lengths=[];
    obj.each(function(){
    	lengths.push($(this).text().length);

    });
    //var smax=Math.max(lengths);
    if(lengths.length==0){return;}
    for(var i=0,smax=lengths[0],len=lengths.length;i<len;i++){
    	if(lengths[i]>smax){
    		smax=lengths[i];
    	}
    }

    for(var i=0,len=lengths.length;i<len;i++){
    	var currlen=lengths[i];
    	if(currlen==smax){continue;}
    	obj.eq(i).css({"letter-spacing": ((smax-currlen)/(currlen-1))+"em"});
    }

html页面调用办法

<script type="text/javascript">// <![CDATA[
justify_Let(".t1")
// ]]></script>

这种办法处理起来有好处的
优点:
1、无需增加多余的空格或者空字符或者空行
2、对动态添加的文本同样生效
3、对用户输入的文本也同样适用
4、无论多少行数都会自动两端对齐

缺点:
1、需要使用js和jq脚本实现,增加了一个脚本的请求。
2、目前只能支持每行都是中文字符或者每行都是英文,因为计算办法是文本长度。
3、多行大小写同时存在的情况也还没能实现兼容。

原创文章,转载请注明出处。欢迎转载。

阅读 4,070 评论 0 阅读全文

js试题

1、HTTP协议的状态消息都有哪些?http://www.cnblogs.com/TankXiao/archive/2013/01/08/2818542.html

2、AJAX是什么? AJAX的交互模型(流程)? AJAX跨域的解决办法?

AJAX是一种异步请求交互技术。( 语文不好,我觉得这样应该差不多了)

AJAX的交互模型 客户端请求-提交服务器-处理信息-返回客户端-刷新区域

跨域还没有接触过……

3、同步和异步的区别?

大体上讲就是B/S模式和AJAX的区别吧。囵吞(错字?)网页刷新区域和时间的区别吧。

4、JavaScript封装(能不能不问这种理论问题,非常的不会答。)

简单点说吧,就是让一段代码可以重复的调用,并且通过所传值返回不同的值!

5、JavaScript继承有哪两种形式形式(擦,这么大一个问题)

对象冒充和圆形方式

对象冒充:有函数A 函数B  函数B中调用函数A

例:

  1.  
    1. function A(name){ 
    2. this.name = name; 
    3. this.sayHello = function(){alert(this.name+” say Hello!”);}; 
    4. function B(name,id){ 
    5. this.temp = A; 
    6. this.temp(name);        //相当于new A(); 
    7.     delete this.temp;        //防止在以后通过temp引用覆盖超类A的属性和方法 
    8.      this.id = id; 
    9. this.checkId = function(ID){alert(this.id==ID)}; 

圆形方式:

例:有函数A 函数B 函数B通过prototype或某种方式来复制A的属性或方法

    1. functionA(){ 
    2.   this.name = “Mike”; 
    3.   this.sayGoodbye = function(){alert(“GoodBye!”);}; 
    4. A.prototype.sayHello = function(){alert(”Hello!”);}; 
    5. function B(){} 
    6. B.prototype = new Person();

 

6.javascript 闭包

读取其他函数内部变量的函数(关键是变量的继承,理解全局变量和局部变量)

7、以下代码点击<p> 会输出什么?为什么?能大概说明白的话继续问能想出几种

  1.  
    1. <!DOCTYPE HTML> 
    2. <html> 
    3. <head> 
    4. <meta charset=”utf-8″ /> 
    5. <title>闭包演示</title> 
    6. <style type=”text/css”> 
    7.     p {background:gold;}  
    8. </style> 
    9. <script type=”text/javascript”>   
    10. function init() {      
    11.     var pAry = document.getElementsByTagName(“p”);      
    12.     for( var i=0; i<pAry.length; i++ ) {      
    13.          pAry[i].onclick = function() {      
    14.          alert(i);      
    15.     }   
    16.   }  
    17. }  
    18. </script>   
    19. </head>   
    20. <body onload=”init();”>   
    21. <p>产品 0</p>   
    22. <p>产品 1</p>   
    23. <p>产品 2</p>   
    24. <p>产品 3</p>   
    25. <p>产品 4</p>   
    26. </body>   
    27. </html>  

   全部都弹出5,因为弹出i时,i已经被保存在内存中,他的值是for结束是最后的值所以是5。问题是闭包产生的,解决方法就是解决闭包,用(function(){})()可以消除闭包

具体可以这样写

  1.  
    1. function init() {      
    2.     var pAry = document.getElementsByTagName(“p”);      
    3.     for( var i=0; i<pAry.length; i++ ) {
    4.    (function(i) {pAry[i].onclick = function() { alert(i);}}(i))
    5.   }  
    6. }  

 

8、在JS中this关键字的使用场合和用法(如在构造函数中、setTimeout中等)

  this一般使用在构造函数中, 用来引用对象。

9、DOM操作 – 怎样添加、移除、移动、复制、创建和查找节点(这个问题真心是基础题,一般不会问)。

添加:appendChild()  移除:removeChild() 复制:replaceChild()  创建 createDocumentFragment()  查找:getElementsByTagName().

10、简述下cookie的操作,还有cookie的属性都知道哪些!

创建-保存-读取-判断-显示

cookie属性:常用的名称,值,过期时间。

11.IE与FF的JS兼容性都知道哪些。

变量名与ID重复,event的x和y属性,对BODY的解析时间以及input的属性修改状态 innerHTML 和innerText等待。

阅读 5,221 评论 0 阅读全文

Javascript继承两种形式

Javascript本身是从Perl语言的语法演变而来的,本质上是脚本语言,随着版本的更新逐渐加入的对面向对象的模拟。我认为Js的面向对象模拟总 体上做得还是不错的,因为我们不能盲从任何一种理念,不能纯粹的为了OOP而OOP,我们需要抓住的是面向对象的好处到底是什么?为了这些优点去OOP, 才是最明智的选择,所以说Js做得还不错。 

Js的继承在很多书里面细致的分了很多种类型和实现方式,大体上就是两种:对象冒充、原型方式。这两种方式各有优点和缺陷,这里我先列举出来,再从底层分析区别: 

(一)对象冒充 

function A(name){ 
this.name = name; 
this.sayHello = function(){alert(this.name+” say Hello!”);}; 
} 
function B(name,id){ 
this.temp = A; 
this.temp(name);        //相当于new A(); 
    delete this.temp;        //防止在以后通过temp引用覆盖超类A的属性和方法 
     this.id = id; 
this.checkId = function(ID){alert(this.id==ID)}; 
} 

当构造对象B的时候,调用temp相当于启动A的构造函数,注意这里的上下文环境中的this对象是B的实例,所以在执行A构造函数脚本时,所有A的变量 和方法都会赋值给this所指的对象,即B的实例,这样子就达到B继承了A的属性方法的目的。之后删除临时引用temp,是防止维护B中对A的类对象(注 意不是实例对象)的引用更改,因为更改temp会直接导致类A(注意不是类A的对象)结构的变化。 

我们看到了,在Js版本更新的过程中,为了更方便的执行这种上下文this的切换以达到继承或者更加广义的目的,增加了call和apply函数。它们的 原理是一样的,只是参数不同的版本罢了(一个可变任意参数,一个必须传入数组作为参数集合)。这里就以call为例子,解释一下用call实现的对象冒充 继承。 

function Rect(width, height){ 
this.width = width; 
this.height = height; 
this.area = function(){return this.width*this.height;}; 
} 
function myRect(width, height, name){ 
Rect .call(this,width,height); 
this.name = name; 
this.show = function(){ 
alert(this.name+” with area:”+this.area()); 
} 
} 

关于Call方法,官方解释:调用一个对象的一个方法,以另一个对象替换当前对象。 
call (thisOb,arg1, arg2…) 

这也是一种对象冒充的继承,其实在call方法调用的时候发生的事情也是上下文环境变量this的替换,在myRect函数体中this肯定是指向类 myRect对象的实例了,然而用这个this作为上下文环境变量调用名字叫Rect方法,即类Rect的构造函数。于是此时调用Rect时候对this 的赋值属性和方法都实际上是对一个myRect的对象进行。所以说尽管call和apply并不是仅仅为了继承而新增的方法,但用它们可以模拟继承。 

对象冒充继承就是这么一回事,它可以实现多重继承,只要重复做这一套赋值的流程就可以了。不过目前真正大规模使用得并不多,为什么呢?因为它有一个明显的 性能缺陷,这就要说道OO的概念了,我们说对象是成员+成员方法的集合,构造对象实例的时候,这些实例只需要拥有各自的成员变量就可以了,成员方法只是一 段对变量操作的可执行文本区域而已,这段区域不用为每个实例而复制一份,所有的实例都可以共享。现在回到Js利用对象冒充模拟的继承里,所有的成员方法都 是针对this而创建的,也就是所所有的实例都会拥有一份成员方法的副本,这是对内存资源的一种极度浪费。其它的缺陷比如说对象冒充无法继承 prototype域的变量和方法就不用提了,笔者认为前一个致命缺陷就已经足够。不过,我们还是需要理解它,特别是父类的属性和方法是如何继承下来的原 理,对于理解Js继承很重要。 

(二)原型方式 
第二种继承方式是原型方式,所谓原型方式的继承,是指利用了prototype或者说以某种方式覆盖了prototype,从而达到属性方法复制的目的。 其实现方式有很多中,可能不同框架多少会有一点区别,但是我们把握住原理,就不会有任何不理解的地方了。看一个例子(某一种实现): 

function Person(){ 
this.name = “Mike”; 
this.sayGoodbye = function(){alert(“GoodBye!”);}; 
} 
Person.prototype.sayHello = function(){alert(”Hello!”);}; 
function Student(){} 
Student.prototype = new Person(); 
function Person(name){ 
this.name = name; 
} 
function Student(name,id){ 
this.id = id; 
} 
Student.prototype = new Person(this.name); 

关键是对最后一句Student原型属性赋值为Person类构造的对象,这里笔者解释一下父类的属性和方法是如何copy到子类上的。Js对象在读取某 个对象属性的时候,总是先查看自身域的属性列表,如果有就返回否则去读取prototype域(每个对象共享构造对象的类的prototype域所有属性 和方法),如果找到就返回,由于prototype可以指向别的对象,所以Js解释器会递归的去查找prototype域指向对象的prototype 域,直到prototype为本身,查找变成了一种循环,就停止,此时还没找到就成undefined了。 

这样看来,最后一句发生的效果就是将父类所有属性和方法连接到子类的prototype域上,这样子类就继承了父类所有的属性和方法,包括name、 sayGoodbye和sayHello。这里与其把最后一句看成一种赋值,不如理解成一种指向关系更好一点。这种原型继承的缺陷也相当明显,就是继承时 父类的构造函数时不能带参数,因为对子类prototype域的修改是在声明子类对象之后才能进行,用子类构造函数的参数去初始化父类属性是无法实现的, 如下所示: 

function Person(name){ 
this.name = name; 
} 
Person.prototype.sayHello = function(){alert(this.name+“say Hello!”);}; 
function Student(name,id){ 
Person.call(this,name); 
this.id = id; 
} 
Student.prototype = new Person(); 
Student.prototype.show = function(){ 
alert(“Name is:”+ this.name+” and Id is:”+this.id); 
} 

两种继承方式已经讲完了,如果我们理解了两种方式下子类如何把父类的属性和方法“抓取”下来,就可以自由组合各自的利弊,来实现真正合理的Js继承。下面是个人总结的一种综合方式: 

总结就是利用对象冒充机制的call方法把父类的属性给抓取下来,而成员方法尽量写进被所有对象实例共享的prototype域中,以防止方法副本重复创 建。然后子类继承父类prototype域来抓取下来所有的方法。如想彻底理清这些调用链的关系,推荐大家多关注Js中prototype的 constructor和对象的constructor属性,这里就不多说了。

阅读 4,038 评论 0 阅读全文

记录工作生活点滴。

返回
顶部