JavaScript知识点整理（一）数据类型

 一、javascript数据类型分为 基本数据类型和引用数据类型：

1.基本数据类型包括：number，string，boolean，undefined，null，es6 引入 Symbol()。
2.引用数据类型包括：Object（Array，Date，RegExp，Function）。
3.两者的区别：
基本数据类型：自身不可拆分的；值在内存中占据固定大小的空间，被保存在栈内存中；从一个变量向另一个变量复制基本类型的值，会创建这个值的一个副本；不能给基本类型的值添加属性。
引用数据类型：可以拆分很多细小的东西；值是指那些可以由多个值构成的对象，不能直接访问操作对象的内存空间；可以为其添加属性和方法，也可以改变和删除其属性和方法。

javascript中类型检测方法：
● typeof
● instanceof
● Object.prototype.toString
● constructor
● duck type

1.typeof 运算符返回一个用来表示表达式(的)数据类型(的)字符串；可能(的)字符串有："number"、"string"、"boolean"、"object"、"function" 和 "undefined"。

<script>
console.log(typeof NaN) //返回值：number NaN特殊的非数字值
console.log(typeof Infinity) //返回值：number Infinity无穷大特殊值
console.log(typeof 123 ) //返回值：number 
console.log(typeof '123') //返回值：string
console.log(typeof(true)) //返回值：boolean
console.log(typeof(Date)) //返回值：function
console.log(typeof(s)) //返回值：undefined 因为s作为一个变量未被定义，所以这里的返回值是undefined
console.log(typeof(undefined)) //返回值：undefined
console.log(typeof(document)) //返回值：object document是DOM下的一个对象
console.log(typeof(null)) //返回值：object
</script>

2.instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。

object instanceof constructor

instanceof 运算符用来检测 constructor.prototype 是否存在于参数 object 的原型链上。

// 定义构造函数
function C(){} 
function D(){} 
var o = new C();
o instanceof C; // true，因为 Object.getPrototypeOf(o) === C.prototype
o instanceof D; // false，因为 D.prototype不在o的原型链上
o instanceof Object; // true,因为Object.prototype.isPrototypeOf(o)返回true
C.prototype instanceof Object // true,同上
C.prototype = {};
var o2 = new C();
o2 instanceof C; // true
o instanceof C; // false,C.prototype指向了一个空对象,这个空对象不在o的原型链上.
D.prototype = new C(); // 继承
var o3 = new D();
o3 instanceof D; // true
o3 instanceof C; // true

下面的代码使用了instanceof来证明：String和Date对象同时也属于Object类型。

var simpleStr = "This is a simple string"; 
var myString = new String();
var newStr = new String("String created with constructor");
var myDate = new Date();
var myObj = {};

simpleStr instanceof String; // returns false, 检查原型链会找到 undefined
myString instanceof String; // returns true
newStr instanceof String; // returns true
myString instanceof Object; // returns true

myObj instanceof Object; // returns true, despite an undefined prototype
({}) instanceof Object; // returns true, 同上

myString instanceof Date; // returns false

myDate instanceof Date; // returns true
myDate instanceof Object; // returns true
myDate instanceof String; // returns false

function Car(make, model, year) {
this.make = make;
this.model = model;
this.year = year;
}
var mycar = new Car("Honda", "Accord", 1998);
var a = mycar instanceof Car; // 返回 true
var b = mycar instanceof Object; // 返回 true

 

3.为了每个对象都能通过 Object.prototype.toString() 来检测，需要以 Function.prototype.call() 或者 Function.prototype.apply() 的形式来调用，传递要检查的对象作为第一个参数，称为thisArg。

var toString = Object.prototype.toString;

toString.call(new Date); // [object Date]
toString.call(new String); // [object String]
toString.call(Math); // [object Math]

//Since JavaScript 1.8.5
toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]

 4.constructor 属性返回对创建此对象的数组函数的引用，返回创建实例对象的 Object 构造函数的引用。注意，此属性的值是对函数本身的引用，而不是一个包含函数名称的字符串。该值为只读的原始类型，如1，true和"test"。

所有对象都会从它的原型上继承一个 constructor 属性：

var o = {};
o.constructor === Object; // true

var o = new Object;
o.constructor === Object; // true

var a = [];
a.constructor === Array; // true

var a = new Array;
a.constructor === Array // true

var n = new Number(3);
n.constructor === Number; // true

5.duck type鸭子类型:

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”我们并不关心对象是什么类型，到底是不是鸭子，只关心行为。
比如不知道一个对象是不是数组，可以判断它的length是不是数字，它是不是有join,push这样一些数组的方法。通过一些特征判断对象是否属于某些类型，这个有时候也常用。

 

二、javascript类型转换：自动类型转换（隐式转换）和强制类型转换

javascript是弱类型语言，变量的类型是根据其实际值来决定的，变量在运行期间参与运算时，在不同的运算环境中，也会进行相应的自动类型转换。

自动类型转换一般是根运行环境和操作符联系在一起的，是一种隐式转换，看似难以捉摸，其实是有一定规律性的，大体可以划分为：转换为字符串类型、转换为布尔类型、转换为数字类型。

1.转换为字符串类型：

当加号“+”作为二元操作符(binary)并且其中一个操作数为字符串类型时，另一个操作数将会被无条件转为字符串类型。

// 基础类型

var foo = 3 + '';            // "3"

var foo = true + '';         // "true"

var foo = undefined + '';    // "undefined"

var foo = null + '';         // "null"


// 复合类型

var foo = [1, 2, 3] + '';    // "1,2,3"

var foo = {} + '';           // "[object Object]"

对于基础类型，会直接转为与字面量相一致的字符串类型，而对于复合类型，会先试图调用对象的valueOf()方法，如果此方法返回值是引用类型，则接着再调用其toString()方法，最后将返回值转为字符串类型。

2.转换为布尔类型：

a.数字转布尔类型，0和NaN会自动转为false，其余数字都被认为是true

b.字符串转为布尔类型，空字符串会被转为false，其它字符串都会转为true

c.undefined和null转为布尔类型，都被认为是false

d.对象转为布尔类型，只要当前引用的对象不为空，都会被认为是true

// 0和NaN为false，其余均为true

if (0) {
    console.log('true');
} else {
    console.log('false');    // output: false
}

if (-0) {
    console.log('true');
} else {
    console.log('false');    // output: false
}

if (NaN) {
    console.log('true');
} else {
    console.log('false');    // output: false
}

// 其余数字均为true

if (-3) {
    console.log('true');    // output: true
} else {
    console.log('false');
}

if (3) {
    console.log('true');    // output: true
} else {
    console.log('false');
}
// 空字符串为false

if (' ') {
    console.log('true');
} else {
    console.log('false');    // output: false
}

// 其他字符串均为true

if ('0') {
    console.log('true');    // output: true
} else {
    console.log('false');
}

if ('false') {
    console.log('true');    // output: true
} else {
    console.log('false');
}

// undefined和null都为false

if (undefined) {
    console.log('true');
} else {
    console.log('false');    // output: false
}

if (null) {
    console.log('true');
} else {
    console.log('false');    // output: false
}
// 字面量对象
var o = {
    valueOf: function() {
        return false;
    },
    toString: function() {
        return false;
    }
};

if (o) {
    console.log('true');    // output: true
} else {
    console.log('false');
}

// 函数
var fn = function() {
    return false;
};

if (fn) {
    console.log('true');    // output: true
} else {
    console.log('false');
}

// 数组
var ary = [];

if (ary) {
    console.log('true');    // output: true
} else {
    console.log('false');
}

// 正则表达式
var regex = /./;

if (regex) {
    console.log('true');    // output: true
} else {
    console.log('false');
}

 

3.转换为数字类型：

a. 字符串类型转为数字，空字符串被转为0，非空字符串中，符合数字规则的会被转换为对应的数字，否则视为NaN

b. 布尔类型转为数字，true被转为1，false被转为0

c. null被转为0，undefined被转为NaN

d. 对象类型转为数字，valueOf()方法先试图被调用，如果调用返回的结果为基础类型，则再将其转为数字，如果返回结果不是基础类型，则会再试图调用toString()方法，最后试图将返回结果转为数字，如果这个返回结果是基础类型，则会得到一个数字或NaN，如果不是基础类型，则会抛出一个异常

var foo = +'';            // 0

var foo = +'3';           // 3

var foo = +'3px';         // NaN

var foo = +false;         // 0

var foo = +true;          // 1

var foo = +null;          // 0

var foo = +undefined;     // NaN