04 数据类型

• 原始类型：Undefined、Number、String、Boolean、Null
• 引用类型：Object以及Object的子类

var i;
alert(typeof i); // "undefined"

var k = 10;
alert(typeof k); // "number"

var f = "abc";
alert(typeof f); // "string"

var d = null;
alert(typeof d); // "object"  null属于Null类型,但是typeof运算符的结果是"object"

var flag = false;
alert(typeof flag); // "boolean"

var obj = new Object();
alert(typeof obj); // "object"

// sayHello是一个函数.
function sayHello(){

}
alert(typeof sayHello); // "function"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

注意区分

var d = null;
alert(typeof d); // "object"  null属于Null类型,但是typeof运算符的结果是"object"
1
2

• typeof：这个运算符可以在程序的运行阶段动态的获取变量的数据类型
• typeof运算符的运算结果是以下6个字符串之一：注意字符串都是全部小写。“undefined”、“number”、“string”、“boolean”、“object”、“function”

在JS当中比较字符串是否相等使用“==”完成。没有equals

typeof运算符的语法格式：
typeof 变量名

function sum(a, b){
   if(typeof a == "number" && typeof b == "number"){
	   return a + b;
   }
   alert(a + "," + b + "必须都为数字！");
}
1
2
3
4
5
6

4.1 undefined

当一个变量没有手动赋值，系统默认赋值undefined或者也可以给一个变量手动赋值undefined

var i; // undefined
var k = undefined; // undefined

alert(i == k); // true

var y = "undefined"; // "undefined"是一个字符串类型
alert(y == k); // false
1
2
3
4
5
6
7

4.2 Number

Number类型包括整数、小数、正数、负数、不是数字、无穷大等
-1 0 1 2 2.3 3.14 100 … NaN Infinity等都属于Number

// Infinity (当除数为0的时候，结果为无穷大)
alert(10 / 0);
1
2

4.2.1 NaN

表示Not a Number，不是一个数字，但属于Number类型。运算结果本来应该是一个数字,最后算完不是一个数字的时候,结果是NaN

var a = 100;
var b = "中国人";
alert(a / b); // 除号显然最后结果应该是一个数字,但是运算的过程中导致最后不是一个数字,那么最后的结果是NaN

var e = "abc";
var f = 10;
alert(e + f); // "abc10"，但此处的加号不是应该数字，而是字符串的拼接
1
2
3
4
5
6
7

4.2.2 关于Number的函数

isNaN()函数

• is Not a Number
• isNaN(数据) ,结果是true表示不是一个数字, 结果是false表示是一个数字

function sum(a, b){
   if(isNaN(a) || isNaN(b)){
	   alert("参与运算的必须是数字！");
	   return;
   }
   return a + b;
}
sum(100, "abc");
alert(sum(100, 200));
1
2
3
4
5
6
7
8
9

parseInt()或者parseFloat()，

• 可以将字符串自动转换成数字
• 并且取整数位

alert(parseInt("3.9999")); // 3
alert(parseInt(3.9999)); // 3

// parseFloat():可以将字符串自动转换成数字.
alert(parseFloat("3.14") + 1); // 4.14
alert(parseFloat("3.2") + 1); // 4.2
1
2
3
4
5
6

Math.ceil()

• 向上取整

// Math.ceil()
alert(Math.ceil("2.1")); // 3
1
2

4.3 Boolean

对应true和false

// 规律:“有"就转换成true,"没有"就转换成false.
alert(Boolean(1)); // true
alert(Boolean(0)); // false
alert(Boolean("")); // false
alert(Boolean("abc")); // true
alert(Boolean(null)); // false
alert(Boolean(NaN)); // false
alert(Boolean(undefined)); // false
alert(Boolean(Infinity)); // true
1
2
3
4
5
6
7
8
9

Boolean()，Boolean()函数的作用是将非布尔类型转换成布尔类型

语法格式：
Boolean(数据)

4.4 Null

null就一个值，区别要与typedf区分开来

// Null类型只有一个值,null
alert(typeof null); // "object"
1
2

4.5 String

String是一个内置的类，可以直接用，String的父类是Object

在JS当中字符串可以使用单引号，也可以使用双引号

//两种创建对象的方式，但创建的对象的类型有所不同
//第一种：
var s = "abc";
//第二种（使用JS内置的支持类String）： 
var s2 = new String("abc");

// 小string(属于原始类型String)
var x = "king";
alert(typeof x); // "string"

// 大String(属于Object类型)
var y = new String("abc");
alert(typeof y); // "object"
1
2
3
4
5
6
7
8
9
10
11
12
13

4.5.1 常用函数

alert("http://www.baidu.com".indexOf("http")); // 0
alert("http://www.baidu.com".indexOf("https")); // -1

// 判断一个字符串中是否包含某个子字符串？
alert("http://www.baidu.com".indexOf("https") >= 0 ? "包含" : "不包含"); // 不包含

// replace (注意：只替换了第一个)
alert("name=value%name=value%name=value".replace("%","&")); // name=value&name=value%name=value

// 继续调用replace方法,就会替换第“二”个.
// 想全部替换需要使用正则表达式.
alert("name=value%name=value%name=value".replace("%","&").replace("%", "&")); // name=value&name=value&name=value
1
2
3
4
5
6
7
8
9
10
11
12

4.5.2 substr和substring的区别

JS的下标从0开始

// substr(startIndex, length)
alert("abcdefxyz".substr(2,4)); //cdef，（下标，长度）
// substring(startIndex, endIndex) 注意:不包含endIndex
alert("abcdefxyz".substring(2,4)); //cd，（开始下标，结束下标）
1
2
3
4

4.6 Object

Object类型是所有类型的超类，自定义的任何类型，默认继承Object

JS定义类的语法：

第一种方式：
    function 类名(形参){

    }
第二种方式：
    类名 = function(形参){

    }
1
2
3
4
5
6
7
8

创建对象的语法：

new 构造方法名(实参); // 构造方法名和类名一致。
1

js的类定义以及探讨

// 定义一个学生类
function Student(){
   alert("Student.....");
}

// 当做普通函数调用
Student();

// 当做类来创建对象
var stu = new Student();
alert(stu); // [object Object]
1
2
3
4
5
6
7
8
9
10
11

• JS中的类的定义,同时又是一个构造函数的定义
• 在JS中类的定义和构造函数的定义是放在一起来完成的
• js的函数形参调用可以有一个或者多个都可以执行，因为是弱类型

function User(a, b, c){ // a b c是形参,属于局部变量.
   // 声明属性 (this表示当前对象)
   // User类中有三个属性:sno/sname/sage
   this.sno = a;
   this.sname = b;
   this.sage = c;
}

// 创建对象
var u1 = new User(111, "zhangsan", 30);
// 访问对象的属性
alert(u1.sno);
alert(u1.sname);
alert(u1.sage);

var u2 = new User(222, "jackson", 55);
alert(u2.sno);
alert(u2.sname);
alert(u2.sage);

// 访问一个对象的属性,还可以使用这种语法
alert(u2["sno"]);
alert(u2["sname"]);
alert(u2["sage"]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

也可以换种方式定义类

Product = function(pno,pname,price){
   // 属性
   this.pno = pno;
   this.pname = pname;
   this.price = price;
   // 函数
   this.getPrice = function(){
	   return this.price;
   }
}

var xigua = new Product(111, "西瓜", 4.0);
var pri = xigua.getPrice();
alert(pri); // 4.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14

属性有：prototype属性（常用的，主要是这个）：作用是给类动态的扩展属性和函数。

// 可以通过prototype这个属性来给类动态扩展属性以及函数
Product.prototype.getPname = function(){
   return this.pname;
}

// 调用后期扩展的getPname()函数
var pname = xigua.getPname();
alert(pname)

// 给String扩展一个函数
String.prototype.suiyi = function(){
   alert("这是给String类型扩展的一个函数，叫做suiyi");
}

"abc".suiyi();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.7 null、NaN和undefined

• 数据类型不一致
• ==(等同运算符：只判断值是否相等)
  ===(全等运算符：既判断值是否相等，又判断数据类型是否相等)
• null和undefined可以等同

// null NaN undefined 数据类型不一致.
alert(typeof null); // "object"
alert(typeof NaN); // "number"
alert(typeof undefined); // "undefined"

// null和undefined可以等同.
alert(null == NaN); // false
alert(null == undefined); // true
alert(undefined == NaN); // false

// 在JS当中有两个比较特殊的运算符
alert(null === NaN); // false
alert(null === undefined); // false
alert(undefined === NaN); // false
1
2
3
4
5
6
7
8
9
10
11
12
13
14