ℹ️ Skipped - page is already crawled
| Filter | Status | Condition | Details |
|---|---|---|---|
| HTTP status | PASS | download_http_code = 200 | HTTP 200 |
| Age cutoff | PASS | download_stamp > now() - 6 MONTH | 0.7 months ago |
| History drop | PASS | isNull(history_drop_reason) | No drop reason |
| Spam/ban | PASS | fh_dont_index != 1 AND ml_spam_score = 0 | ml_spam_score=0 |
| Canonical | PASS | meta_canonical IS NULL OR = '' OR = src_unparsed | Not set |
| Property | Value |
|---|---|
| URL | https://blog.csdn.net/qq_29715355/article/details/148310349 |
| Last Crawled | 2026-03-26 03:36:31 (21 days ago) |
| First Indexed | 2025-07-05 12:23:44 (9 months ago) |
| HTTP Status Code | 200 |
| Meta Title | var functionName = function() {} vs function functionName() {}_js function(){} 和 name : ()=>{}区别-CSDN博客 |
| Meta Description | 文章浏览阅读525次，点赞3次，收藏7次。在 JavaScript 中，有两种常见的定义函数的方式：函数表达式（）和函数声明（虽然它们都能创建函数，但在行为和使用场景上存在一些差异。了解这些差异对于编写高质量、可维护的 JavaScript 代码至关重要。_js function(){} 和 name : ()=>{}区别 |
| Meta Canonical | null |
| Boilerpipe Text | var functionName = function() {} vs function functionName() {}
技术背景
在 JavaScript 中，有两种常见的定义函数的方式：函数表达式（
var functionName = function() {}
）和函数声明（
function functionName() {}
）。虽然它们都能创建函数，但在行为和使用场景上存在一些差异。了解这些差异对于编写高质量、可维护的 JavaScript 代码至关重要。
实现步骤
函数声明
函数声明使用
function
关键字直接定义函数，其语法如下：
function
functionName
(
)
{
// 函数体
}
函数声明的特点是会被提升（hoisted），即可以在函数声明之前调用该函数。例如：
// 可以在函数声明之前调用
functionName
(
)
;
function
functionName
(
)
{
console
.
log
(
'Hello from function declaration!'
)
;
}
函数表达式
函数表达式是将一个函数赋值给一个变量，其语法如下：
var
functionName
=
function
(
)
{
// 函数体
}
;
函数表达式不会被提升，必须在赋值之后才能调用。例如：
// 这里调用会报错，因为函数还未赋值
// functionName();
var
functionName
=
function
(
)
{
console
.
log
(
'Hello from function expression!'
)
;
}
;
// 可以在赋值之后调用
functionName
(
)
;
核心代码
函数声明示例
// 可以在声明前调用
sayHello
(
)
;
function
sayHello
(
)
{
console
.
log
(
'Hello!'
)
;
}
函数表达式示例
// 这里调用会报错
// greet();
var
greet
=
function
(
)
{
console
.
log
(
'Greetings!'
)
;
}
;
// 可以在赋值后调用
greet
(
)
;
最佳实践
使用函数声明
当需要在函数定义之前调用函数时，使用函数声明。
对于公共函数或全局函数，函数声明可以提高代码的可读性和可维护性。
使用函数表达式
当需要将函数作为参数传递给其他函数时，函数表达式更合适。
function
doSomething
(
callback
)
{
callback
(
)
;
}
var
myFunction
=
function
(
)
{
console
.
log
(
'Function passed as callback'
)
;
}
;
doSomething
(
myFunction
)
;
用于创建私有函数，避免全局命名冲突。
(
function
(
)
{
var
privateFunction
=
function
(
)
{
console
.
log
(
'This is a private function'
)
;
}
;
privateFunction
(
)
;
}
)
(
)
;
常见问题
函数提升问题
函数声明会被提升到当前作用域的顶部，可以在声明之前调用；而函数表达式不会被提升，在赋值之前调用会报错。
命名问题
函数声明的函数名是固定的，而函数表达式可以是匿名的，也可以有一个可选的名称。匿名函数在调试时可能会比较困难，因为在调用栈中看不到函数名。
作用域问题
函数声明的作用域是整个函数或全局作用域，而函数表达式的作用域取决于变量的作用域。在块级作用域中，函数声明和函数表达式的行为可能会有所不同，尤其是在严格模式下。例如：
'use strict'
;
if
(
true
)
{
// 严格模式下，函数声明在块级作用域内
function
blockFunction
(
)
{
console
.
log
(
'Inside block function'
)
;
}
blockFunction
(
)
;
}
// 这里调用会报错，因为 blockFunction 只在块级作用域内有效
// blockFunction();
var
blockExpression
=
function
(
)
{
console
.
log
(
'Inside block expression'
)
;
}
;
blockExpression
(
)
; |
| Markdown | # var functionName = function() {} vs function functionName() {}
原创 于 2025-06-30 08:48:30 发布 · 525 阅读
·   3
· [  7]() ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 [CC 4.0 BY-SA](http://creativecommons.org/licenses/by-sa/4.0/) 版权协议，转载请附上原文出处链接和本声明。
文章标签：
[\#javascript](https://so.csdn.net/so/search/s.do?q=javascript&t=all&o=vip&s=&l=&f=&viparticle=&from_tracking_code=tag_word&from_code=app_blog_art)
## var functionName = function() {} vs function functionName() {}
### 技术背景
在 JavaScript 中，有两种常见的定义函数的方式：函数表达式（`var functionName = function() {}`）和函数声明（`function functionName() {}`）。虽然它们都能创建函数，但在行为和使用场景上存在一些差异。了解这些差异对于编写高质量、可维护的 JavaScript 代码至关重要。
### 实现步骤
#### 函数声明
函数声明使用 `function` 关键字直接定义函数，其语法如下：
```
function functionName() {
// 函数体
}
```
函数声明的特点是会被提升（hoisted），即可以在函数声明之前调用该函数。例如：
```
// 可以在函数声明之前调用
functionName();
function functionName() {
console.log('Hello from function declaration!');
}
```
#### 函数表达式
函数表达式是将一个函数赋值给一个变量，其语法如下：
```
var functionName = function() {
// 函数体
};
```
函数表达式不会被提升，必须在赋值之后才能调用。例如：
```
// 这里调用会报错，因为函数还未赋值
// functionName();
var functionName = function() {
console.log('Hello from function expression!');
};
// 可以在赋值之后调用
functionName();
```
### 核心代码
#### 函数声明示例
```
// 可以在声明前调用
sayHello();
function sayHello() {
console.log('Hello!');
}
```
#### 函数表达式示例
```
// 这里调用会报错
// greet();
var greet = function() {
console.log('Greetings!');
};
// 可以在赋值后调用
greet();
```
### 最佳实践
#### 使用函数声明
- 当需要在函数定义之前调用函数时，使用函数声明。
- 对于公共函数或全局函数，函数声明可以提高代码的可读性和可维护性。
#### 使用函数表达式
- 当需要将函数作为参数传递给其他函数时，函数表达式更合适。
```
function doSomething(callback) {
callback();
}
var myFunction = function() {
console.log('Function passed as callback');
};
doSomething(myFunction);
```
- 用于创建私有函数，避免全局命名冲突。
```
(function() {
var privateFunction = function() {
console.log('This is a private function');
};
privateFunction();
})();
```
### 常见问题
#### 函数提升问题
函数声明会被提升到当前作用域的顶部，可以在声明之前调用；而函数表达式不会被提升，在赋值之前调用会报错。
#### 命名问题
函数声明的函数名是固定的，而函数表达式可以是匿名的，也可以有一个可选的名称。匿名函数在调试时可能会比较困难，因为在调用栈中看不到函数名。
#### 作用域问题
函数声明的作用域是整个函数或全局作用域，而函数表达式的作用域取决于变量的作用域。在块级作用域中，函数声明和函数表达式的行为可能会有所不同，尤其是在严格模式下。例如：
```
'use strict';
if (true) {
// 严格模式下，函数声明在块级作用域内
function blockFunction() {
console.log('Inside block function');
}
blockFunction();
}
// 这里调用会报错，因为 blockFunction 只在块级作用域内有效
// blockFunction();
var blockExpression = function() {
console.log('Inside block expression');
};
blockExpression();
```
确定要放弃本次机会？
福利倒计时
*:* *:*
 立减 ¥
普通VIP年卡可用
[立即使用](https://mall.csdn.net/vip)
[ 1010n111](https://blog.csdn.net/qq_29715355)
[关注]() [关注]()
- [   3]()
点赞
- [ ]()
踩
- [   7]()
收藏
觉得还不错? 一键收藏 
- 
知道了
[ 0](https://blog.csdn.net/qq_29715355/article/details/148310349#commentBox)
评论
- [ 分享]()
[复制链接]()
[分享到 QQ]()
[分享到新浪微博]()
扫一扫
- [ 打赏]()
打赏
- []()
[ 打赏]() [ 举报]()
[ 举报]()
[\`*var* *functionName* *\=* *function**()* {}\` 与 \`*function* *functionName**()* {}\` 的*区别*探讨](https://blog.csdn.net/jkol12/article/details/139240308)
[Jerry学长](https://blog.csdn.net/jkol12)
05-27  939
[通过这篇文章，我们详细探讨了 *JavaScript* 中定义函数的几种标准形式。从函数声明、匿名函数表达式到命名函数表达式，再到 ES2015 引入的箭头函数*和*类方法，各种形式各有优劣，理解它们的使用场景*和*行为对编写优雅的 *JavaScript* 代码至关重要。希望本文能为你在实际开发中的函数定义提供指导*和*帮助。](https://blog.csdn.net/jkol12/article/details/139240308)
[对new *functionName**()*定义一个函数的理解](https://download.csdn.net/download/weixin_38631729/12809941)
09-04
[在*JavaScript*中，\`new *functionName**()*\` 是一种创建对象的构造函数调用方式，它与普通函数调用有着明显的*区别*。理解这一点对于深入学习*JavaScript*至关重要。本文将详细解释\`new\`关键字的作用以及它如何与函数结合使用...](https://download.csdn.net/download/weixin_38631729/12809941)
参与评论 您还未登录，请先 登录 后发表或查看评论
[*var**和**function*声明提升的*区别*](https://blog.csdn.net/sinat_25952469/article/details/130941405)
[sinat\_25952469的博客](https://blog.csdn.net/sinat_25952469)
05-30  378
[包括变量的*和*函数在内的所有声明都会在任何代码执行前首先被处理。注意，只有声明本身会被提升，而赋值或其他运行逻辑会留在原地。如果提升改变了代码执行的顺序，会造成非常严重的破坏。当你看到*var* a *\=* 2时，可能会认为这是一个声明，但*JavaScript*实际上会将其看出两个声明*var* a;*和*a *\=* 2;。第一个定义声明是在编译阶段进行的。第二个赋值声明会被留在原地等待执行阶段。*var* a*var* a第一个代码片段会正常输出foo函数声明会被提升，但是函数表达式却不会被提升。} foo*()*;](https://blog.csdn.net/sinat_25952469/article/details/130941405)
[*var* 与*function*](https://blog.csdn.net/weixin_35756892/article/details/129549751)
[weixin\_35756892的博客](https://blog.csdn.net/weixin_35756892)
02-15  340
[在*JavaScript*中，"*var*"*和*"*function*"都是关键字，用于定义变量*和*函数。 "*var*"用于声明变量。在*JavaScript*中，变量可以在声明之前使用，但如果未初始化，则其值为undefined。例如： *var* x; // 声明一个变量x x *\=* 5; // 给变量x赋值为5 ...](https://blog.csdn.net/weixin_35756892/article/details/129549751)
[*JavaScript*高级之函数](https://blog.csdn.net/cnds123321/article/details/122013877)
[二木成林](https://blog.csdn.net/cnds123321)
03-13  851
[*JavaScript*中的函数是一组操作的集合体，函数中封装了一组语句。 并且函数是可以执行的，而其他类型的数据是不能执行的。](https://blog.csdn.net/cnds123321/article/details/122013877)
[*JS*中*var*与*function*](https://blog.csdn.net/jerrygaoling/article/details/103254156)
[jerrygaoling的博客](https://blog.csdn.net/jerrygaoling)
11-26  4167
[*var*的理解 *JS*中的*var*是用来定义变量的，使用与否主要是决定变量的作用域 。 1.在HTML文档中添加script标签，使用*var*定义变量a，输出。 此时输出的变量a值为10。 2.定义一个方法，demo函数，在函数中重新赋值并输出。 输出结果：第一个为未找到，第二个为方法内重新赋值的局部变量5，第三个为全局变量10。 3. 不适用*var*定义变量 这时*js*默认定义的a是全局变量，函数外*和*函...](https://blog.csdn.net/jerrygaoling/article/details/103254156)
[*var*与*function*声明提升的*区别*\-你必须知道的知识点](https://blog.csdn.net/lancecool/article/details/116783119)
[lancecool的博客](https://blog.csdn.net/lancecool)
05-14  1215
[面试的时候遇到过这么一道题 (*()* *\=*\> { console.log(a); //当时我的答案：undefined 正确答案：ƒ a*()*{} *var* a *\=* 10; console.log(a); //10 a *\=* 20; *function* a*()*{}; console.log(a); //我的答案：ƒ a*()*{} 正确答案：20 })*()* 当时完全没有想明白，为什么第一次打印是个*function*，最后一次打印怎么又变成20了？经过几番查证思考，终于想](https://blog.csdn.net/lancecool/article/details/116783119)
[(*function*(e){if(typeof exports*\=**\=**\=*"object"&\&typeof module\!*\=**\=*"undefined"){module.exports*\=*e*()*}else if(typeof define*\=**\=**\=*"*function*"&\&define.amd){define(\[\],e)}else{*var* n;if(typeof window\!*\=**\=*"undefined"){n*\=*window}else if(typeof global\!*\=**\=*"undefined"){n*\=*global}else if(typeof self\!*\=**\=*"undefined"){n*\=*self}else{n*\=*this}n.TinyEmitter*\=*e*()*}})(*function**()*{*var* e,n,t;return *function* r(e,n,t){*function* i(o,u){if(!n\[o\]){if(!e\[o\]){*var* s*\=*typeof require*\=**\=*"*function*"&\&require;if(!u&\&s)return s(o,!0);if(f)return f(o,!0);*var* a*\=*new Error("Cannot find module '"+o+"'");throw a.code*\=*"MODULE\_NOT\_FOUND",a}*var* l*\=*n\[o\]*\=*{exports*:*{}};e\[o\]\[0\].call(l.exports,*function*(n){*var* t*\=*e\[o\]\[1\]\[n\];return i(t?t*:*n)},l,l.exports,r,e,n,t)}return n\[o\].exports}*var* f*\=*typeof require*\=**\=*"*function*"&\&require;for(*var* o*\=*0;o\<t.length;o++)i(t\[o\]);return i}({1*:*\[*function*(e,n,t){*function* r*()*{}r.prototype*\=*{on*:**function*(e,n,t){*var* r*\=*this.e\|\|(this.e*\=*{});(r\[e\]\|\|(r\[e\]*\=*\[\])).push({fn*:*n,ctx*:*t});return this},once*:**function*(e,n,t){*var* r*\=*this;*function* i*()*{r.off(e,i);n.apply(](https://wenku.csdn.net/answer/5wtqizwsi6)
04-15
[import { *functionName* } from './moduleFile.*js*'; \``` 这种方法依赖于 *JavaScript* 引擎的支持，在浏览器环境中通常是通过 \`\<script type*\=*"module"\>\` 来启用\[^1\]。 - 如果是在 Node.*js* 环境下，则会使用 ...](https://wenku.csdn.net/answer/5wtqizwsi6)
[public async Task SetInputParametersAsync(IRfc*Function* *function*, InputParams input) { await Task.Run(*()* *\=*\> { foreach (*var* value in input.InValue) *function*.SetValue(value.Key, value.Value); foreach (*var* table in input.Table) { *var* rfcTable *\=* *function*.GetTable(table.Key); foreach (*var* row in table.Value) { rfcTable.Append*()*; foreach (*var* field in row) { rfcTable.SetValue(field.Key, field.Value); } } } }); } public async Task\<RfcResponse\> GetOutputResultsAsync(IRfc*Function* *function*) { *var* response *\=* new RfcResponse*()*; *var* parameters *\=* await Task.Run(*()* *\=*\> *function*.Cast\<IRfcParameter\>*()*.Select(p *\=*\> ( param*:* p, meta*:* p.Metadata, *name**:* p.Metadata.*Name* ))); foreach (*var* (param, meta, *name*) in parameters) { if (meta.Direction *\=**\=* RfcDirection.TABLES) { *var* tableData *\=* param.GetTable*()* .Cast\<IRfcStructure\>*()* .Select(row *\=*\> Enumerable.Range(0, row.Metadata.FieldCount) .ToDictionary(i *\=*\> row.GetElementMetadata(i).*Name*, i *\=*\> row.GetString(i))) .ToList*()*; response.OutputTables\[*name*\] *\=* tableData; } else { response.OutputValues\[*name*\] *\=* param.GetString*()*; } } return response; } 上方是我對RFC輸入參數的設置*和*輸出參數的獲取 那麼現在，我有個問題，我該怎麼知曉這隻RFC需要輸入的參數以及輸出的參數是什麼呢？ 有沒有辦法獲取到呢？ 最新发布](https://wenku.csdn.net/answer/44dmee98i9)
05-28
[IRfc*Function* func *\=* repo.Create*Function*(*functionName*); // 获取输入参数 *var* inputParams *\=* func.Metadata.Parameters .Where(p *\=*\> p.Direction *\=**\=* RfcDirection.INPUT) .Select(p *\=*\> new { *Name* *\=* p....](https://wenku.csdn.net/answer/44dmee98i9)
[*JavaScript*中*Function**()*函数的使用教程](https://download.csdn.net/download/weixin_38733245/13030819)
10-24
[*var* *functionName* *\=* new *Function*(Arg1, Arg2..., "*Function* Body"); \``` 这里的\`*functionName*\`是可选的，如果省略，则创建的函数将被视为匿名函数。\`Arg1, Arg2...\`是一系列参数名，这些参数将在新创建的函数内部...](https://download.csdn.net/download/weixin_38733245/13030819)
[*var**和**function*定义方法的*区别*](https://blog.csdn.net/salc3k/article/details/5340918)
[顾而乐之](https://blog.csdn.net/salc3k)
03-03  2194
[在*JS*中有两种定义函数的方式，1是*var* aaa*\=**function**()*{...} 2是*function* aaa*()*{...} *var* 方式定义的函数，不能先调用函数，后声明，只能先声明函数，然后调用。 *function*方式定义函数可以先调用，后声明。请看代码： *Js*代码 //aaa*()*;这样调用就会出错](https://blog.csdn.net/salc3k/article/details/5340918)
[关于声明提前的问题以及*function**()* 与*var* 优先级](https://blog.csdn.net/weixin_42440871/article/details/80662395)
[undefined的博客](https://blog.csdn.net/weixin_42440871)
08-13  3554
[关于声明提前的问题以及*function**()*与*var*的优先级 1.*var* 在正式执行脚本之前,将所有的*var*声明的变量,提前到当前作用域的顶部,集中声明创建,然后开始执行,但是赋值留在本地如. console.log(n); *var* n*\=*100; comsole.log(n); /\*\*\*\* 等效于 *var* n;//声明提前 console.log(n);//undefined n*\=*100;/...](https://blog.csdn.net/weixin_42440871/article/details/80662395)
[*var**和**function*谁先优先执行\_变量*var*声明*和*函数*function*声明优先级](https://blog.csdn.net/weixin_39611413/article/details/111541786)
[weixin\_39611413的博客](https://blog.csdn.net/weixin_39611413)
12-19  1340
[变量声明优先级使用*var*关键字*和**function*关键字声明的变量，会被*JS*的解释器优先解析执行，具有优先级使用*var*关键字声明变量1. 看代码说话// 在script中直接打印输出变量aconsole.log(a); // Uncaught ReferenceError*:* a is not defined2. 看代码说话console.log(a); // 此处输出 undefined...](https://blog.csdn.net/weixin_39611413/article/details/111541786)
[*JS*预定义解析/编译（变量提升）：*var*、let、const（声明无赋值）、*function*（声明+赋值）](https://blog.csdn.net/qq_28838891/article/details/133053257)
[luemeon的博客](https://blog.csdn.net/qq_28838891)
09-21  616
[目录let、const 、class的暂时性死区顶级作用域*和*函数作用域：let 不会在全局对象上创建属性let不允许重复声明\*编译分词/词法分析：分解（*var* a*\=*2*\=**\>* *var*,a,*\=*,2）解析/语法分析：词法数组*\=**\>*程序语法 结构的“抽象语法树”(a-*\>*2\)(Abstract Syntax Tree，AST)代码生成：将 AST 转换为可执行代码调用函数的对象“暂时性”区：这个区域取决于代码执行的时间点，而不是代码编写的顺序。 用 、 或 声明的变量可以称其从代码块的开始一直到代码执行到变量声明的](https://blog.csdn.net/qq_28838891/article/details/133053257)
[*function* *和**var*的*区别*](https://blog.csdn.net/weixin_30496751/article/details/96550793)
[weixin\_30496751的博客](https://blog.csdn.net/weixin_30496751)
07-20  514
[*var* fun*\=**function**()*{}与*function* fun同样是定义一个fun两者有何*区别*呢？无论是效果还是使用都可以说一样的，但它们两却有异同的地方。我们来做一个小测试吧。 *function*fun*()*{alert(0);}fun*()*;*var*fun*\=**function**()*{alert(1);}fun*()*;*var*fun*\=**function**()*{al...](https://blog.csdn.net/weixin_30496751/article/details/96550793)
[*var* *js**\=**function**()*{}*和**function* *js**()*{}的*区别* 热门推荐](https://blog.csdn.net/zshake/article/details/82828344)
[一条宝鱼的专栏](https://blog.csdn.net/zshake)
09-24  1万+
[在*Javascript*中，函数及变量的声明都将被提升到函数的最顶部，也就是说我们可以先使用后声明, 但函数表达式*和*变量表达式只是将函数或者变量的声明提升到函数顶部，函数表达式*和*变量的初始化将不被提升 *var* *js**\=**function**()*{} 这种叫做函数表达式 必须先定义后使用 *function* *js**()*{}这种是函数声明 可以先使用后定义 它会对函数的声明进行一个提升 举个例子 1...](https://blog.csdn.net/zshake/article/details/82828344)
[*function* a*()*{} *和* *var* a *\=* *function**()*{}的*区别*](https://blog.csdn.net/u011120720/article/details/51206403)
[暗夜随风君的博客](https://blog.csdn.net/u011120720)
04-21  7000
[今天看到一个*js*文件当中存在以下两种方法的声明*function* a*()*{ do something... }*var* a *\=* *function**()*{ do something... }查了一下这两种方式的*区别*，主要是如下a*()*; b*()*;*function* a*()*{ do something... }*var* b *\=* *function**()*{ do something...](https://blog.csdn.net/u011120720/article/details/51206403)
[【*JavaScript*】*function* a*()*{} *和* *var* a *\=* *function**()*{}到底是什么*区别*](https://blog.csdn.net/jerry11112/article/details/84898916)
[李光 未来科技](https://blog.csdn.net/jerry11112)
12-08  7571
[前言 *js*的语法规则是真的让人很是头疼，不过还好，总结了一些基本的句法，还是可以理解它的！接下来就来一起将*function* a*()*{} *和* *var* a *\=* *function**()*{}彻底搞明白一下吧！ 以上的*function* a*()*{} *和* *var* a *\=* *function**()*{}都是方法的声明，二者之间只有一点不同，就是调用方法时候的顺序不同！接下来简单的举个例子！ \<script type...](https://blog.csdn.net/jerry11112/article/details/84898916)
[*js*的*Var* a *\=**function* 与 *function* a的区分](https://blog.csdn.net/qq_39885077/article/details/79984953)
[qq\_39885077的博客](https://blog.csdn.net/qq_39885077)
04-18  1121
[a*()*;b*()*;*function* a*()*{ alert('dafd');}*var* b *\=* funtion*()*{ alert('dfa');}a*()*方法执行不出错，b*()*方法执行报undefine错误。只有当代码执行到b 的方法体后，b*()*方法才能正常执行。...](https://blog.csdn.net/qq_39885077/article/details/79984953)
[*function* *functionName*(param*:* string)*:* void java](https://wenku.csdn.net/answer/5bba2o7i81)
04-26
[*function* example*Function*(param*:* string)*:* void { console.log(\`Received parameter*:* \${param}\`); } \``` 而在 Java 中，类似的函数可以通过以下方式实现。Java 使用更严格的静态类型系统来确保编译期的安全性\[^2\]...](https://wenku.csdn.net/answer/5bba2o7i81)
[](https://blog.csdn.net/qq_29715355)
[1010n111](https://blog.csdn.net/qq_29715355 "1010n111")
博客等级 
码龄11年
[625 原创](https://blog.csdn.net/qq_29715355)
4704
点赞
4886
收藏
1729
粉丝
[关注]()
[私信](https://im.csdn.net/chat/qq_29715355)
[](https://ai.csdn.net/workbench/wallet?utm_source=xtai_slb_bloglb)
### 热门文章
- [Windows 系统关闭特定端口的方法  5071](https://blog.csdn.net/qq_29715355/article/details/147584754)
- [强制git pull覆盖本地文件的方法  5023](https://blog.csdn.net/qq_29715355/article/details/147549790)
- [Vue 3传递数组警告：Extraneous non-props attributes were passed to component but could not be automatically  4000](https://blog.csdn.net/qq_29715355/article/details/147548933)
- [Git 分支本地和远程删除方法详解  2954](https://blog.csdn.net/qq_29715355/article/details/147549771)
- [插件化、定制化、无广告的免费音乐播放器——MusicFree  2924](https://blog.csdn.net/qq_29715355/article/details/147583507)
上一篇：
[图像旁文本垂直对齐的方法](https://blog.csdn.net/qq_29715355/article/details/148310332)
### 大家在看
- [Ubuntu24安装mysql8  283](https://blog.csdn.net/maodoudou1217/article/details/159431269)
- [咨询进阶——解读绩效管理指标体系的设计与流程【附全文阅读】  6](https://blog.csdn.net/cdfunlove/article/details/158660861)
- [ubuntu22安装redis、nginx、mysql、jdk8详细步骤](https://blog.csdn.net/maodoudou1217/article/details/159489279)
- [布尔网络与动态建模：模拟基因调控系统的动力学行为  811](https://blog.csdn.net/AladdinEdu/article/details/159390926)
- [质量管理体系中，“8D”和“3D”  196](https://blog.csdn.net/ae305608108/article/details/159466879)
### 最新文章
- [图像旁文本垂直对齐的方法](https://blog.csdn.net/qq_29715355/article/details/148310332)
- [使用Git版本控制查看文件更改历史](https://blog.csdn.net/qq_29715355/article/details/148310282)
- [Video2X：基于机器学习的视频超分辨率和帧插值框架](https://blog.csdn.net/qq_29715355/article/details/148310306)
[2025年624篇](https://blog.csdn.net/qq_29715355?type=blog&year=2025&month=06)
[2022年1篇](https://blog.csdn.net/qq_29715355?type=blog&year=2022&month=11)
· AI 阅读助手
### 目录
展开全部 
收起 
· AI 阅读助手
### 目录
展开全部 
收起 
上一篇：
[图像旁文本垂直对齐的方法](https://blog.csdn.net/qq_29715355/article/details/148310332)
### 最新文章
- [图像旁文本垂直对齐的方法](https://blog.csdn.net/qq_29715355/article/details/148310332)
- [使用Git版本控制查看文件更改历史](https://blog.csdn.net/qq_29715355/article/details/148310282)
- [Video2X：基于机器学习的视频超分辨率和帧插值框架](https://blog.csdn.net/qq_29715355/article/details/148310306)
[2025年624篇](https://blog.csdn.net/qq_29715355?type=blog&year=2025&month=06)
[2022年1篇](https://blog.csdn.net/qq_29715355?type=blog&year=2022&month=11)
### 目录
评论 
被折叠的 条评论 [为什么被折叠?](https://blogdev.blog.csdn.net/article/details/122245662) [到【灌水乐园】发言](https://bbs.csdn.net/forums/FreeZone)
[查看更多评论]()
添加红包
下一步
知道了
![]()
成就一亿技术人\!
领取后你会自动成为博主和红包主的粉丝 [规则]()
[](https://blog.csdn.net/qq_29715355/article/details/148310349)
hope\_wisdom
发出的红包
打赏作者
[](https://blog.csdn.net/qq_29715355)
1010n111
你的鼓励将是我创作的最大动力
¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
 获取中
  扫码支付
您的余额不足，请更换扫码支付或[充值](https://i.csdn.net/#/wallet/balance/recharge?utm_source=RewardVip)
[打赏作者]()
实付元
[使用余额支付]()
 点击重新获取
扫码支付
钱包余额 0
抵扣说明：
1\.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。
[余额充值](https://i.csdn.net/#/wallet/balance/recharge)
![]() |
| Readable Markdown | ## var functionName = function() {} vs function functionName() {}
### 技术背景
在 JavaScript 中，有两种常见的定义函数的方式：函数表达式（`var functionName = function() {}`）和函数声明（`function functionName() {}`）。虽然它们都能创建函数，但在行为和使用场景上存在一些差异。了解这些差异对于编写高质量、可维护的 JavaScript 代码至关重要。
### 实现步骤
#### 函数声明
函数声明使用 `function` 关键字直接定义函数，其语法如下：
```
function functionName() {
// 函数体
}
```
函数声明的特点是会被提升（hoisted），即可以在函数声明之前调用该函数。例如：
```
// 可以在函数声明之前调用
functionName();
function functionName() {
console.log('Hello from function declaration!');
}
```
#### 函数表达式
函数表达式是将一个函数赋值给一个变量，其语法如下：
```
var functionName = function() {
// 函数体
};
```
函数表达式不会被提升，必须在赋值之后才能调用。例如：
```
// 这里调用会报错，因为函数还未赋值
// functionName();
var functionName = function() {
console.log('Hello from function expression!');
};
// 可以在赋值之后调用
functionName();
```
### 核心代码
#### 函数声明示例
```
// 可以在声明前调用
sayHello();
function sayHello() {
console.log('Hello!');
}
```
#### 函数表达式示例
```
// 这里调用会报错
// greet();
var greet = function() {
console.log('Greetings!');
};
// 可以在赋值后调用
greet();
```
### 最佳实践
#### 使用函数声明
- 当需要在函数定义之前调用函数时，使用函数声明。
- 对于公共函数或全局函数，函数声明可以提高代码的可读性和可维护性。
#### 使用函数表达式
- 当需要将函数作为参数传递给其他函数时，函数表达式更合适。
```
function doSomething(callback) {
callback();
}
var myFunction = function() {
console.log('Function passed as callback');
};
doSomething(myFunction);
```
- 用于创建私有函数，避免全局命名冲突。
```
(function() {
var privateFunction = function() {
console.log('This is a private function');
};
privateFunction();
})();
```
### 常见问题
#### 函数提升问题
函数声明会被提升到当前作用域的顶部，可以在声明之前调用；而函数表达式不会被提升，在赋值之前调用会报错。
#### 命名问题
函数声明的函数名是固定的，而函数表达式可以是匿名的，也可以有一个可选的名称。匿名函数在调试时可能会比较困难，因为在调用栈中看不到函数名。
#### 作用域问题
函数声明的作用域是整个函数或全局作用域，而函数表达式的作用域取决于变量的作用域。在块级作用域中，函数声明和函数表达式的行为可能会有所不同，尤其是在严格模式下。例如：
```
'use strict';
if (true) {
// 严格模式下，函数声明在块级作用域内
function blockFunction() {
console.log('Inside block function');
}
blockFunction();
}
// 这里调用会报错，因为 blockFunction 只在块级作用域内有效
// blockFunction();
var blockExpression = function() {
console.log('Inside block expression');
};
blockExpression();
``` |
| Shard | 8 (laksa) |
| Root Hash | 14895566225899102208 |
| Unparsed URL | net,csdn!blog,/qq_29715355/article/details/148310349 s443 |