首先声明js是脚本性语言,非面向对象语言。我这里所做的是尝试用js将面向对象中的各种特性模拟出来。
1
//定义类
2
3
var Test=function()
4
5

{
6
7
//定义私有变量
8
9
//这里的私有变量是指Test内部的变量
10
11
var priParam="Private";
12
13
//定义共有变量,外界及Test内部函数也可访问到
14
15
//这里的this指向Test
16
17
this.pubParam="Public";
18
19
20
21
//定义私有函数
22
23
var priFun=function()
24
25
{
26
27
//这里可以访问私有变量
28
29
alert(priParam);
30
31
//这里的var变量,其作用域为priFun内,外部无法访问
32
33
var theParam1="theParam1";
34
35
alert(theParam1);
36
37
//这里定义this指向Test,定义this. pubParam2,其实作用就是定义了Test. pubParam2
38
39
//但是却访问不到pubParam,借用面向对象的说法因为pubParam不是静态变量,必须Test实例化后才可以访问
40
41
this. pubParam2="pubParam2";
42
43
alert(pubParam2);
44
45
alert(this.pubParam2);
46
47
//这里会报错
48
49
//alert(this.pubParam);
50
}
51
52
53
54
//定义公有函数
55
56
this.pubFun=function()
57
58
{
59
60
//可以访问定义的私有函数
61
62
priFun();
63
64
//可以访问私有变量
65
66
alert(priParam);
67
68
//可以访问公有变量
69
70
alert(this.pubParam);
71
72
}
73
74
75
76
//定义初始化函数
77
78
this.Create=function()
79
80
{
81
82
priParam="Private Param";
83
84
this.pubParam="Public Param";
85
86
}
87
88
this.Create();
89
90
}
91
92
93
94
//定义并实例化一个类实例
95
96
//这里实际调用了Test.Create();
97
98
var test=new Test();
99
100
//Test中用this定义的变量,实例化后可以被访问,但是没办法访问priParam
101
102
alert(test.pubParam);
103
104
alert(test.priParam); //会提示为undefined
105
106
//可以调用pubFun();但无法调用priFun();
107
108
test.pubFun();
109
110
//test.priFun(); //这里会报错
111

2

3

4

5



6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25



26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58



59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80



81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

看了上面的代码后,有心人就会发现在变量定义中var 和 this 的作用非常不一样,我们现在是知其然,那么其所以然是如何的呢?
先吃饭,回头说