javascript摘录

if (typeof(obj.property) != "undefined") {}

if (obj instanceof PredefinedObj) {}

语言的基础一定要打扎实!如:
各原始类型占用内存存储空间
各原始类型如何转化 
原始类型和对象类型存储的区别(没弄清楚咋用递归呢)

http://www.blogjava.net/zkjbeyond/archive/2006/05/19/47025.html
javascrpt语言预定义的属性不能用for in 得到。如toString


   ECMAScript认可两类对象，“Native Object”和“Host Object”,Host Object属于Native Object的子类，在(ECMA 262 3rd Ed Section 4.3)中叫"Built-in Object"（内置对象）。Native objects属于语言级别，host objects被环境提供（浏览器等），例如，document objects,DOM nodes等。

    关于对象属性的存取，数据类型，原型对象prototype的使用，我这就不译了。

http://www.blogjava.net/zkjbeyond/archive/2006/04/17/41531.html

对象：
http://www.iteye.com/topic/19748?page=3

变量：
http://zkj-beyond.iteye.com/blog/19506

prototype:
http://www.iteye.com/topic/53537

容易忽略的地方：
http://bbs.51js.com/thread-67208-1-1.html

prototype的继承讨论：
http://bbs.51js.com/viewthread.php?tid=67057&extra=&page=1



prototype 实现继承之注意点：
http://www.ajaxwing.com/index.php?id=2


prototype 实现继承之方式一：
http://kevlindev.com/tutorials/javascript/inheritance/index.htm

prototype 实现继承之方式二：

ext的继承片段
(和一的方式差不多，但是做了一些改进)

extend : function(){
            // inline overrides
            var io = function(o){
                for(var m in o){
                    this[m] = o[m];
                }
            };
            return function(sc, sp, overrides){
                var F = function(){}, scp, spp = sp.prototype;
                F.prototype = spp;
                scp = sc.prototype = new F();
                scp.constructor=sc;
                sc.superclass=spp;
                if(spp.constructor == Object.prototype.constructor){
                    spp.constructor=sp;
                }
                sc.override = function(o){
                    Ext.override(sc, o);
                };
                scp.override = io;
                Ext.override(sc, overrides);
                return sc;
            };
        }(),

        override : function(origclass, overrides){
            if(overrides){
                var p = origclass.prototype;
                for(var method in overrides){
                    p[method] = overrides[method];
                }
            }
        },

oop要实现的问题：

实例属性：
私有 在初始化方法中用var来声明就ok了。
公共 在初始化方法中使用this来声明就ok了。
为了效率，可以在prototype中实现。


静态属性：
公共 默认情况下就是公共的。
私有 可以一个私有属性绑定一个。

目前prototype实现的继承在上面四点上存在的问题是：
目前ext实现的继承在上面四点是存在的问题是：


使用prototype来实现只读属性（了解一下，好像没什么用，没必要搞这些技巧把问题搞复杂）

<script>
function Polygan()
{
	var m_points = [];

	m_points = Array.apply(m_points, arguments);

	function GETTER(){};
	GETTER.prototype = m_points[0];
	this.firstPoint = new GETTER();

	this.length = {
		valueOf : function(){return m_points.length},
		toString : function(){return m_points.length}
	}

	this.add = function(){
		m_points.push.apply(m_points, arguments);
	}

	this.getPoint = function(idx)
	{
		return m_points[idx];
	}
}
var p = new Polygan({x:1, y:2},{x:2, y:4},{x:2, y:6});
alert(p.length);
alert(p.firstPoint.x);
alert(p.firstPoint.y);
p.firstPoint.x = 100; //不小心写了它的值
alert(p.getPoint(0).x);  //不会影响到实际的私有成员
delete p.firstPoint.x; //恢复
alert(p.firstPoint.x);
</script>

另类prototype的使用：

<script>
function classA()
{
	this.a = 100;
	this.b = 200;
	this.c = 300;

	this.reset = function()
	{
		for(var each in this)
		{
			delete this[each];
		}
	}
}
classA.prototype = new classA();

var a = new classA();
alert(a.a);
a.a *= 2;
a.b *= 2;
a.c *= 2;
alert(a.a);
alert(a.b);
alert(a.c);
a.reset();
alert(a.a);
alert(a.b);
alert(a.c);
</script>

prototype继承中class type prototype三者之间的关系，js中prototype只能在元类级别修改，一旦function生成了对象，改对象对prototype是没有修改的权利的，当然元类级别还能做修改，且能立即反映到生成的对象上。


js的变量定义和函数定义：
http://www.coolcode.cn/andot/javascript-oop-inheritance-polymorphism/255


iframe  当用户点击后退按钮时会觉得奇怪，怎么没后退啦
        跨域时要注意sessionid urlencode
xmlhttp 跨域时麻烦

全面理解javascript的caller,callee,call,apply


call,apply改变函数执行的scope，第一个参数相同，其余参数不同


callee 属性的初始值就是正被执行的 Function 对象。

callee 属性是 arguments 对象的一个成员，它表示对函数对象本身的引用，这有利于匿名
函数的递归或者保证函数的封装性，例如下边示例的递归计算1到n的自然数之和。而该属性
仅当相关函数正在执行时才可用。还有需要注意的是callee拥有length属性，这个属性有时候
用于验证还是比较好的。arguments.length是实参长度，arguments.callee.length是
形参长度，由此可以判断调用时形参长度是否和实参长度一致。


String.substr(N1,N2) 这个就是我们常用的从指定的位置(N1)截取指定长度(N2)的字符串;
String.substring(N1,N2) 这个就是我们常用的从指定的位置(N1)到指定的位置(N2)的字符串;