js权威指南读书笔记

1、遍历对象属性
var a = {};
a.x = "x";
a.xx = function(){

}
for(var name in a ){
console.log(name); //x xx
}


2、判断对象类型
var a = new Date;
console.log(typeof a );//object
console.log(a.constructor == Date);//true
console.log(a instanceof Date);//true 等效于上一句

3、如果局部变量不加var 则会成为全局变量

var a = 6;
function test(){
a = 5;
console.log(a); //5
}
console.log(a); //6
test();
console.log(a); //5

4、函数没有块级作用域
无论在函数中那里声明，整个函数中都有它的定义。
---》代码1
var a = 6;
function test(){
console.log(a)// 6
}
test();

---》代码2
var a = 6;
function test(){
console.log(a)// undefined
var a=5;
}
test();

可以看出声明了变量a，则a是在整个test函数起作用的。

所有把函数中的变量放到函数的头部是个很好的习惯。

代码2等同于代码3

---》代码3
var a = 6;
function test(){
var a；
console.log(a)// undefined
a=5;
}
test();

5、js 变量和对象的属性其实是没有根本区别的。全局变量是全局对象的属性。

=========
1、number 类型
js 不区分整型还是浮点类型；
2、string 类型
js没有char类型。
3、number转string

var a = 2.63;
var b = a+""; //方法一
var c = a.toString();//方法二
3、小数转string并保留小数
var a = 2.62；
var d = a.toFixed(1); //2.6
4、字符串转数字
var a = "23.5";
var b = a-0;//方式一 不能+0 那样是字符串连接
var c = parseInt(a);//23 方式二
var d = parseFloat(a); //23.5

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

1、定义函数
function test1(){
console.log("test1----");
}

var test2 = function(){
console.log("test2----");
}

test1();
test2();

2、arguments

function test1(){
console.log(arguments); //[5, 8, 9]
}

test1(5,8,9);

3、函数作为对象方法的函数

function test1(){
console.log(arguments); //[5, 8, 9]
}

var test2 = function(){
console.log("test2----");
}
var obj = {};
obj.test1 = test1;
obj.test2 = test2;

obj.test2(); //test2---
obj.test1(56);//[56]

4、this
---》

function test1(){
console.log(this.a+ this.b); //3
}


var obj = {a:1,b:2};
obj.test1 = test1;
obj.test1();

---》
var a =4;
var b = 7;

var obj = {a:1,
b:2,
test2:function(){
console.log(a+ b); //11
}};
obj.test2();
---》
var a =4;
var b = 7;

var obj = {a:1,
b:2,
test2:function(){
console.log(this.a+this.b); //3
}};
obj.test2();

5、function对象的length属性是指函数的实际形参个数；
arguments 是指实际传递的实参个数；

function test1(e,e){
console.log(test1.length);//2
console.log(arguments.length);//3
}

test1(1,2,4);

6、apply、call
指定对象调用方法，可以共享定义的方法。

function test1(e,e1){
console.log(e+e1);
}

var obj1 = {};
var obj2 = {};
test1.apply(obj1,[1,2]);//3
test1.call(obj2,5,6);//11

7、作为命名空间的调用函数

为避免多个声明变量冲突 可以把变量定义到函数中。

function init(){
var a =0;
var b =1;
}

init();//别忘回调

或者


(function(){
var a =0;
var b =1;
})()

============
1、js构造函数及类定义
function Human(age){
this.age = age;
this.getAge = function(){
console.log(age);
}
}

var h = new Human(56);
console.log(h.getAge());

2、效率高的js类定义（继承属性）

function Human(age){
this.age = age;
// this.getAge = function(){
// console.log(this.age);
// }
}
Human.prototype.getAge = function(){
console.log(this.age);
}

var h = new Human(56);
console.log(h.getAge());

3、判断 属性是继承的属性还是常规的属性
function Human(age){
this.age = age;
}
Human.prototype.getAge = function(){
console.log(this.age);
}

var h = new Human(56);
console.log(h.getAge());
console.log(h.hasOwnProperty("age"))//true
console.log(h.hasOwnProperty("getAge"))//false
4、扩展内建类型（最好不要这么写，会造成混乱，可以扩展自己的方法）
String.prototype.showA = function(){
console.log("---")
}
var a = "ss"
a.showA();//---
console.log(typeof(String.prototype.showA))//function

5、js采用的是原型的继承而不是类的继承
6、实例属性、实例方法、类属性、类方法

// 定义类构造函数
function Circle(radius) {
//定义实例属性
this.r = radius;
}

//定义类属性
Circle.PI = 3.14159;

// 定义实例方法
Circle.prototype.area = function() { return Circle.PI * this.r * this.r; }

// 定义类方法
Circle.max = function(a,b) {
if (a.r > b.r) return a;
else return b;
}

// 创建类实例
var c = new Circle(1.0); // Create an instance of the Circle class
c.r = 2.2; // Set the r instance property
var a = c.area(); // Invoke the area() instance method
var x = Math.exp(Circle.PI); // Use the PI class property in our own computation
var d = new Circle(1.2); // Create another Circle instance
var bigger = Circle.max(c,d); // Use the max() class method

7、通用对象模型 也就是一般需要定义的几个方法

toString（）转换成字符串表达形式；
valueOf（） 把对象转换成特定数据形式；
equal（）；比较方法；

8、继承
//父类
function Animal(name){
this.name = name;
this.count = 0;
}

Animal.prototype.getName = function(){
console.log(this.name);
}

var a = new Animal("dog");
a.getName(); //dog

//子类
function Man(sex,name){
Animal.call(this,name);
this.sex = sex;
}

Man.prototype = new Animal();//**通过原型继承
Man.prototype.constructor = Man;//**显示设置原型constructor属性

var m = new Man('boy',"jim");
m.getName();//jim
console.log(m.count)//0

9、判断对象类型

var d = new Date();
console.log(typeof d);//object
console.log(d instanceof Object);//true
console.log(d instanceof Date);//true
console.log(d.constructor == Date)//true
console.log(d.constructor == Object)//false

typeof主要用于区分对象和基本数据类型；
区分对象是不是某个类的实例 可以用instanceof

==========
1、尽量不要定义全局变量 ，而应该定义到一个对象中统一管理,用对象模拟实现命名空间
class={};
class.a="aaa"; //定义一个属性
//定义一个方法
class.showA = function(){
console.log(this.a);
}

class.showA(); //aaa

2、加入还有个模块用了class 难免会覆盖上述的calss命名空间
可以分模块定义class
如
var moduleA = {};
moduleA.class = {};
moduleA.class.a="aaa"; //定义一个属性
//定义一个方法
moduleA.class.showA = function(){
console.log(this.a);
}
/*或者
moduleA.class = {
a:"aaa",
showA : function(){
console.log(this.a);
}
}
*/

同样可以定义模块B的class
4、//检查模块可用性
var com;//声明全局变量
if(!com || !com.sf){
throw new Error("com.sf 模块不存在！");
}
5、extjs 的命名空间
//ext的命名空间
Ext.namespace("com.sf");
//检查模块可用性
if(!com || !com.sf){
throw new Error("com.sf 模块不存在！");
}else{
console.log("存在");//存在
}

6、闭包创建私有空间，把公有方法导入到命名空间中
//ext的命名空间
Ext.namespace("com.sf");//等同于 var com = {}； com.sf = {};
//检查模块可用性
if(!com || !com.sf){
throw new Error("com.sf 模块不存在！");
}else{
console.log("存在");//存在
}

//闭包创建私有空间，把公有方法导入到命名空间中
(function(){
var a = "test";
function showName (){
console.log(a);
}
var temp = com.sf;
temp.showName = showName; //导入到com.sf命名空间中
})();

com.sf.showName();//test
console.log(com.sf.a);//undefined 无法获取私有变量

7、划分模块与ext.namespace 影响

Ext.namespace("xxx.i18n");
xxx.i18n.b = "bbb";

console.log(xxx.i18n.a);//aa


if(!xxx)
var xxx = {};

if(!xxx.i18n)
xxx.i18n = {};

//等同于 Ext.namespace("xxx.i18n");

xxx.i18n.a = "aaa";
console.log(xxx.i18n.a);//aaa
console.log(xxx.i18n.b);//bbb
==========
1、客户端javscript中 全局对象时window
var a="nihao";
window.b = "nihao!";//等同于上一句
console.log(window.a);
console.log(a);
console.log(window.b);//nihao!
console.log(b);//nihao!