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

//正文

1.实参与形参个数可以有偏差，不会因为参数不统一而错误。

例1：

例2：

2.JS函数不能重载。

因为“函数重载”靠的就是相同函数名根据参数的不同，匹配特定函数，从而执行函数的过程；而JS函数不再排斥“异形”函数，缺失了辨别相同函数名的不同函数的过程，相同函数名的情况下，JS调用时，只会执行最后一个所调函数。

例3：

例4：

3.函数运用arguments对象，很有特点

arguments对象的使用，很好地解释了支持形参、实参不一致而不出错的原理性问题。

3.1 arguments[index]指定参数值，index为参数的索引

例5：

3.2 arguments.length得到参数的个数

例6：

3.3 arguments.length的扩展运用

例7：

4.一个显而易见的错误(只为下面说明问题)

看了例7，可能会有点迷糊，因而添加例8、例9，都说明了一个问题，参数为函数体提供必要信息，用于可控地实现功能。函数(function:功能)

例8：

例9：

简单比较例2、例4、例8，可以得出这样的结论，JS中的函数体与形参、实参以及形参与实参的关系是：

遵循一个原则：函数实现功能

函数体与形参关系：形参必须满足函数体的必要需求，否则没法进行，即使用了形参未定义的‘字面量’，出错：c is not defined 。

形参与实参关系：实参在形参的标尺下，多出的被拦截而被忽略，缺少的被判断为undefined(不存在)，但都不报错。

智能：是说JS函数对多出的实参去粗取精，对少的实参做了适当的处理，没有雷厉加之，使得函数运行更大限度地平稳协调。

C语言，函数形参与实参个数不一致问题

​ 最近阅读工程代码的时候，同一个函数，不同场景调用时，输入的实参个数不一样，但是编译却没有问题。查看函数的定义，相关的C文件里并没有给形参指定默认值，这就很奇怪了。

​ 最终，发现在函数相关的头文件里有给形参指定默认值。这就能解释通为什么形参和实参个数不一致，编译能正常通过的问题了。下面是示例代码。

/*parainput.c 文件内容*/

#include <stdio.h> 
void sum(int a,int b,int c)
{
	int result = a + b + c;
	printf("result = %d\n",result);	
} 

/*parainput.h 文件内容*/

#ifndef _PARAINPUT_H
#define _PARAINPUT_H

void sum(int a,int b=1,int c=2);

#endif

/*main.c 文件内容*/
#include <stdio.h>
#include "parainput.h" 

void test_01(void)
{
	int a = 10;
	sum(a);
	return;
}

void test_02(void)
{
	int a = 10,b = 20;
	sum(a,b);
}

void test_03(void)
{
	int a = 10,b = 20,c = 30;
	sum(a,b,c);
}
int main(void)
{
	test_01();
	test_02();
	test_03();
	
	return 0; 
}

**用G++**进行编译，最终运行结果如下。

result = 13
result = 32
result = 60

--------------------------------
Process exited after 0.006126 seconds with return value 0
请按任意键继续. . .

形参和实参

形参：形式参数，指的就是方法中定义的参数，是没有具体值的，存在的意义就是告诉调用者想要使用该功能就必须给到相应类型的值。

（例如：一个空位置上写着此处有人，实际上没有人）

实参：实际参数，指的是在调用某个方法时，传递的实际的具体的值。

（例如：想要比较两个数的大小，就要给两个具体的值）

public static void main(String[] agrs) {
		Max(5, 6);// 此时括号中的内容为实参 5，6是具体的值 是实参
		int a = 9; // 给a赋值
		int b = 3;// 给b赋值
		Max(a, b); // 此时的a和b是已经有了具体的值，是实参
		int x = 7; // 给x赋值
		int y = 8; // 给y赋值
		Max(x, y); // 此时的x和y已经有了具体的值，是实参
	}

	/**
	 * 求两个数的最大值
	 * 
	 * @param x 此时定义的参数x为形参 没有具体的值
	 * @param y 此时定义的参数y为实参 没有具体的值
	 */
	public static void Max(int x, int y) {
		if (x > y) {
			System.out.println(x);
		} else {
			System.out.println(y);
		}
	}

参数类型转换

小类型转大类型的可以，大类型转小类型需要强制转换，否则编译失败

小类型转大类型
   public static void main(String[] agrs) {
		byte a=9;  //定义一个byte类型
		int  b=7;  //定义一个int类型
		Max(a,b);  //byte类型给int给类型传值为小转大可以
	}

	/**
	 * 求两个数的最大值
	 * 
	 * @param x int类型的参数
	 * @param y int类型的参数
	 */
	public static void Max(int x, int y) {
		if (x > y) {
			System.out.println(x);
		} else {
			System.out.println(y);
		}
	}
-------------------------------------------------------------------------
大类型转小类型
    public static void main(String[] agrs) {
		int a = 9; // 定义一个int类型
		int b = 71; // 定义一个int类型 ，
		Max((byte) a, (byte) b); // int类型给byte给类型传值为大转小步可以，需要将int类型强制转换成byte类型
	}

	/**
	 * 求两个数的最大值
	 * 
	 * @param x byte类型的参数
	 * @param y byte类型的参数
	 */
	public static void Max(byte x, byte y) {
		if (x > y) {
			System.out.println(x);
		} else {
			System.out.println(y);
		}
	}