javascript-函数

函数：就是封装一段可以被重复调用执行的代码块。通过此代码块可以实现可以实现大量代码的重复使用

声明函数本身并不是执行代码，只有调用函数时才会执行函数体代码

 

函数的封装：

• 函数的封装是把一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口
• 简单理解：封装类似于将电脑配件整合组装到机箱中（类似于快递打包）

函数用例

function getsum(num1, num2) {

var sum = 0;

for (var i = num1; i <= num2; i++) {

sum += i;

}

console.log(sum);

}

getsum(1, 100);

 

参数

行参和实参

function 函数名(实参1, 实参2等);//在函数调用的小括号里面是实参（实际的参数）

//形参和实参的执行过程

function cook(aru) {//形参是接受实参的 aru='玻璃海滩' 形参类似于一个变量

console.log(aru);

}

cook('玻璃海滩');

//函数的参数可以有，也可以没有个数不限

 

在声明函数时，可以在函数名称后面的小括号中添加一些参数，这些参数被称为形参

而在调用该函数时，同样需要传递相应的参数，这些参数被称为实参

 

形参：形式上的参数，函数定义的时候，传递的参数，当前是什么并不知道

实参：实际上的参数，函数调用的时候传递的参数 实参是传递给形参的

 

求两数和

function getsum(num1, num2) {

alert(num1 + num2)

}

getsum(1, 2)

求两数之间的和

function getsums(start, end) {

var sum = 0;

for (var i = start; i <= end; i++) {

sum += i;

}

alert(sum);

}

getsums(1, 100);

 

注：

• 如果实参的个数多于形参的个数，会取到形参的个数
• 如果实参的个数小于形参的个数，多余的形参定义为undefined，最终的结果就是NaN
• 形参可以看作是不用声明的变量，num2是一个变量但是没有接受值，结果就是undefined

return

function getresult() {

return 666;

}

alert(getresult());

求最大值

function getMax(num1, num2) {

return num1 > num2 ? num1 : num2;

}

max = getMax(1, 100);

alert(max);

求数组的最大元素值

function getArrMax(arr) {

var max = arr[0];

for (var i = 1; i <= arr.length; i++) {

if (arr[i] > max) {

max = arr[i];

}

}

return max;

}

alert(getArrMax([1, 2, 3, 4, 5, 6]));

 

注：

• return只能返回一个值，返回的结果如果是好几个值，那么只能返回最后一个值
• 函数没有return则返回undefined

arguments

实际上是当前函数的一个内置对象。所有函数中都内置了一个arguments对象，arguments对象中存储了传递的所有实参。

//arguments使用

function fn() {

console.log(arguments);

console.log(arguments.length);

for (var i = 0; i < arguments.length; i++) {

console.log(arguments[i]);

}

}

fn(1, 2, 3)

//伪数组 并不是真正意义上的数组

//1.具有数组的length属性

//2.按照索引的方式进行存储的

//3.他没有真正意数组的一些方法 pop（）朴实（）等

 

//任意个数的最大值

function getMax() {

var max = arguments[0];

for (var i = 1; i <= arguments.length; i++) {

if (max < arguments[i]) {

max = arguments[i];

}

}

return max

}

console.log(getMax(1, 2, 3));

console.log(getMax(111, 22, 31));

console.log(getMax(11, 222, 32));

 

//数组翻转

function reverse(arr) {

var newarr = [];

for (var i = arr.length - 1; i >= 0; i--) {

newarr[newarr.length] = arr[i];

}

return newarr;

}

var arr1 = reverse([1, 2, 3, 4])

console.log(arr1);

 

//封装冒泡排序

function sort(nums) {

for (var i = 0; i <= nums.length; i++) {

var temp = 0;

for (var j = i + 1; j <= nums.length; j++) {

if (nums[i] > nums[j]) {

temp = nums[i];

nums[i] = nums[j];

nums[j] = temp;

}

}

}

return nums

}

console.log(sort([5, 3, 1, 2]));

 

//判断是否为闰年

function isrunnian(year) {

//如果是闰年则返回true

var flag = false;

if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {

flag = true;

}

return flag;

}

console.log(isrunnian(2000));

 

//函数是可以相互调用的

function fn1() {

console.log(11);

fn2();

}

fn1();

function fn2() {

console.log(22);

}

 

//用户输入年份，输出当前年份2月份的天数

function backday() {

var year = prompt('请你输入年份：');

flag = isrunnian(year);

if (flag) {

alert('当前年份是闰年二月份有29天');

} else {

alert('当前年份是平年二月份有28天');

}

}

backday();

函数的两种声明方式

1. 利用函数关键字自定义函数（命名函数）
2. function fn() {

   
   

   }

   fn();
3. 函数表达式(匿名函数)
4. var 变量名 = function () { };

   var fun = function (aru) {

   console.log('我是函数表达式');

   console.log(aru);

   }

   fun('abc');

   //fun是变量名 不是函数名

   //函数表达式声明方式和声明变量差不多，只不过变量里面存的是值，

   //而函数表达式里面存的是函数

   //函数表达式也可以传递参数