js1常用的东西

1 .ready 与resize方法。
$(inject).ready(function() {
var windowWidth = $(document.body).outerWidth(true);
resizeBannerAd(windowWidth);
});
$(window).resize(function() {
var windowWidth = $(document.body).outerWidth(true);
resizeBannerAd(windowWidth);
});
2 .获取meta标签中的
$('meta[name="pageInfo"]').attr('content')

$('meta[name="pageInfo"]').attr('content').split('|')[1]
3.
var domElem = $("#fla_box")[0];
if (!domElem){
domElem = $(".zt_player")[0];
if (!domElem) return;
}
function 用 typeof判断
也可以用 instanceof
也可以简单点用：
thisMovie('www_player_1').cmdPauseToShowVppAds
但这样子不一定是个方法。
4.
var s = document.createElement("script");
document.getElementsByTagName("head")[0].appendChild(s);
这里我们明白。
这里不能document.getElementsByTagName("body")[0].appendChild("<div>真的</div>");
5. //if(!__ADINFO__ && ! __ADINFO__.arkId) return;
responsePlayer = require('bz/www_play/responsePlayer');
这里判断不能用判断属性是否存在的方式，要用判断方式是否存在的试试，typeof object=='function'
或者object instanceof Function大写
6. 关于加载js。
<script type="text/javascript" src='1.js'></script>
<script type="text/javascript" src='2.js'></script>
这样子加载的1.js和2.js这里可以看出来，肯定是1中resize先执行，然后在执行2中，所有主站中的我们肯定是先执行，我们广告的2.js中的可以用prev()这种方法根据上边的确定他们的。
7.================================================================
网上的大咖
闭包作用域小,但是这个变量会一直在内存中保留 多了会内存外溢
会释放的！
有作用域引用计数器的
除非无限制递归
比如做个堆排序，无限制递归要考虑一下
也就是你的闭包不用了或者作用域中没有异步跳出那么里面的变量就会被释放了！
【传说】0x6ce0(450044101) 9:41:57
强行作用域引用计数。。
修改对象原型，特别是共用的对象就会出现一些莫名的污染！比如有时候在某个对象上只有3个属性或方法，可是当另外一份代码修改或者添加方法，那么第一份的方法或者属性调用会失败，遍历属性一样得到意想不到的结果！
传说】0x6ce0(450044101) 9:44:51
1，引用计数是变量。2，v8的gc用的不是引用计数
所以我一般不做原型继承扩展！
v8不是混合了几种方式吗？
没种引擎可以有不同做法，看实现者考虑的了！但是道理基本上没多大变化，一样是结束使用就回收！
很多方法，或者链式压栈，或者引用计数还有好多他们自己喜欢的做法
这个要看栈什么时候被销毁
函数执行完
只要能算出变量不在被使用就可以了
闭包情况下 是要手动写点什么来释放变量吗?还是js自带的。
【活跃】叶子(26029682) 9:57:22
js自己释放的！
【传说】隐木(412950798) 9:57:59
貌似暴露到全局的闭包变量需手动
暴露的应用结束后一样被释放，你手动也是提前清理()
8=================================================================
prototype扩展的属性和自身的对象属性不在一个里面。
【冒泡】SunnyBoy(534877846) 11:21:35
prototype扩展的方法和属性都在__proto__里面。
9--------------------------------------
var ss = {
yan1:function(){
this.name="yan1";
},
yan2:function(){
alert(this.name);
}
}
ss.yan1();
ss.yan2();//yan1

10.var yan=function(){
this.name="yanjinyun";
}
var yan1=new yan;
var yan2=new yan();
这两种创建对象的方式一样。

11.------------------------------------------------------------------
function Boo() {}
function Foo() {}
Foo.prototype.say=function(){
alert("nih");
}
Foo.prototype = new Boo;
p=new Foo;
p.say();//报错
这样子会造成原型覆盖。
12--------------------------------------------
PluginAD.focus_adkeys = PluginAD.focus_adkeys || {};

var ADUID;
if (PluginAD.focus_adkeys[""+ADUID]){
return;
}
PluginAD.focus_adkeys[""+ADUID] = 1;
13--------------------------------------------------
js用递归模拟深拷贝。
function extendDeep(parent, child) {
var i,
toStr = Object.prototype.toString,
astr = "[object Array]";
child = child || {};
for (i in parent) {
if (parent.hasOwnProperty(i)) {
if (typeof parent[i] === "object") {
child[i] = (toStr.call(parent[i]) === astr) ? [] : {};
debugger
extendDeep(parent[i], child[i]);
} else {
child[i] = parent[i];
}
}
}
return child;
}
var box={name:"yan",arr:[1,3,5],obj:{objName:"objyan",age:20}}
for(var x in box){
alert(box[x]);
}
debugger
var copy=extendDeep(box);
var copy1=box;
//1.首先我们需要记住for(var i in parent)
//2.其次我们需要明白循环从第一个开始。按顺序的。
14----------------------------------------------------------
我们一定要注意，网页的另存为和查看网页源码后的保存的文档是不同的。
15.

//i am a student.
/*var box="i am a student";
var box1=['yanjinyun',23,{name:'yan'}];
box1.splice(1,0,'tamen',13);*///返回值为空

16. 这个我们需要知道，jquery对象转化为数组。然后遍历。
/*var obj=$('#fla_box').find('[id^="www_player_"]')[0];
if(obj.length==1){
$('#fla_box').find('[id^="www_player_"]')[0].onTuhaoClosed();
}else{
for(var i=0;i<obj.length;i++){
if(obj.get()[i].parents('div[id^="fla_box"]')){
obj[0].onTuhaoClosed();
}
}
}*/

17.

function RenderFunc() {
var self = this;
return function(data) {
self.data = data;
self.init();
};
}
RenderFunc.prototype.init = function() {
var self=this;
function onResize() {
alert(self.data);
}
$(window).resize(onResize);
}
var box1=new RenderFunc();
box1('yan1');
box1('yan2');
//出现的问题当浏览器变化的时候，两次alert出来的都是yan2.

这是因为self是一个引用，引用不会改变的，我们可以直接传self.data进入，传实际的值，或者把self浅引用一下。

1 关于setinterval的理解

这里的判断 条件不能写成==0，这样子的话可能执行太快就不==0了，所以必须<=0;

2

var data=dataF.substr(1).substring(-1,0);

var data=JSON.parse(dataF);

Js 中不能用”{}”这样子传，但是flash调用的时候可以这样传，并且可以parse.

window.ZhanMuAD("{"tMethod":"flash","url":"http://i2.letvimg.com/lc03_creative/201511/13/11/24/ZhanMuMain2.swf","isZhanMu":"1","rightSwf":"http://ads.lesports.com/demo/20151008MatchBoard/200x7450":"http://ads.lesports.com/demo/20151008MatchBoard/200x745001.swf"}");

3

<script language="javascript1.2">

function test() {

if((a.b.value.indexOf ("***") == 0)||(a.b.value.indexOf ("****") == 0)){

alert(":)");

a.b.focus();

return false;}

}

</script>

<form name=a onsubmit="return test()">

<input type=text name=b>

<input type="submit" name="Submit" value="check">

</form>

这里的form提交事件中，我们可以直接a.b.value这种写法。

4

找出HTMLDIVDOCUMENT对象的里边的内容。分清

Console.log

Console.dir

Console.dirxml

innerHTML用法。

5

javascript中void是一个操作符，该操作符指定要计算一个表达式但是不返回值。 
javascript:;好些，javascript:void(0);
据说某些情况下有浏览器兼容bug。
可以写成javascript:;，qq空间很多都是写成javascript:; 
两者之间没有什么差别，都是执行一个空事件

6  js原生获取页面及个元素高度、宽度，关于body属性。

Document.body是获取body的一种比较简单的方式。

网页可见区域宽：document.body.clientWidth; 如果浏览器缩小的话，那么这个宽度也会变小。

网页可见区域高：document.body.clientHeight; 如果有滚动而隐藏的高度的话，那么也会算在里面。

网页可见区域宽： document.body.offsetWidth (包括边线和滚动条的宽);

网页可见区域高： document.body.offsetHeight (包括边线的宽);

网页正文全文宽： document.body.scrollWidth; //包含当前界面的宽度

网页正文全文高： document.body.scrollHeight;//包含当前界面的高度

以上三种方法推荐使用scrollWidth和scrollHeight。

----------------------------------------------------------------------------------------------------------------

网页被卷去的高(ff)：document.body.scrollTop;

网页被卷去的高(ie): document.documentElement.scrollTop;

IE浏览器不用body获取高而是用documentElement获取界面的高。

网页被卷去的左：document.body.scrollLeft;

有的地方说：我试了下，下面的说的好像不对，上面的对。

scrollLeft:设置或获取位于对象左边界和窗口中目前可见内容的最左端之间的距离
scrollTop:设置或获取位于对象最顶端和窗口中可见内容的最顶端之间的距离

网页正文部分上：window.screenTop;  //窗口缩小后，窗口对于电脑屏幕的位置。

网页正文部分左：window.screenLeft;

----------------------------------------------------------------------------------------------------------------------

某个元素的宽度：obj.offsetWidth;

某个元素的高度：obj.offsetHeight;

某个元素的上边界到body最顶部的距离：obj.offsetTop;（在元素的包含元素不含滚动条的情况下）

某个元素的左边界到body最左边的距离：obj.offsetLeft;（在元素的包含元素不含滚动条的情况下）

返回当前元素的上边界到它的包含元素的上边界的偏移量：obj.offsetTop（在元素的包含元素含滚动条的情况下）

返回当前元素的左边界到它的包含元素的左边界的偏移量：obj.offsetLeft（在元素的包含元素含滚动条的情况下）

我赞同上一种。

还有另外一种说法：

offsetHeight:获取对象相对于版面或由父坐标 offsetParent 属性指定的父坐标的高度
offsetLeft:获取对象相对于版面或由 offsetParent 属性指定的父坐标的计算左侧位置
offsetTop:获取对象相对于版面或由 offsetTop 属性指定的父坐标的计算顶端位置

------------------------------------------------------------------------------

易混淆点：

clientX 设置或获取鼠标指针位置相对于当前窗口的 x 坐标，其中客户区域不包括窗口自身的控件和滚动条。 
clientY 设置或获取鼠标指针位置相对于当前窗口的 y 坐标，其中客户区域不包括窗口自身的控件和滚动条。 
offsetX 设置或获取鼠标指针位置相对于触发事件的对象的 x 坐标。 
offsetY 设置或获取鼠标指针位置相对于触发事件的对象的 y 坐标。 
screenX 设置或获取获取鼠标指针位置相对于用户屏幕的 x 坐标。 
screenY 设置或获取鼠标指针位置相对于用户屏幕的 y 坐标。 
x 设置或获取鼠标指针位置相对于父文档的 x 像素坐标(亦即相对于当前窗口)。 
y 设置或获取鼠标指针位置相对于父文档的 y 像素坐标(亦即相对于当前窗口)。

document.documentElement.scrollTop 垂直方向滚动的值
event.clientX+document.documentElement.scrollTop 相对文档的水平座标+垂直方向滚动的量
以上主要指IE之中，FireFox差异如下：
IE6.0、FF1.06+：
clientWidth = width + padding
clientHeight = height + padding
offsetWidth = width + padding + border
offsetHeight = height + padding + border

屏幕分辨率的高： window.screen.height;
屏幕分辨率的宽： window.screen.width;

屏幕可用工作区高度： window.screen.availHeight;
屏幕可用工作区宽度：window.screen.availWidth;

scrollTop, scrollLeft

设置或返回已经滚动到元素的左边界或上边界的像素数。只有在元素有滚动条的时候，例如，元素的 CSS overflow 属性设置为 auto 的时候，这些像素才有用。这些属性也只在文档的 <body> 或 <html> 标记上定义（这和浏览器有关），并且一起来制定滚动文档的位置。注意，这些属性并不会指定一个 <iframe> 标记的滚动量。这是非标准的但却得到很好支持的属性

7    obj.offsetHeight与obj.style.height区别

1、obj.offsetHeight可以获取写在样式文件里的属性值，而obj.style.height只能获取行内属性，在表现与结构分离的今天，这显然是不合适的

2、obj.offsetHeight返回的是一个数值，而obj.style.height返回的是一个字符串，单位是“px”

3、obj.offsetHeight是只读，而obj.style.height是可读写

4、如果没有为元素设置高度，obj.offsetHeight会根据内容获取高度值，而obj.style.height会返回undefine

jQuery里我们使用$(obj).height()来获取元素的高度，（$(obj).css('height')返回的是一个带有单位的字符串）。

与其他三个（$(obj).height()、$(obj).css('height')、obj.style.height）不同的是，obj.offsetHeight的高度就是height+padding,其他是不把padding计入高度的

8

<div><img/></div>

外层div的max-width和max-height 不可以控制里面的img的宽度和高度。如果里边的img 中图片的原始尺寸和宽过于大的话，我们只能控制，img标签的宽和高来控制。

10 Jquert中对于元素的大小和位置，有属性有方法。

jQuery里我们使用$(obj).height()来获取元素的高度，（$(obj).css('height')返回的是一个带有单位的字符串）。

前面的就是方法，后边的而利用css属性方法。

一、获得坐标

1.offset()

offset() 方法返回或设置匹配元素相对于文档的偏移（位置）。（即视口坐标）

该方法返回的对象包含两个整型属性：top 和 left，以像素计。

此方法只对可见元素有效。

2.position()

position() 方法返回匹配元素相对于父元素的位置（偏移）。(相对于父元素的文档坐标）

该方法返回的对象包含两个整型属性：top 和 left，以像素计。

此方法只对可见元素有效。

3.offsetParent()

offsetParent() 方法返回最近的祖先定位元素。

定位元素指的是元素的 CSS position 属性被设置为 relative、absolute 或 fixed 的元素。

可以通过 jQuery 设置 position，或者通过 CSS 的 position 属性。

二、获得尺寸

1.width() 和 height() 方法

width() 方法设置或返回元素的宽度（不包括内边距、边框或外边距）。

height() 方法设置或返回元素的高度（不包括内边距、边框或外边距）。

2.innerWidth() 和 innerHeight() 方法

innerWidth() 方法返回元素的宽度（包括内边距）。

innerHeight() 方法返回元素的高度（包括内边距）。

3.outerWidth() 和 outerHeight() 方法

outerWidth() 方法返回元素的宽度（包括内边距和边框）。

outerHeight() 方法返回元素的高度（包括内边距和边框）。

outerWidth(true) 方法返回元素的宽度（包括内边距、边框和外边距）。

outerHeight(true) 方法返回元素的高度（包括内边距、边框和外边距）。

11 我遇到的情况分析一----------微信底部banner版权的控制。

If($(window).outerWidth(true)>$(document).outerWidth(true)){

$(‘.footer’).addClass(‘bottom’);

}

12 我遇到的情况分析二---------迪奥真我香水

对于获取iframe的元素的兼容处理：

var ifm= document.getElementById("iframepage");

var subWeb = document.frames ? document.frames["iframepage"].document : ifm.contentDocument;

var data=subWeb.body.scrollHeight/subWeb.body.scrollWidth;//一般我们用scrolllWidth不用其他clientWidth和offsetWidth.

对于iframe的使用，我们获取iframe元素的方法，一般用id，但是如果获取iframe里边的东西的话，我们一般用subWeb去获取里边的内容，注意此时用onload属性，

我们一般情况下onload只能用于window和body两个的属性，如果有iframe的话，我们也可以用onload。

我这里写的有问题，大师那个方法不能放在onload里边执行。如果放在现在的位置，就是后边执行的话，必须有一个默认的高度，而不是自动获取到的元素内容的高度。

13 $(‘*’)$(‘*’,’document.body’) 和$(‘document.body’).

14

function  YAN(name,age){

this.name=name;

var age=age;

}

var y=new YAN('jjj',12);

alert(y.name);//jjj

alert(y.age);//undefined

=====================================

1016/4/29新增加的内容：

Javascript权威指南（第6版）中文版

1.

var sss={'a': 'a1','b': 'b2','c': 'c3'}

sss.a   sss[‘a’]

2.函数是函数，方法准确的表示是对象中的函数就是方法了。

3.数据库中需要用租户的字段进行数据隔离，在面向对象的思想中，创建一个对象，也要实现对象的数据隔离，同一个类创建的对象，引用的地址不同。

4.数据库只是一种服务而已，他的底层本质也是类似于text的文本编辑器。

5.Load方法只有window和body两个对象拥有，比如iframe中的body也有。

6.if(image.addEventListener){image.addEventListener('click',hide,false);}

else{image.attachEvent("onclick",hide);}//兼容IE8即以前的版本

function hide(event){event.target.style.visbility="hidden";}

addEventListener的第三个参数

phase: true/false, true表示在捕获阶段执行，false表示在冒泡阶段执行

addEventListener非IE用，attachEvent IE用。

7.

addEventListener与attachEvent的区别

1. 支持的浏览器addEventListener在支持DOM2的浏览器中使用，如FF, Chrome等attachEvent为IE所用

2. 处理程序执行阶段addEventListener的第三个参数为true时，在捕获阶段执行，为false时，在冒泡阶段执行attachEvent的均在冒泡阶段执行

3. 作用域addEventListener的作用域为元素作用域，this为element的引用addEvent的为全局作用域，this为window的引用

4. 事件处理程序执行顺序addEventHander：执行顺序与添加顺序一致attachEvent：执行顺序与添加顺序相反

5.移除事件处理函数element.removeEventListener(type, handler, phase);

移除事件处理程序element.detachEvent(type, handler);

1. Jquert重新debug函数

function debug（msg）{

var log=$("#debuglog");if(log.length==0){

log=$("<div id='debuglog'><h1>Debug log</h1></div>");log.appendTo(document.body);

}

log.append($("<pre/>").text(msg));

}

1. Window.localstorage.
2. encodeURIComponent
3. Javascript onclick必须写成驼峰命名。
4. javascript解释器有自己的内存管理机制，可以自动对内存进行垃圾回收，这意味着程序可以按需创建对象，程序员则不必担心这些对象的销毁和内存回收，当不再有任何引用指向一个对象，解释器就会知道这个对象没用了，然后自动回收它所占用的内存资源。
5. java是面向对象的语言，而js是基于对象的语言。
6. Js 中的取反-取补~ 左移<< 右移>> 无符号右移>>>
7. !!双重否定表示肯定，把一般的变为boolean类型。
8. !（取反)
9. 事件的重复注册。

18.

function Lakers() {

this.name = "kobe bryant";

this.age = "28";

this.gender = "boy";

}

var people=new Lakers();

with(people)

{

var str = "姓名: " + name + "<br>";

str += "年龄：" + age + "<br>";

str += "性别：" + gender;

document.write(str);

}

19.

空语句的作用

//初始化一个数组a

for(i=0;i<a.length;a[i++]=0);

20 不可以在if else while 等中定义方法。

21 方法的两种定义方法:

尽管函数声明语句和函数定义表达式包含相同的函数名，但两者不同，两种方式都创建了新的函数对象，但函数声明语句中的函数名是一个变量名，函数指向函数对象，和通过var 声明变量一样，函数定义语句中的函数被显示地提前到了脚本或函数的顶部，因此它们在整个脚本和函数内部都是可见的。使用var 的话，只有变量声明提前了，变量的初始化代码仍然在原来的位置。然而使用函数声明语句的话，函数声明和函数体均提前：脚本中的所有函数和函数中所有嵌套的函数都会在当前上下文中其他代码之前声明。也就是说，可以在声明一个javascript函数之前调用它。

22.

mainloop:while(token!=null){

//忽略这里的代码

continue mainloop;

}

1. 如果return 后面不写表达式的话，那么相当于返回undefine;
2. For 和while在执行，try和finally组成的语句，有微妙的差异。
3. With不推荐使用，但是还是有一些亮点的，

with(p)x=1;如果p有x属性，赋值为1，如果p中没有定义属性x，和不使用x是一模一样的。with提供了一种读取p的属性的快捷方式，但不能创建p的属性。

1. 如果一个对象的最后一个属性后的逗号没有去掉，IE报错，但是其他浏览器没有问题。
2. Js中对象的属性名，如果是json则必须加引号，如果只是js对象，可以不加。
3. 对象直接量。

var circle = {x:0, y:0, radius:2};

可以理解为：

var circle = new Object();circle.x = 0;circle.y = 0;circle.radius = 2;简写形式。而不是所谓Circle构造函数生成的实例，如果想是Circle构造函数生成的话，需要楼主自定义一个Circle构造函数，比如:

function Circle(x, y, radius){

this.x = x;

this.y = y;

this.radius = radius;

}

var circle = new Circle();

29.

js的三类对象和两类属性：

内置对象，宿主对象（浏览器你去），自定义对象，自有属性和继承属性。

30.

Js中把对象和构造器（函数名）搞得差不多了。

Math  Json 这两个直接以对象的形式存在的，是内置对象，直接调方法。

1. 一个网站有趣比他赚钱更有意义，一般来说，有趣的才能赚钱。
2. __pro__   prototype  constructs

所有内置函数（12个其中8个）的__pro__指向Function.prototype.

Number,Boolean,String,Object,Function,Array,Error,Date

其中Function.prototype 打印出来是function(){}

所有自定义函数的__pro__也是指向Function.prototype的。

Global不能直接访问，Arguments仅在函数调用时由JS引擎创建，Math，JSON是以对象形式存在的，无需new。它们的__proto__是Object.prototype。

Function.prototype也是唯一一个typeof XXX.prototype为 “function”的prototype。其它的构造器的prototype都是一个对象，这个对象含有这个构造器的继承方法。 这里我们只研究了typeof XXX.prototype 而对于,Array.prototype打印出来的是[],Object.prototype打印出来{}，String.prototype打印出来{}。

console.log(Function.prototype.__proto__ === Object.prototype) // true

这说明所有的构造器的prototype也都是一个普通JS对象，可以给构造器添加/删除属性等。同时它也继承了Object.prototype上的所有方法：toString、valueOf、hasOwnProperty等。

Object.prototype.__proto__ === null  // true

所有对象的__proto__都指向其构造器的prototype

console.log(p.__proto__ === p.constructor.prototype) // true

如果换一种方式设置原型，结果就有些不同了

function Person(name) {

this.name = name

}

// 重写原型

Person.prototype = {

getName: function() {}

}

var p = new Person('jack')

console.log(p.__proto__ === Person.prototype) // true

console.log(p.__proto__ === p.constructor.prototype) // false

这里直接重写了Person.prototype（注意：上一个示例是修改原型）。输出结果可以看出p.__proto__仍然指向的是Person.prototype，而不是p.constructor.prototype。

这也很好理解，给Person.prototype赋值的是一个对象直接量{getName: function(){}}，使用对象直接量方式定义的对象其构造器（constructor）指向的是根构造器Object，Object.prototype是一个空对象{}，{}自然与{getName: function(){}}不等。如下

var p = {}

console.log(Object.prototype) // 为一个空的对象{}

console.log(p.constructor === Object) // 对象直接量方式定义的对象其constructor为Object

console.log(p.constructor.prototype === Object.prototype) // 为true，不解释

1. function Yan(){}   var y=new Yan();

y.__proto__    Yan.prototype.__proto__.construct,hasOwnProperty,isPrototypeOf,valueOf,toString,toLocaleString

34.

a=[];     //a.length=0;

a[1000]=0;//a.length=1001;

35.数组分为稀松数组和非稀松数组，我们的length一般来定义非稀松数组，数组中不存在和没有是两回事。

绝大多数的js数组不是稀松数组，如果你确实碰到了稀松数组，你的代码很可能像对待非稀松数组一样对待他们，只不过它们包含一些undefines值。

ES5中用Object.defineProperty()让数组的length属性变为只读的.让一个数组不可变化。

数组的push,pop,unshift,shift,splice,

delete不改变length长度。

var adItemData=adContentSortArr.shift();//移除第一个，返回移除的对象，length变化

36.数组过滤掉不存在 undefined和null，过滤不存在的地址还是不理解

for(var i=0;i<a.length;i++){

if(!a[i]) continue;//跳过null,undefined和不存在的元素

if（!a[i]===undefined）continue;//跳过undefined+不存在的元素

if(!(i in a)) continue;//跳过不存在的元素

}

？37.for/in循环能够美剧继承者的属性名，如添加到Array.prototype中的方法，由于这个原因，在数组上不应该使用for/in循环，除非使用额外的检测方法来过滤不想要的属性，

for(var i in a){

if(!a.hasOwnProperty(i))continue;//跳过继承的属性。

}

38 if(String(Math.floor(Math.abs(Number(i))))!==i) continue;

1. 遍历数组的方法，for循环，for/in循环，还有forEach，不过ie好像不兼容forEach，跳出forEach的方法，return false,true;

js创建二维数组并且初始化：

var table=new Array(10);

for(var i=0;i<table.length;i++){table[i]=new Array(10);}

for(var row=0;row<table.length;row++){for(col=0;col<table[row].length;col++){

table[row][col]=row*col;

}}

40 join方法是split的缩写。reverse().sort().toLowerCase().concat()

41 var a=[1,2,3];

a.concat(4,[5,[6,7]]);//返回[1,2,3,4,5,[6,7]]

1. Slice()
2. Splice不同于concat,slice，它会改变调用的数组。

a.splice(2,0,'a','b');//splice在数组中插入

44.

7.9 ES5的9种方法 forEach()  map() filter() every()和some() reduce()和reduceRight() indexOf和lastIndexOf()

45.

ES5提供的判断数组的方法，Array.isArray()

46.打印155-164

47.

//定义并调用一个函数来确定当前脚本运行时是否为严格模式

var strict =(function(){return !this;})

var calculator={

operand1:1,

operand2:1,

add:function(){

this.result=this.operand1+this.operand2;

}

}

calculator.add();

calculator.result //2

48.一个简单的this用法

var box;

var flag=true;

function YY(){

_self=this;

var name='jinyun';

return function(){

_self.render();

}

}

YY.prototype.render=function(){

var self=this;

var i=0;

i++;

var ss=[];

//ss.split();

function ss2(){

self.bb++;

alert(self.bb);

}

if(flag){

flag=false;

this.bb=1;

}

var ss1;

ss2();

}

var y=new YY();

y();//2

y();//3

var y1=new YY();

y1();//Nan

y1();//Nan

49.匿名函数中this代表全局变量。而其他变量，首先找的是上一级的父函数的变量，如果没有才找全局的。匿名函数是一种特殊的闭包。

50.a_banner_circulate.js  和a_background_image.js

circulate传入的是对象，而image传入的是方法名

image的this没有变，而circule 对象，他的this对象改变了。

所以在Image中直接调backCall,而circule却需要call。

51 call方法的使用：

（1）在a_banner_circulate.js中setinit方法中

PluginAD.backCall.call(PluginAD, {'uid': uid,'eventType': 'onPuton'});

最主要的是backCall这个方法中用this这个关键字了。

如果不用关键字的话，不用call方法。

或者像a_background_image一样，不用创建对象，直接传方法名，这样就不会改变this了。

（2）

function Box(name,age){

this.name=name;

this.age=age;

this.run=function(){

return this.name+this.age+'运行中...';

}

}

var o=new Object();

Box.call(o,'Jack',200);//方法名是Box,this是o中的this.

o.run();

(3)

function Box(age){

this.name=['Lee','Jack','Hello'];

this.age=age;

}

Box.prototype.run=function(){

return this.name+this.age;

}

function Desk(age){

Box.call(this,age);

}

Desk.prototype=new Box();

var desk=new Desk(100);

alert(desk.run());//如果调用这种prototype的run方法，一定没有匿名函数中。

（4）

for(var i in man) {

if(Object.prototype.hasOwnProperty.call(man,i)) { //过滤

console.log(i,":",man[i]);

}

}

Object.prototype.hasOwnProperty 打印出来是：function hasOwnProperty(){[native code] }开始的function只是类型，不属于打印出来的。

52.

对于只调用一次的内容，可以这样写

if(typeof this.run!='function'){

Box.prototype.run=function(){

return this.name+this.age+'运行中...';

}

}

53.

对于函数的参数过多，我们记不住顺序，可以改为传一个参数。

一般情况下不这么写，太麻烦了

function easycopy(args){

arraycopy(args.from,

args.from_start || 0,

args.to,

args.to_start || 0,args.length);

}

var a=[1,2,3,4];

easycopy({from:a,to:b,length:4});

54. Js的四种调用

方法调用模式，函数调用模式，构造器调用模式，apply调用模式（本地js网页中）

55.

//大多数的变成语言都有精华部分和鸡肋部分，我发现如果只是用精华部分而避免使用鸡肋部分，我可以成为一名更好的程序员。

1. new Date().toLocaleTimeString()

57.

当方法的返回值是一个对象，这个对象还可以再调用它的方法，这种方法调用序列中（通常成为链或者级别）每次的调用结果都是另外一个表达式的组成部分。比如jquery，我们常常会这样写代码：

//找到所有的header，取得它们的id的映射，转换为数组并对他们进行排序

$(":header").map(function(){return this.id}).get().sort();

当方法并不需要返回值时，最好直接返回this.如果在设计的api中一直采用这种方式，使用api就可以进行链式调用风格的编程，在这种编程风格中，只要只定一次要调用的对象即可，余下的方法都可以基于此进行调用。

shape.setX(100).setY(100).setSize(50).setOutline("red").setFill("blue").draw();

不要将方法的链式调用和构造函数的链式调用混为一谈，。以后将构造函数的链式调用。

1. Js中set和get方法，setter和getter方法， es规定中新推出的，好像IE不支持，比如json，

Ie7不支持的时候我们就用，自己原生的js自己解析，比如主站的LETV.Json.

网上使用set和get地方就两种。

<script type="text/javascript">

//demo1

var obj = {

val:100,

get getval(){

return this.val;

},

set setval(x){

this.val = x;

}

}//get，set之后不写冒号的。

console.log(obj.getval);

obj.setval = 101;

console.log(obj.getval);

//demo2

var obj2 = {

val:200

}

obj2.__defineGetter__('name',function(){return this.val});

obj2.__defineSetter__('name',function(name){this.val = name;})

console.log(obj2.name)

obj2.name = 201;

console.log(obj2.name);

</script>

1. For用于遍历数组，而for in用于遍历对象，但是遍历对象考虑的比较多。

//---------for-in 用来遍历非数组对象

var man ={hands:2,legs:2,heads:1};

//为所有的对象添加clone方法，即给内置原型(object,Array,function)增加原型属性,该方法很强大，也很危险

if(typeof Object.prototype.clone ==="undefined"){

Object.prototype.clone = function(){};

}

//    for(var i in man){

if (man.hasOwnProperty(i)) { //filter,只输出man的私有属性

console.log(i,":",man[i]);

};

}

//输出结果为print hands:2,legs:2,heads:1

for(var i in man) {//不使用过滤

console.log(i,":",man[i]);

}

//输出结果为

//hands : 2 index.html:20

//legs : 2 index.html:20

//heads : 1 index.html:20

//clone : function (){}

for(var i in man) {

if(Object.prototype.hasOwnProperty.call(man,i)) { //过滤

console.log(i,":",man[i]);

}

}

//输出结果为print hands:2,legs:2,heads:1

60. 学习有规律的东西比没有规律的东西要有意义的多,但是很多伟人就是在无规律的东西中发现了规律， 所以我们不做伟人。