javascript的基础知识及面向对象和原型属性

var num = 123;
console.log(typeof num); // 

作用：判断指定属性是否存在于指定的对象中。

如果指定的属性存在于指定的对象中，则 in 运算符会返回 true。

语法：
属性 in 对象

返回值：true 或者 false

示例：
var obj = {
    age: 18
};
var hasAge = "age" in obj;
console.log(hasAge); // 

1 in
2 浏览器能力检测

值类型：变量中存储的是数值本身
引用类型：变量中存储的是数据的引用（地址）

对象中的属性可以是值类型也可以是引用类型

var o = new Object();
function foo(obj) {
    obj.name = "腐女";
    obj = new Object();
    obj.name = "屌丝";
}
foo(o);
console.log(o.name); // 

||
如果第一个为真 就返回第一个表达式, 如果为假 则返回第二个表达式
&&
如果第一个为假 就返回第一个表达式, 如果为真则返回第二个表达式

function fn(num) {
    // 如果传入num，就打印num的值
    // 如果没有传入 就打印 没有参数
}

作用：删除一个对象的属性。
语法：delete 属性名
返回值： true 或 false

用法:
1 删除数组中的元素
2 删除对象的属性或方法
3 删除没有用 var 声明 变量

// 语法:
try {
    // 可能出现错误的代码
} catch ( e ) {
    // 出现错误会执行这里的代码
} finally { // 可选
    // 无论是否出现异常, 最后执行
}

// 手动抛出异常
throw new Error("别瞎搞");
throw "这都行？？？";

// 函数声明
function foo() {}

// 函数表达式
var foo = function foo() {};

// 不推荐这么做！！
if(true) {
    function f() {
        console.log(true);
    }
}

f();

表达式：(有值)
表达式（expression）是JavaScript中的一个短语，JavaScript解释器会将其计算出一个值。
表达式可以是：数据 或者 数据和运算符的组合
例如：1、"abc"、true、1 + 2、i++、a === b ? a : b 、a = 1

语句：(带分号)
语句是JavaScript的句子或命令，以分号结束。
var a = 1;

// jQuery
$("body").append("<p>jQuery创建节点就是如此潇洒</p>");

// js
var p = document.createElement("p");
var txt = document.createTextNode("creat E..，creat T..真麻烦");
p.appendChild(txt);

document.body.appendChild(p);

面向过程：所有的细节、步骤、过程，要一步一步亲历亲为（执行者）
面向对象：找到能完成这个事情的对象，让它帮你完成就行（调度者）

生活中的例子：
做饭（叫外卖）
开公司

// 通过标签名获取元素
function tag(tagStr) {
    return document.getElementsByTagName(tagStr);
}

var divs = tag("div");
for(var i = 0; i < divs.length; i++) {
    divs[i].style.border = "1px dotted red";
}

var ps = tag("p");
for(var i = 0; i < ps.length; i++) {
    ps[i].style.border = "1px dotted red";
}

// 使用对象
var itcast = {
    id: function(idStr) {
        return document.getElementById(idStr);
    },
    tag: function(tagStr) {
        return document.getElementsByTagName(tagStr);
    }
};

var itcast = {
    // 元素获取模块
    getElem: {
        tag: function() {},
        id: function() {}
    },
    // 样式模块
    css: {
        addStyle: function() {},
        removeStyle: function() {},
        hasStyle: function() {}
    }
};

getElementById getElementsByTagName getElementsByClassName

appendChild insertBefore removeChild replaceChild cloneNode
createElement createTextNode（创建文本节点）

getAttribute setAttribute removeAttribute

className innerHTML innerText/textContent value
children 

在DOM中所有的东西全部都是对象，所以，使用DOM非常简单方便

jQuery中所有的东西也都是对象

// json 的表示法， 对象的直接量（字面量）
var p = {
    name: "jim",
    age: 19,
    sex: "男",
    sayHello: function() {
        alert("你好，哈哈哈哈");
    }
};

p.sayHello();
// 此时可以把对象称为：关联数组
p["sayHello"]();

例如：
描述一个商品 Goods(name, price, img, count, pDate)

假如有 100 件

var Person = function() {
    this.name = "jim";
    this.age = 19;
    this.gender = "男";

    this.sayHello = function() {
        alert("你好，哈哈哈哈");
    };
};
// 创建对象（构造函数Person的对象）
var p = new Person();
// 访问对象的 属性
console.log(p.name);
// 访问对象的 方法
p.sayHello();

写一个学生 Student, 要求有 姓名性别年龄和课程分数(语文, 数学, 英语)和说话的方法

// 不使用函数
var area = 10 * 10 / 2;

// 封装成函数
function getArea() {
    var area = 10 * 10 / 2;
    return area;
}

// 改进
function getArea(bottom, height) {
    return bottom * height / 2;
}
getArea(10, 20);

形参（形式参数），即函数定义时的参数，只起到占位的作用，等到函数被调用的时候，会被传入的具体值代替。【联想数学公式】 s = d * h / 2;

实参（实际参数），即函数被调用时的参数，是一个具体的值或者表达式（1、"老司机"、true、[2, 2]、{ name: "two"} 等）

构造函数中的属性和方法，会在调用的时候被处理，即会消耗内存。

new 出来的对象，都是一个单独副本
new 一个对象就占用一份内存，new 多少对象就占用多少份内存。

但是对于构造函数中的方法来说，每个对象的方法都是相同的（或者说应该是被共享的）

function Person() {}
// prototype 即 原型
Person.prototype.legs = 2;

var p = new Person();
console.log(p.legs);

在访问对象的某一个属性 (方法)的时候：

1 首先会在当前对象中查找有没有该属性
2 如果当前对象没有, 就会在构造方法的定义规则中查找(当前对象)
3 如果没有, 就会到与对象联系起来的 构造函数的 prototype 属性的值中找

// 对象会到 与它联系的 prototype 中找数据  
// 可以考虑将共享的数据, 放到 里面
function Person(name) {
    this.name = name;
}
Person.prototype.sayHello = function() {
    alert(this.name);
};

var p = new Person();
p.sayHello();

获取操作：
遵循属性查找原则

赋值操作（只与当前对象有关）：
只会操作对象本身，如果对象中没有该属性则创建该属性，并赋值；如果对象中有，则修改

对象中有一个属性 叫 __proto__  
对象的 __proto__ 与创建它的构造函数的 prototype 是一个东西

function F() {}
var o = new F();

console.log(o.__proto__ === F.prototype);

F.prototype  原型属性
f.__proto__  原型对象

F.prototype 是 构造函数F的 原型属性
f.__proto__ 是 对象f的     原型对象