我最近开始保持别人的JavaScript代码,我正在修复错误,添加功能,也试图更新代码并使其更加一致。
以前的开发人员使用了两种方式来宣布功能,我无法解决是否有原因。
兩種方式是:
var functionOne = function() {
// Some code
};
function functionTwo() {
// Some code
}
使用这两种不同的方法的原因是什么?每个方法的优点和缺点是什么?可以用一种方法做些什么,不能用另一种方法做些什么?
当前回答
function x() {
console.log('x');
}
x(); // Works even though it's above the declaration
function x() {
console.log('x');
}
if (someCondition) {
function foo() { // <===== HERE THERE
} // <===== BE DRAGONS
}
"use strict";
if (someCondition) {
foo(); // Works just fine
function foo() {
}
}
console.log(typeof foo); // "undefined" (`foo` is not in scope here
// because it's not in the same block)
var y = function () {
console.log('y');
};
名称函数表达式
var z = function w() {
console.log('zw')
};
var z = function w() {
console.log(typeof w); // "function"
};
console.log(typeof w); // "undefined"
配件功能启动器(ES5+)
var obj = {
value: 0,
get f() {
return this.value;
},
set f(v) {
this.value = v;
}
};
console.log(obj.f); // 0
console.log(typeof obj.f); // "number"
您还可以使用 Object.defineProperty、Object.defineProperties 和 Object.create 更不熟悉的第二个论点创建附件功能。
Arrow 功能表达式(ES2015+)
var a = [1, 2, 3];
var b = a.map(n => n * 2);
console.log(b.join(", ")); // 2, 4, 6
看到 n => n * 2 隐藏在地图() 呼叫? 这是一个函数。
关于箭头功能的一些事情:
他們沒有自己的這一點. 相反,他們關閉了他們所定義的背景的這一點. (他們也關閉了論點,在相關的情況下,超級.) 這意味著他們內在的這一點是相同的這一點,在那裡他們是創造的,並且不能改變。
var a = [1, 2, 3];
var b = a.map((n, i) => n * i);
console.log(b.join(", ")); // 0, 2, 6
如果您正在做一个单一表达式以上,请使用 {} 和一个明确的回报(如果您需要返回值),如正常:
var a = [
{first: "Joe", last: "Bloggs"},
{first: "Albert", last: "Bloggs"},
{first: "Mary", last: "Albright"}
];
a = a.sort((a, b) => {
var rv = a.last.localeCompare(b.last);
if (rv === 0) {
rv = a.first.localeCompare(b.first);
}
return rv;
});
console.log(JSON.stringify(a));
对象初步化方法宣言(ES2015+)
var o = {
foo() {
}
};
var o = {
foo: function foo() {
}
};
ES2015为我们提供类合成,包括声明的建筑师和方法:
class Person {
constructor(firstName, lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
getFullName() {
return this.firstName + " " + this.lastName;
}
}
其他回答
第一個(函數 doSomething(x))應該是對象評分的一部分。
你可能想知道什么是函数声明和函数表达式。
function foo() {
return 3;
}
ECMA 5(13.0)定义合成为函数识别器(FormalParameterListopt ) { FunctionBody }
在上述情况下,函数名称在其范围内和其父母范围内可见(否则它将是不可访问的)。
在函数表达中
函数表达式定义函数作为一个更大的表达式合成的一部分(通常是一个变量任务)。函数表达式可以命名或匿名。
// Anonymous function expression
var a = function() {
return 3;
}
// Named function expression
var a = function foo() {
return 3;
}
// Self-invoking function expression
(function foo() {
alert("hello!");
})();
ECMA 5 (13.0) 定义合成为函数 Identifieropt ( FormalParameterListopt ) { FunctionBody }
函数表达与函数表达的区别:
然而,在变量中存储函数(函数表达)并不是创建函数的唯一方式,也可以通过函数声明进行。
函数表达式可以是匿名的,而函数声明必须有一个名称. 两者都有一个名称属性,用于识别函数. 函数表达式的名称属性是它所属的变量的名称,而函数声明的名称只是给出的名称。
下面是一个例子:
答:
函数内所宣布的变量/函数在页面内是全球性的,可以访问该页面中的任何地方.函数内所宣布的变量/函数具有本地范围. 也就是说,它们在函数体内可用/可用,它们不在函数体外可用。
变量
JavaScript 被称为顺利打字语言,这意味着 JavaScript 变量可以保留任何数据类型的值,JavaScript 会自动根据运行时间提供的值/字体来改变变量类型。
global_Page = 10; var global_Page; « undefined
« Integer literal, Number Type. ------------------- global_Page = 10; « Number
global_Page = 'Yash'; | Interpreted | global_Page = 'Yash'; « String
« String literal, String Type. « AS « global_Page = true; « Boolean
var global_Page = true; | | global_Page = function (){ « function
« Boolean Type ------------------- var local_functionblock; « undefined
global_Page = function (){ local_functionblock = 777;« Number
var local_functionblock = 777; };
// Assigning function as a data.
};
功能
function Identifier_opt ( FormalParameterList_opt ) {
FunctionBody | sequence of statements
« return; Default undefined
« return 'some data';
}
function globalAccess() { function globalAccess() {
} ------------------- }
globalAccess(); | | function globalAccess() { « Re-Defined / overridden.
localAccess(); « Hoisted As « function localAccess() {
function globalAccess() { | | }
localAccess(); ------------------- localAccess(); « function accessed with in globalAccess() only.
function localAccess() { }
} globalAccess();
} localAccess(); « ReferenceError as the function is not defined
功能表达
10; « literal
(10); « Expression (10).toString() -> '10'
var a;
a = 10; « Expression var a.toString() -> '10'
(function invoke() { « Expression Function
console.log('Self Invoking'); (function () {
}); }) () -> 'Self Invoking'
var f;
f = function (){ « Expression var Function
console.log('var Function'); f () -> 'var Function'
};
(function selfExecuting(){
console.log('IIFE - Immediately-Invoked Function Expression');
}());
var anonymous = function (){
console.log('anonymous function Expression');
};
var namedExpression = function for_InternalUSE(fact){
if(fact === 1){
return 1;
}
var localExpression = function(){
console.log('Local to the parent Function Scope');
};
globalExpression = function(){
console.log('creates a new global variable, then assigned this function.');
};
//return; //undefined.
return fact * for_InternalUSE( fact - 1);
};
namedExpression();
globalExpression();
JavaScript 被解释为
var anonymous;
var namedExpression;
var globalExpression;
anonymous = function (){
console.log('anonymous function Expression');
};
namedExpression = function for_InternalUSE(fact){
var localExpression;
if(fact === 1){
return 1;
}
localExpression = function(){
console.log('Local to the parent Function Scope');
};
globalExpression = function(){
console.log('creates a new global variable, then assigned this function.');
};
return fact * for_InternalUSE( fact - 1); // DEFAULT UNDEFINED.
};
namedExpression(10);
globalExpression();
ES5 Constructor 功能类:使用 Function.prototype.bind 创建的功能对象
function Shape(id) { // Function Declaration
this.id = id;
};
// Adding a prototyped method to a function.
Shape.prototype.getID = function () {
return this.id;
};
Shape.prototype.setID = function ( id ) {
this.id = id;
};
var expFn = Shape; // Function Expression
var funObj = new Shape( ); // Function Object
funObj.hasOwnProperty('prototype'); // false
funObj.setID( 10 );
console.log( funObj.getID() ); // 10
ArrowFunction : ArrowParameters => ConciseBody. const fn = (item) => {返回项目 & 1? 'Odd' : 'Even'; }; console.log( fn(2) ); // Even console.log( fn(3) ); // Odd
1、功能表达
var functionOne = function() {
// Some code
};
函数表达式定义一个函数作为一个更大的表达式合成的一部分(通常是一个变量任务)。函数表达式通过函数表达式定义的函数可以被命名或匿名。
二、职能宣言
function functionTwo() {
// Some code
}
这是在JavaScript中召唤函数的正常方式,这个函数可以被召唤之前你甚至宣布它,因为在JavaScript中,所有函数都被收集,但如果你有“严格使用”这个函数不会像预期那样收集,这是一个很好的方式召唤所有正常函数,这些函数不大,也不是一个构建函数。
此外,如果您需要更多关于如何在JavaScript中工作的信息,请参阅下面的链接:
function xyz(){
function abc(){};
// abc is defined here...
}
// ...but not here
其次,可以结合两种风格:
var xyz = function abc(){};
var xyz = function abc(){
// xyz is visible here
// abc is visible here
}
// xyz is visible here
// abc is undefined here
function abc(){};
var xyz = abc;
console.log(xyz === abc); // prints "true"
function abc(){};
console.log(abc.name); // prints "abc"
var abc = function(){};
console.log(abc.name); // prints ""
它的名字是空的 - 我们创建了一个匿名函数,并将其分配给一些变量。
使用合并风格的另一个好理由是使用一个简短的内部名称来引用自己,同时为外部用户提供一个长而不冲突的名称:
// Assume really.long.external.scoped is {}
really.long.external.scoped.name = function shortcut(n){
// Let it call itself recursively:
shortcut(n - 1);
// ...
// Let it pass itself as a callback:
someFunction(shortcut);
// ...
}
在上面的例子中,我们可以用外部名称做同样的事情,但它会太不多(而且更慢)。
function abc(){}
abc在这里在当前范围内在任何地方都被定义:
// We can call it here
abc(); // Works
// Yet, it is defined down there.
function abc(){}
// We can call it again
abc(); // Works
// We can call it here
abc(); // Works
return;
function abc(){}
这是一个功能表达:
var xyz = function(){};
xyz 在这里从分配点定义:
// We can't call it here
xyz(); // UNDEFINED!!!
// Now it is defined
xyz = function(){}
// We can call it here
xyz(); // works
函数声明与函数表达是格雷格所证明的差异的真正原因。
有趣的事实:
var xyz = function abc(){};
console.log(xyz.name); // Prints "abc"
var abc = function(){};
我知道我定义了函数本地,当我定义了函数如
abc = function(){};
function abc(){};
它取决于背景,可能会让你猜测它实际上在哪里定义,特别是在 eval()的情况下 - 答案是: 它取决于浏览器。
推荐文章
- Babel 6改变了它导出默认值的方式
- 如何配置历史记录?
- ES6模板文字可以在运行时被替换(或重用)吗?
- [Vue警告]:找不到元素
- 可以在setInterval()内部调用clearInterval()吗?
- AngularJS控制器的生命周期是什么?
- 无法读取未定义的属性“msie”- jQuery工具
- 我的蛋蛋怎么不见了?
- JavaScript中的排列?
- JavaScript中有睡眠/暂停/等待功能吗?
- 如何禁用文本选择使用jQuery?
- 如何停止事件冒泡复选框点击
- 如何在PHP中截断字符串最接近于一定数量的字符?
- 向对象数组添加属性
- 如何在Redux应用程序中动态加载代码分割的减速器?
