Question

回顾上节：

• 1、 javascript 介绍
• 2、基于对象的内存管理
• javascript 就是来操作这些对象
  • 通过逻辑组织对象之间的关系和行为
  • 如何操作这些对象？通过变量引用
• 3、变量

知识点 ：

1、 window 作用域

• 只要在 script 标签中定义的变量，默认就在 window 的作用域之下
• 默认就是 window 这个对象里面写代码

2、数据类型

如何判断 js 中的数据类型：

• typeof 、 instanceof 、 constructor 、 prototype 方法比较
• 如何判断 js 中的类型呢，先举几个例子：

var a = "iamstring."; var b = 222; var c= [1,2,3]; var d = new Date(); var e = function(){alert(111);}; var f = function(){this.name="22";};

最常见的判断方法 ： typeof

alert(typeof a) ------------> string alert(typeof b) ------------> number alert(typeof c) ------------> object alert(typeof d) ------------> object alert(typeof e) ------------> function alert(typeof f) ------------> function

• 其中 typeof 返回的类型都是字符串形式，需注意，例如：

alert(typeof a == "string") -------------> true alert(typeof a == String) ---------------> false

• 另外 typeof 可以判断 function 的类型；在判断除 Object 类型的对象时比较方便。

判断已知对象类型的方法 ： instanceof

alert(c instanceof Array) ---------------> true alert(d instanceof Date) alert(f instanceof Function) ------------> true alert(f instanceof function) ------------> false

• 注意 ： instanceof 后面一定要是对象类型，并且大小写不能错，该方法适合一些条件选择或分支。

根据对象的 constructor 判断 ： constructor

alert(c.constructor === Array) ----------> true alert(d.constructor === Date) -----------> true alert(e.constructor === Function) -------> true

• 注意 ： constructor 在类继承时会出错
• 例子：

function A(){}; function B(){}; A.prototype = new B(); //A 继承自 B var aObj = new A(); alert(aobj.constructor === B) -----------> true; alert(aobj.constructor === A) -----------> false;

• 而 instanceof 方法不会出现该问题，对象直接继承和间接继承的都会报 true ：

alert(aobj instanceof B) ----------------> true; alert(aobj instanceof B) ----------------> true;

• 言归正传，解决 construtor 的问题通常是让对象的 constructor 手动指向自己：

aobj.constructor = A; //将自己的类赋值给对象的 constructor 属性 alert(aobj.constructor === A) -----------> true; alert(aobj.constructor === B) -----------> false; //基类不会报 true 了;

通用但很繁琐的方法 ： prototype

alert(Object.prototype.toString.call(a) === ‘[object String]’) -------> true; alert(Object.prototype.toString.call(b) === ‘[object Number]’) -------> true; alert(Object.prototype.toString.call(c) === ‘[object Array]’) -------> true; alert(Object.prototype.toString.call(d) === ‘[object Date]’) -------> true; alert(Object.prototype.toString.call(e) === ‘[object Function]’) -------> true; alert(Object.prototype.toString.call(f) === ‘[object Function]’) -------> true;

• 大小写不能写错，比较麻烦，但胜在通用。
• 通常情况下用 typeof 判断就可以了，遇到预知 Object 类型的情况可以选用 instanceof 或 constructor 方法

Javascript 的数据类型有六种（ES6 新增了第七种 Symbol ）

• 数值（ number ）：整数和小数（比如 1 和 3.14）
• 字符串（ string ）：字符组成的文本（比如”Hello World”）
• 布尔值（ boolean ）：true（真）和 false（假）两个特定值
• undefined ：表示 未定义 或不存在，即此处目前没有任何值
• null ：表示空缺，即此处应该有一个值，但目前为空
• 对象（ object ）：各种值组成的集合
• 通常，我们将数值、字符串、布尔值称为原始类型（ primitive type ）的值，即它们是最基本的数据类型，不能再细分了。而将对象称为合成类型（ complex type ）的值，因为一个对象往往是多个原始类型的值的合成，可以看作是一个存放各种值的容器。至于 undefined 和 null ，一般将它们看成两个特殊值

内存中一共分为几种对象：

• 变量
• DOM 对象
• 常量
• 自定义对象

数据类型转换

转换函数

• toString() 转换为字符串，在 JavaScript 中所有数据类型都可以转换为 string 类型

var n1 = 12; var n2 = true; var a = [1, 2, 3]; var o = {}; function f(){} n1.toString(); //"12" n2.toString(); //"true" a.toString(); //"1,2,3" o.toString(); //"[object Object]" f.toString(); //"function f(){}"

• parseInt() 解析出一个 string 或者 number 类型的整数部分，如果没有可以转换的部分，则返回 NaN （ not a number ）
  

  var n1 = "12"; var n2 = "23hello"; var n3 = "hello"; parseInt(n1); //12 parseInt(n2); //23 parseInt(n3); //NaN

  • parseFloat() 解析出一个 string 的浮点数部分，如果没有可以转换的部分，则返回 NaN （ not a number ）

  var n1 = "1.2.3"; var n2 = "1.2hello" var n3 = "hello" parseFloat(n1); //1.2 parseFloat(n2); //1.2 parseFloat(n3); //NaN

强制类型转换

• Boolean(value) - 把给定的值转换成 Boolean 型

Boolean(123); //true Boolean(""); //false Boolean([]); //true Boolean({}); //true Boolean(null); //false Boolean(undefined); //false

• Number(value) -把给定的值转换成数字（可以是整数或浮点数）

Number("123"); //123 Number("123h"); //NaN Number(true); //1 Number(false); //0 Number(undefined); //NaN Number(null); //0 Number([]); //0 Number({}); //NaN

• String(value) - 把给定的值转换成字符串
  

  String(123); //"123" String([1,2]); //"1,2" String(undefined) //"undefined" String(null) //"null" String({}) //"[object Object]"

隐式转换

• 数字＋字符串：数字转换为字符串 console.log(12+"12") ; //1212
• 数字＋布尔值： true 转换为 1 ， false 转换为 0 console.log(12+true) ; //13
• 字符串＋布尔值：布尔值转换为 true 或 false console.log("hello"+true) ; // hellotrue
• 布尔值＋布尔值 console.log(true+true) ; //2

null 和 undefined

• undefined 表示一种未知状态，声明了但没有初始化的变量，变量的值时一个未知状态。访问不存在的属性或对象 window.xxx ）方法没有明确返回值时，返回值是一个 undefined. 当对未声明的变量应用 typeof 运算符时，显示为 undefined 。
• null 表示尚未存在的对象, null 是一个有特殊意义的值。可以为变量赋值为 null ，此时变量的值为“已知状态”(不是 undefined )，即 null 。（用来初始化变量，清除变量内容，释放内存）

undefined==null //结果为 true,但含义不同。 undefined===null //false,两者类型不一致，前者为“undefined”，后者为“object”

3、javascript 脚本执行顺序

• 第一步定义： 分为 var 定义 和函数定义 function
• 第二步执行： 其他所有
• 先从上往下定义完所有的后，再从上往下执行 除了 var function 定义外的 其他都是执行 如：赋值 函数调用
• 在栈里面找到的，就不去堆里面找，因为栈空间小，就近原则【总之：先在栈里面找，找不到再去堆里面找】在栈里面开辟，就能找到堆里面的地址 如： var b = function(){}

总结一下 == 运算的规则：(隐式转换)

• JS 中的值有两种类型：原始类型( Primitive )、对象类型( Object )。
• 原始类型包括： Undefined 、 Null 、 Boolean 、 Number 和 String 等五种。
• Undefined 类型和 Null 类型的都只有一个值，即 undefined 和 null ； Boolean 类型有两个值： true 和 false ； Number 类型的值有很多很多； String 类型的值理论上有无数个。
• 所有对象都有 valueOf() 和 toString() 方法，它们继承自 Object ，当然也可能被子类重写
• undefined == null ，结果是 true 。且它俩与所有其他值比较的结果都是 false 。
• String == Boolean ，需要两个操作数同时转为 Number 。
• String/Boolean == Number ，需要 String/Boolean 转为 Number 。
• Object == Primitive ，需要 Object 转为 Primitive (具体通过 valueOf 和 toString 方法)