JavaScript 函数当调用该函数时，会执行函数内的代码。可以在某事件发生时直接调用函数（比如当用户点击按钮时），并

函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块函数就是用来执行任务的代码块，函数需要通过调用的方式来完成代码的执行，函数的最大好处：包含在函数内容的代码块，可以重复执行

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>测试实例</title>
</head>

<body>
<button onclick="myFunction()">点我</button>
</body>

<script>
function myFunction(){
    alert("Hello World!");
}
</script>

</html>

尝试一下 »

函数的三种形式

普通函数

function f() {
  console.log("普通函数")
}
f()

构造函数

通过new 来调用,创建对象

function F() {
  console.log("我是构造函数")
}
var f = new F()

对象的方法

function Person() {
  this.say = function () {
    console.log("写代码")
  }
}
var per = new Person()
per.say()





var myObject = {
    firstName:"John",
    lastName: "Doe",
    fullName: function () {
        return this.firstName + " " + this.lastName;
    }
}
myObject.fullName();   // 返回 "John Doe"

JavaScript 函数定义

JavaScript 使用关键字 function 定义函数函数可以通过声明定义，也可以是一个表达式

函数声明

函数就是包裹在花括号中的代码块，前面使用了关键词 function

function functionName(parameters) {
  执行的代码
}

当调用该函数时，会执行函数内的代码。可以在某事件发生时直接调用函数（比如当用户点击按钮时），并且可由 JavaScript 在任何位置进行调用 ⚠️**注意: **JavaScript 对大小写敏感。关键词 function 必须是小写的，且必须以与函数名称完全一致来调用函数

调用带参数的函数

函数声明后不会立即执行，会在我们需要的时候调用到在调用函数时，您可以向其传递值，这些值被称为参数。这些参数可以在函数中使用您可以发送任意多的参数，由逗号 (,) 分隔：

myFunction(argument1,argument2)

您声明函数时，请把参数作为变量来声明：

function myFunction(var1,var2){代码}

<!DOCTYPE html>
<html>
<head> 
<meta charset="utf-8"> 
</head>
<body>
<p>本例调用的函数会执行一个计算，然后返回结果：</p>
<p id="demo"></p>

<script>
function myFunction(a,b){
	return a*b;
}
document.getElementById("demo").innerHTML=myFunction(4,3);
</script>

</body>
</html>

⚠️注意: 分号是用来分隔可执行JavaScript语句。由于函数声明不是一个可执行语句，所以不以分号结束尝试一下 »

函数很灵活，您可以使用不同的参数来调用该函数，这样就会给出不同的消息：

<!DOCTYPE html>
<html>
<head> 
<meta charset="utf-8"> 
<title>菜鸟教程(runoob.com)</title> 
</head>
<body>

<p>请点击其中的一个按钮，来调用带参数的函数。</p>
<button onclick="myFunction('Harry Potter','Wizard')">点击这里</button>
<button onclick="myFunction('Bob','Builder')">点击这里</button>
<script>
function myFunction(name,job){
	alert("Welcome " + name + ", the " + job);
}
</script>

</body>
</html>

根据您点击的不同的按钮，上面的例子会提示 "Welcome Harry Potter, the Wizard" 或 "Welcome Bob, the Builder" 尝试一下 »

函数表达式

JavaScript 函数可以通过一个表达式定义。函数表达式可以存储在变量中：

var x = function (a, b) {return a * b};

在函数表达式存储在变量后，变量也可作为一个函数使用

var x = function (a, b) {return a * b};
var z = x(4, 3);

以上函数实际上是一个 匿名函数 (函数没有名称)。函数存储在变量中，不需要函数名称，通常通过变量名来调用

命名函数

function x(a, b) {return a * b};

⚠️**注意: **命名函数也叫做函数声明

匿名函数

匿名函数不可以直接调用

//函数自调用
(function (name) {console.log(name) })("Ken")

//匿名函数当作参数被调用
myFunction("onClick",function () { })

自调用函数 (沙箱)

函数表达式可以自调用(IIFE), 自调用表达式会自动调用如果表达式后面紧跟 () ，则会自动调用

//第一种
(function () {
  console.log("Hello Word");
})();

//第二种
(function () {
  console.log("Hello Word");
}());

//第三种 在函数定义前加上“~”和“!”等符号来定义匿名函数
!function myalert(){
	console.log("Hello Word");
}()

~function myalert(){
	console.log("Hello Word");
}()

Function() 构造函数

在以上实例中，我们了解到函数通过关键字 function 定义。函数同样可以通过内置的 JavaScript 函数构造器（Function()）定义

var myFunction = new Function("a", "b", "c","return a * b ** c")
console.log(myFunction(2, 4, 3)) //128

实际上，你不必使用构造函数。上面实例可以写成：

var myFunction = function (a, b, c) { return a * b ** c }
console.log(myFunction(2, 4, 3)) //128

函数提升（Hoisting）

提升（Hoisting）是 JavaScript 默认将当前作用域提升到前面去的的行为提升（Hoisting）应用在变量的声明与函数的声明因此，函数可以在声明之前调用：

myFunction(5)
function myFunction(y) { return y * y }

myFunction(5) //报错:myFunction is not a function
var myFunction = function (y) { return y * y }

⚠️**注意: **使用表达式定义函数时无法提升

函数可作为一个值使用

JavaScript 函数作为一个值使用：

<html>
<body>
<p>函数可作为一个值：</p>
<p>x = myFunction(4,3) 或 x = 12</p>
<p>两种情况下，x 的值都为 12。</p>
<p id="demo"></p>

<script>
function myFunction(a, b) {
    return a * b;
}
var x = myFunction(4, 3);
document.getElementById("demo").innerHTML = x;
</script>

</body>
</html>

javaScript 函数可作为表达式使用：

function myFunction(a, b) {
    return a * b;
}

var x = myFunction(4, 3) * 2;

函数是对象

在 JavaScript 中使用 typeof 操作符判断函数类型将返回 "function" 但是JavaScript 函数描述为一个对象更加准确 JavaScript 函数有属性和方法 arguments.length 属性返回函数调用过程接收到的参数个数：

function myFunction(a, b) {
    return arguments.length
}

toString() 方法将函数作为一个字符串返回:

function myFunction(a, b) {
  return a * b;
}
var txt = myFunction.toString();
console.log(txt);

/* 
输出
function myFunction(a, b) {
  return a * b;
}
*/

箭头函数

箭头函数表达式的语法比普通函数表达式更简洁

(参数1, 参数2, …, 参数N) => { 函数声明 }

(参数1, 参数2, …, 参数N) => 表达式(单一)
// 相当于：
(参数1, 参数2, …, 参数N) =>{ return 表达式; }

当只有一个参数时，圆括号是可选的：

(单一参数) => {函数声明}
单一参数 => {函数声明}

没有参数的函数应该写成一对圆括号:

() => {函数声明}

// ES5
var x = function(x, y) {
     return x * y;
}
 
// ES6
const x = (x, y) => x * y;

有的箭头函数都没有自己的 this。不适合定义一个 对象的方法。当我们使用箭头函数的时候，箭头函数会默认帮我们绑定外层 this 的值，所以在箭头函数中 this 的值和外层的 this 是一样的箭头函数是不能提升的，所以需要在使用之前定义使用 const 比使用 var 更安全，因为函数表达式始终是一个常量如果函数部分只是一个语句，则可以省略 return 关键字和大括号 {}，这样做是一个比较好的习惯:

const x = (x, y) => { return x * y };

JavaScript 函数参数

JavaScript 函数对参数的值没有进行任何的检查参数分为函数显式参数(Parameters)与隐式参数(Arguments) 参数分为形参和实参

函数在定义时候括号里的变量叫形参

调用函数传入的值叫实参，实参可以是变量，可以是数值

参数规则

JavaScript 函数定义显式参数时没有指定数据类型 JavaScript 函数对隐式参数没有进行类型检测, 对隐式参数的个数没有进行检测

默认参数

ES5 中如果函数在调用时未提供隐式参数，参数会默认设置为： undefined 有时这是可以接受的，但是建议最好为参数设置一个默认值：

function myFunction(x, y) {
    if (y === undefined) {
          y = 0
    } 
}

//或者，更简单的方式：
function myFunction(x, y) {
  	//如果y已经定义(不会被自动转换成false),y||0 返回y, 因为y是true, 否则返回0, 因为undefined为false
    y = y || 0 
}

ES6 函数可以自带参数

function myFunction(x, y = 10) {
    return x + y
}
 
myFunction(0, 2) // 输出 2
myFunction(5);   // 输出 15, y 参数的默认值

函数显式参数(Parameters)

函数显式参数在函数定义时列出

functionName(parameter1, parameter2, parameter3) {
    // 要执行的代码……
}

隐式参数(Arguments)

函数隐式参数在函数调用时传递给函数真正的值

arguments 对象

JavaScript 函数有个内置的对象 arguments 对象, argument 对象包含了函数调用的参数数组。通过这种方式你可以很方便的找到最大的一个参数的值：


function findMax() {
  var i, max = arguments[0];
  if (arguments.length <= 1) return max;

  for (i = 0; i < arguments.length; i++) {
    if (arguments[i] > max) {
      max = arguments[i];
    }
  }
  
  return max;
}

x = findMax(1, 123, 500, 115, 44, 88);
console.log(x); //500

或者创建一个函数用来统计所有数值的和：

function sumAll() {
  var sum = 0;
  for (i = 0; i < arguments.length; i++) {
    sum += arguments[i];
  }
  return sum;
}

x = sumAll(1, 123, 500, 115, 44, 88);
console.log(x); //871

回调函数

函数可以作为参数使用，叫做回调函数

function method(callbackFn) { callbackFn()}
function fn() { console.log("这是函数2") }
method(fn)

通过值传递参数

在函数中调用的参数是函数的隐式参数 JavaScript 隐式参数通过值来传递：函数仅仅只是获取值。如果函数修改参数的值，不会修改显式参数的初始值（在函数外定义）隐式参数的改变在函数外是不可见的

通过对象传递参数

在JavaScript中，可以引用对象的值因此我们在函数内部修改对象的属性就会修改其初始的值。修改对象属性可作用于函数外部（全局变量）修改对象属性在函数外是可见的

JavaScript 函数参数

JavaScript 函数有 4 种调用方式

每种方式的不同在于 this 的初始化

函数中的对象与this的指向?

一般而言，在Javascript中，this指向函数执行时的当前对象 ⚠️注意: this 是保留关键字，你不能修改 this 的值

普通函数中的this是谁 ?        ----- window
对象.方法中的this是谁 ?       ----- 当前的实例对象
定时器方法中的this是谁 ?      ----- window
构造函数中的this是谁 ?        ----- 实例对象
原型对象方法中的this是谁 ?     ----- 实例对象

作为一个普通函数调用

function myFunction(a, b) {
    return a * b;
}
myFunction(10, 2);           // myFunction(10, 2) 返回 20

以上函数不属于任何对象。但是在 JavaScript 中它始终是默认的全局对象在 HTML 中默认的全局对象是 HTML 页面本身，所以函数是属于 HTML 页面在浏览器中的页面对象是浏览器窗口(window 对象)。以上函数会自动变为 window 对象的函数 myFunction() 和 window.myFunction() 是一样的：

function myFunction(a, b) {
    return a * b;
}
window.myFunction(10, 2);    // window.myFunction(10, 2) 返回 20

⚠️**注意: **这是调用 JavaScript 函数常用的方法，但不是良好的编程习惯全局变量，方法或函数容易造成命名冲突的bug

全局对象

当函数没有被自身的对象调用时 this 的值就会变成全局对象在 web 浏览器中全局对象是浏览器窗口（window 对象）该实例返回 this 的值是 window 对象:

function myFunction() {
    return this;
}
myFunction();  // 返回 window 对象

函数作为方法调用

在 JavaScript 中你可以将函数定义为对象的方法以下实例创建了一个对象 (myObject), 对象有两个属性 (firstName 和 lastName), 及一个方法 (fullName):

var myObject = {
    firstName:"John",
    lastName: "Doe",
    fullName: function () {
        return this.firstName + " " + this.lastName;
    }
}
myObject.fullName();     // 返回 "John Doe"

fullName 方法是一个函数。函数属于对象。 myObject 是函数的所有者 this对象，拥有 JavaScript 代码。实例中 this 的值为 myObject 对象测试以下！修改 fullName 方法并返回 this 值:

var myObject = {
    firstName:"John",
    lastName: "Doe",
    fullName: function () {
        return this;
    }
}
myObject.fullName();          // 返回 [object Object] (所有者对象)

使用构造函数调用函数

如果函数调用前使用了 new 关键字, 则是调用了构造函数。这看起来就像创建了新的函数，但实际上 JavaScript 函数是重新创建的对象：

// 构造函数:
function myFunction(arg1, arg2) {
    this.firstName = arg1;
    this.lastName  = arg2;
}
 
// This    creates a new object
var x = new myFunction("John","Doe");
x.firstName;    // 返回 "John"

构造函数的调用会创建一个新的对象。新对象会继承构造函数的属性和方法 ⚠️**注意: **构造函数中 this 关键字没有任何的值。this 的值在函数调用实例化对象(new object)时创建

作为函数方法调用函数

在 JavaScript 中, 函数是对象。JavaScript 函数有它的属性和方法 call() 和 apply() 是预定义的函数方法。两个方法可用于调用函数，两个方法的第一个参数必须是对象本身

function myFunction(a, b) {
    return a * b;
}
myObject = myFunction.call(myObject, 10, 2);   // 返回 20

function myFunction(a, b) {
    return a * b;
}
myArray = [10, 2];
myObject = myFunction.apply(myObject, myArray);  // 返回 20

两个方法都使用了对象本身作为第一个参数。两者的区别在于第二个参数： apply传入的是一个参数数组，也就是将多个参数组合成为一个数组传入，而call则作为call的参数传入（从第二个参数开始）在 JavaScript 严格模式(strict mode)下, 在调用函数时第一个参数会成为 this 的值，即使该参数不是一个对象。在 JavaScript 非严格模式(non-strict mode)下, 如果第一个参数的值是 null 或 undefined, 它将使用全局对象替代 **⚠️注意: **通过 call() 或 apply() 方法你可以设置 this 的值, 且作为已存在对象的新方法调用

JavaScript 函数返回值

有时，我们会希望函数将值返回调用它的地方。通过使用 return 语句就可以实现在使用 return 语句时，函数会停止执行，并返回指定的值

function myFunction(){
    var x=5;
    return x;
}

**⚠️注意: **整个 JavaScript 并不会停止执行，仅仅是函数。JavaScript 将继续执行代码，从调用函数的地方

声明变量接收函数调用的返回值：

//myVar 变量的值是 5，也就是函数 "myFunction()" 所返回的值
var myVar=myFunction();

即使不把它保存为变量，您也可以使用返回值：

document.getElementById("demo").innerHTML=myFunction();

在您仅仅希望退出函数时，也可使用 return 语句。返回值是可选的：

function myFunction(a,b){
    if (a>b) return;
    x=a+b
}