JavaScript[12.28]

1.Number

var num = 3.616;
num.toFixed(1); // 3.6
num.toFixed(0); // 4    显示几位小数
num.toExponential(1)  // 3.6e +0  显示指数表示法

num.toPrecision(1); // 4  综合以上，自动选择toFixed或者toExponential 。显示几位数字

2.String

concat() // 连接字符串，不会修改原字符
slice()  //
substr() //
substring() //   三个都是返回字符串，不会修改原字符串
indexOf()
lastIndexOf() //  查找字符
localeCompare() // 比较两个字符串

3.面向对象的程序设计

defineProperty() // 定义单个属性
defineProperties() // 定义多个属性

• 工厂模式：封装函数

function createPerson(name, age)
{
    var o = new Object();
    o.name = name;
    o.age = age;
    o.sayName = function()
    {
        alert(this.name);
    }
    return o;
}
var person1 = createPerson("Mali" , 29);
alert(typeof person1); // object

• 构造函数模式：可以知道实例出的对象的类型

function Person(name, age)
{
    this.name = name;
    this.age = age;
    this.sayName = function()
    {
        alert(this.name);
    }
}
var person1 = new Person("Mali" , 29);
alert(typeof person1); // true
alert(person1 instanceof Person); //true

• 原型模式：共享属性

function Person(name, age)   // 这样是为了方便看出共享，实际上是下一个代码块那种写
{
    Person.prototype.name = name;
    Person.prototype.age = age;
    Person.prototype.sayName = function()
    {
        alert(this.name);
    }
}
var person1 = new Person("wo",18);
var person2 = new Person("ni",29);
person1.sayName();  //ni
person2.sayName();  //ni
alert(person1.sayName == person2.sayName);// true

function Person()
{
    Person.prototype.name = "ni";
    Person.prototype.age = 18;
    Person.prototype.sayName = function()
    {
        alert(this.name);
    }
}
var person1 = new Person();
var person2 = new Person();
person1.name = "ta";
person1.sayName();  //ta  -- 来自实例
person2.sayName();  //ni  -- 来自原例
person1.hasOwnProperty("name");  // true  hasOwnProperty检测属性是否存在于实例中
person2.hasOwnProperty("name");  // false

// in 操作符
alert("name" in person1);  // true
alert("name" in person2);  // true  只要对象有这个属性就返回true，不管实例还是原型

• 原型的动态性： 创建对象实例之后，重写整个原型对象，会切断指针

function Person()
{
}
var friend = new Person();
Person.prototype = 
{
    name: "w",
    age: 18
}
alert(friend.name); // undefined
var person1 = new Person();
alert(person1.name); // w 

• 组合使用构造函数和原型模式

function Person(name, age)          // 构造函数
{
    this.name = name;
    this.age = age;
    this.friends = [1,2];
}
Person.prototype =              // 原型模式
{
    constructor : Person,
    sayName : function()
    {
        alert(this.name);
    }
}
var person1 = new Person("wo",18);
var person2 = new Person("ni",29);
person1.friends.push(3);
alert(person1.friends); // 1,2,3
alert(person2.friends);  //1,2
alert(person1.friends == person2.friends); // false
alert(person1.sayName == person1.sayName); // true

• 动态原型模式

function Person(name, age)
{
    this.name = name;
    this.age = age;

    //  方法
    if(typeof this.sayName != "function")
    {
        Person.prototype.sayName = function()
        {
            alert(this.name);
        };
    }
}

var person1 = new Person("ni",29);
var person2 = new Person("wo",29);
person1.sayName();
person2.sayName();
alert(person1.sayName == person2.sayName);   // true

4.函数表达式

• 特征

function person() //  非标准name属性
{
}
alert(person.name); // Person

sayHi();   // 函数**声明**提升
function sayHi()
{
    alert("Hi");
}

• 闭包

就是一个对象局部变量，被外面引用了，这就叫闭包（一个自己的浅显理解）
当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。)

function f()
{
    n = 77;
    function q()
    {
        alert(n);
    }
    return q();

}
f();  // 77

上一节代码中的q函数，就是闭包。
各种专业文献上的“闭包”（closure）定义非常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数。
由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成“定义在一个函数内部的函数”。
闭包的作用：一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。

function a()
{
    var i = 0;
    function b()
    {
        alert(++i);
    }
    return b;
}
var c = a();            // 局部的i 并没有被内存回收掉
c();//1
c();//2
c();//3
c();//4

var name = "The Window";
var object = 
{
    name:"My Object",
    getNameFunc:function()
    {
        //var that = this;  这里的this是指object，后面return this.name的话就是Myobject了
        return function()   // 这里会把func返回到全局上去，所以里面的this其实是指全局
        {
            return this.name;
        }
    }
}
alert(object.getNameFunc()());    // The Window  // 相当于直接alert(this.name)

• 私有作用域

(function()
{
    //这里是块级作用域
})();

function outPutNum(count)
{
    for(var i = 0; i < count; i++)
    {
        alert(i);  // 0.1.2.3.4
    }
    var i;  //重新声明变量
    alert(i); // 5
}
outPutNum(5);   // js会对同一个变量的后续声明视而不见，但可以初始化

function outPutNum(count)
{
    (function()
    {
        for(var i = 0; i < count; i++)
        {
            alert(i);  // 0.1.2.3.4
        }
    })();
    alert(i);  // undefined
}
outPutNum(5);

私有变量

function obj()
{
    var pri = 10;   // 私有变量和函数
    function a()
    {
    }

    this.rePir = function ()  //  特权函数
    {
        return pri;
    };
}
var obj = new obj();
alert(obj.pri);   // undefined
alert(obj.rePir());  //10

BOM

Browser Object Mode 浏览器对象模型
核心对象是window

可以通过设置为window的属性来删除

 var age = 19;
 window.color = "red";

 delete age;  // 19
 delete window.color;  // undefined

可以通过window查询变量是否声明

var value = oldvalue; // 报错因为oldvalue未声明
var value = window.oldvalue;  //  不报错，但undefined