JavaScript-Patterns/runfunction.js at master · yinuoba/JavaScript-Patterns · GitHub

1
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
;(function() {
	/**
	 * 先声明一个函数。
	 * 注意执行的时候不能直接花括号后面加括号执行，因为解析器会把它当作一个函数声明。
	 * @param  {String} msg
	 * @return {[type]}
	 */
	function common(msg) {
		console.info(msg + "先声明函数，再调用！")
	}

	/**
	 * 常用执行方式。先声明函数，再用一条语句，并在方法名后加()
	 */
	common("常用调用方式，");

	/**
	 * 通过call调用，普通函数跟构造函数，均可以通过call调用
	 */
	common.call(null, "常用调用方式，");

	/**
	 * 通过apply调用，普通函数跟构造函数，均可以通过apply调用
	 */
	common.apply(null, ["常用调用方式，"]);


	/**
	 * 将函数转化为表达式
	 * 将函数转化为表达式的方式有很多，括弧()和JavaScript的&&，异或，逗号，+，-，~，!，new，void等操作符可在函数表达式和函数声明之间消除歧义
	 */

	/**
	 * 函数外加一个括号，将其转化为函数表达式
	 * @param  {String} msg 参数
	 * @return {[type]}   [description]
	 */
	 (function(msg) {
	 	console.info(msg + "先声明函数，再调用！")
	 })("常用调用方式，");

	/**
	 * 函数后紧接着一个括号，并在外层再套一个括号，将其转化为函数表达式并执行
	 */
	(function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，"));

	/**
	 * 命名函数表达式，可直接在后面加括号并传入参数（如果有参数）
	 * @param  {[String]} msg [description]
	 * @return {[type]}     [description]
	 */
	var common1 = function common(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 匿名函数表达式，可直接在后面加括号并传入参数（如果有参数）
	 * @param  {[String]} msg [description]
	 * @return {[type]}     [description]
	 */
	var commonn2 = function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 通过void操作符，将其转化为表达式，后接一括号，让其执行
	 * @param  {[String]} msg [description]
	 * @return {[type]}     [description]
	 */
	void function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 通过new操作符，将其转化为表达式，后接一括号，让其执行
	 * @param  {String} msg [description]
	 * @return {[type]}     [description]
	 */
	new function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 通过&&操作符，将其转化为表达式，后接一括号，让其执行
	 * @param  {String} msg [description]
	 * @return {[type]}     [description]
	 */
	true && function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 通过逗号操作符，将其转化为表达式，后接一括号，让其执行
	 * 前面加一分号是为了将其与前面语句区分开来
	 * @param  {String} msg [description]
	 * @return {[type]}     [description]
	 */
	; true, function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 通过加号操作符，将其转化为表达式，后接一括号，让其执行
	 * 前面加一分号是为了将其与前面语句区分开来
	 * @param  {String} msg [description]
	 * @return {[type]}     [description]
	 */
	; +function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 通过减号操作符，将其转化为表达式，后接一括号，让其执行
	 * 前面加一分号是为了将其与前面语句区分开来
	 * @param  {String} msg [description]
	 * @return {[type]}     [description]
	 */
	; -function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 通过~操作符，将其转化为表达式，后接一括号，让其执行
	 * 前面加一分号是为了将其与前面语句区分开来
	 * @param  {String} msg [description]
	 * @return {[type]}     [description]
	 */
	; ~function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

	/**
	 * 通过!操作符，将其转化为表达式，后接一括号，让其执行。如果返回的是布尔类型，不要用这种方式执行,
	 * 前面加一分号是为了将其与前面语句区分开来
	 * @param  {String} msg [description]
	 * @return {[type]}     [description]
	 */
	; !function(msg) {
		console.info(msg + "先声明函数，再调用！")
	} ("常用调用方式，");

}())