js学习笔记
typeof：一元运算符，返回字符串，表明运算符的类型（数字、字符串、布尔值的类型依次为number\string\boolean）
alert(typeof 'abc');
alert(typeof('abc'));
in：运算符，左边为字符串（或可以被转换成字符串），右边是一个对象或数组
var point = {x:1, y:2};
var has_x_coord = "x" in point; //true
var has_z_coord = "z" in point;//false
instanceof：左侧运算数是一个对象，右边运算数是对象类的名字(所有对象都是Object类的实例)
var d = new Date();
alert(d instanceof Date);//trie
alert(d instanceof Object);//true
alert(d instanceof Number);//false
var a = [1, 2, 3];
alert(a instanceof Array);//true
alert(a instanceof Object);//true
alert(a instanceof RegExp);//false
当+用于字符串和数字时，它并不一定具有结合性
alert(1+2+' blind mice');//3 blind mice
alert('blind mice '+1+2);//blind mice 12
delete运算符是一个一元运算符，他将删除运算符指定的属性、数组或变量，当删除属性、数组元素或变量不只是把它们的值设置为undefined。当删除属性后，该属性将不再存在
var o ={x:1, y:2};
delete o.x;
alert(typeof o.x);//undefined
delete o.x; //删除不存在的属性 returns false
delete o; //不能删除用var定义的变量 returns false
delete 1;//不能删除整数 returns true
x = 1;
delete x;
x; //runtime error , x is not defined
void运算符：一元运算符，可出现在任何类型操作数之前（它总是舍弃运算符的值，然后返回undefined）
<a href="javascript:void window.open();">open new window</a>
for in：语句
var o = {x:2, y:5, z:3};
for(prop_name in o){
document.write('name：'+ prop_name + "；value："+ o[prop_name]);
}
break：语句使运行的程序立即退出包含在最内层的循环或退出一个switch语句，break后可以跟一个标签名
outerloop:
for(var i =0; i<10; i++){
innerloop:
for(var j=0; j<10; j++){
if(j >3) break;
if(i == 2) break innerloop;
if(i ==4) break outerloop;
document.write("i = " + i + ", j = " + j + "<br />");
}
}
document.write("final i = " + i + " j = " + j);
函数定义在解析时发生，而不是在运行时发生
alert(f(4));//16
var f = 0;
function f(x){
return x*x;
}
alert(f);//0
arguments：实现给函数传递任意个参数，其属性callee可以引用当前正在执行的函数。
function max(){
var m = Number.NEGATIVE_INFINITY;
for(var i=0; i<arguments.length; i++){
if(arguments[i] > m) m = arguments[i];
}
return m;
}
var largest = max(1, 10, 100, 5, 563, 19530, 2);
function(x){
if(x==1) return 1;
return x*arguments.callee(x-1);
}
给函数传递不定顺序的参数
function easycopy(args){
arraycopy(args.from, args.from_start || 0, args.to, args.to_start || 0, args.length);
}
var a = [2,5,6,7];
var b = new Array(4);
easycopy({from : a, to : b, length : 4});
传入函数的实际参数个数：arguments.callee.length，函数定义的参数个数：arguments.length
function check(args){
var actual = args.length;
var expected = args.callee.length;
if(actual != expected) {
throw new Error("参数个数错误，期待：" + expected + "个参数，实际传递的参数个数："+actual);
}
}
function f(x, y, z){
check(arguments);
return x+y+z;
}
alert(f(1, 1053));//Error: 参数个数错误，期待：3个参数，实际传递的参数个数：2
Function()构造函数：期待任意数目的字符串参数，最后一个参数是函数的函数体
var f = new Function("x", "y", "return x+y;");
1. Function()函数所创建的函数并不使用词法作用域，相反，他们总是当作顶层的函数一样来编译
var y = 'global';
function constructFunction(){
var y = 'local';
return new Function('return y');
}
alert(constructFunction()());//global
2. Function()构造函数允许javascript代码倍动态创建并且在运行时编译，如eval()
Prototype：每个类都有一个带有一组属性的原型对象。当读取对象o的属性p的时候，javascript首先检查o是否有一个名为p的对象，如果没有，则检查o的原型对象是否有一个名为p的属性。
function Rectange(w, h){
this.width = w;
this.height = h;
}
Rectange.prototype.area = function(){ return this.width*this.height;};
var a= new Rectange(35, 64);
//alert(a.area());
alert(a.hasOwnProperty('width'));//true
alert(a.hasOwnProperty('area'));//false，area是a的继承属性
扩展内建类型：像String和Date这样的内建的类，也有原型对象，并且可以为它们赋值
String.prototype.endsWith = function(c){
return (c == this.charAt(this.length-1));
}
var message = 'hello world';
message.endsWith('d');//true
message.endsWith('h');//false
var 中文函数 = function (参数一, 参数二)
{
var 加我 = 4;
alert( 参数一 + (参数二 + 加我));
};
中文函数('汗哒哒。。。。', 22);
function f1(){
alert('function 1');
}
var f2 = function(){
alert('function 2');
}
f1与f2的区别是前者在语法解释期，后者在运行期。区别在于：如果调用该函数的代码在函数定义之后，则没有区别；如果调用该函数的代码在函数定义之前，则f1仍然可以调用，f2则会报错，提示f2未定义。
(function f(){
function f() { return 1;}
return f();
function f(){ return 2;}
})(); //2
