第四章.函数

公告

View Post

一、函数的的声明(创建)和调用

//1.函数的作用：代码的冗余，可以重复使用相同的代码

//2.函数的使用分分两步骤:1.声明函数 2.调用函数

//3.语法格式:

//第一种方式:用函数关键字来声明函数

function 函数名（）{

//函数体

}

注意：（1）function 声明函数的关键字一般都大写

（2）函数不调用自己不执行

//案列1：

//利用函数计算1-100之间的累加和

function getaSum(){

// 声明总的和

var sum=0;

//用for循环来遍历

for(var i=0;i<=100;i++){

//把遍历出来的加到总和里面

sum=sum+i;

}

//打印

console.log(sum);

}

//调用函数

getSum;

//第二种方式：函数的表达式（匿名函数）也带形参和实参

//语法结构：

var fun(fun表示变量名)=function（）{

}

fun();//变量名,后面接实参传递参数

注意：函数表达式声明方式跟声明变量差不多，

只不过变量里面存的是值而函数里面存的是函数

//形参是用来接收实参的

var fun = function (arr) {

console.log("我是函数");

console.log(arr)

}

fun('我是喜欢函数');

二、函数的形参和实参

//1.形参：在声明函数的小括号里面是形参（形式上的参数）

//2.实参：在函数调用的小括号里面是实参（实际上的参数）

语法结构：

//声明函数

function 函数名（形参1，形参2....）{

//函数体

}

//调用函数

函数名（实参1，实参2....）;

//案列1：

//利用函数求任意两个数的和

//声明函数

function getSum（start,end）{

var sum=0;

for(var i=star,i<=end;i++){

sum=sum+i;

}

consloe.log(sum);

}

//调用函数

getSum（1,166）;

//案列2：

//利用函数求任意两个数的和

function getSum(num1,num2){

console.log(num1+num2);

}

//调用函数

getSum(100,200);

三、函数的形参与实参匹配

function getSum(num1,num2){

console.log(num1+num2);

}

// 1.如果实参的个数和形参的个数一致则正常输入

getSum(1,2);

// 2.如果实参的个数多余形参的个数会取到形参的个数

getSum(1,2,3);

// 3.如果实参的个数小于形参的个数,多余的形参定义为undefined 最终结果就是NaN

getSum(1);

//4.建议实参和形参的个数相匹配

四、函数的返回结果

//函数的返回值格式

语法格式：

function 函数名（）{

return 需要返回的结果

}

函数名（）;

1.函数只是实现某种功能，最终的结果需要返回给函数的调用者通过return来实现

2.只要函数遇见return，就把后面的结果返回给函数的调用者函数名（）=return后面的结果

// 案列1：

function getResult（add）{

return add;

}

console.log(getResurt('世界真大，风景也很美'));

// 案列2：

利用函数求两个数的和

function getSu(num1,num2){

return num1+num2;

}

//调用函数

console.log(getSu(1,47)) ;

// 案列3：

//利用函数求任意两个数的最大值

function functionMax(num1,num2){

//通过if来判断

if(num1>num2){

return num1;

}esle{

return num2

}

//if-else简写为三元表达式

// return num1>num2 ? num1:num2;

}

console.log(functionMax(1,8));

// 案列4：

//利用函数求数组[100, 12, 222, 344, 56]中的最大值

function getMax(arr){

var max=[0];

//用for来遍历

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

//用if来判断

if(arr[i]>max){

max=arr[i];

}

return max;//只能返回一个值，返回多个值用数组来存储

}

//调用函数

//实例化

var re= getMax([100, 12, 222, 344, 56]);

console.log(re);

五.伪数组

// arguments作用

//1.当我们不确定有多少个参数传递的时候,可以用arguments来获取。

//2. arguments对象中存储了传递的所有实参.

// 3..arguments:存储了传递的所有实参,只有函数才有arguments对象，而起每个函数都有内置好的arguments

// 4..arguments伪数组,并不是真正的数组

// 5.arguments具有数组的长度length属性

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

function n() {

console.log(arguments);

// 具有数组特性,长度

console.log(arguments.length);

// 把第几个位置元素的值给他取出来

console.log(arguments[2]);

// 可以按照数组的方式遍历arguments

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

console.log(arguments[i]);

}

n(1, 2, 3);

n(1, 2, 3,4,5,6,7);

// 案列1：

//利用函数求任意两个数的最大值

//声明一个函数，不用带参数

function getMax（）{

//定义一个存储最大的值

var max=arguments[0];

//用for遍历这个伪数组

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

//用if来判断

if（max>arguments[i]）{

max=arguments[i];

}

//用return返回最大值

return max;

}

//调用并且打印这个返回值

console.log(getMax(1,2,3,5,67,77,88));

//案列2：

//利用函数封装的方法任意翻转 reverse翻转

//声明一个函数，带参数

function reverse(arr){

//创建一个新的空数组

var newArr=[];

//用for循环来遍历

for（var i=0;i<arr.length;i++）{

//把翻转过来的旧的数组存放在新的数组

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

}

//用return来返回值

return newArr

}

//调用这个函数

var arr1=reverse([1,3,4,5,6,7]);

consloe.log(arr1);

//案列3：

//利用函数冒泡排序 sort排序

//声明一个带参数的函数

function sort（）{

//用for外层循环来遍历

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

//用for里层循环来遍历

for(var j=0;j<arr.lenght-i-1;j++){

//比较两个是的大小，前一个比后一个大+1

if(arr[j]>arr[j+1]) {

//定义一个变量来交换

var temp;

var temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

//用return来返回值

return arr;

}

//调用函数并且打印return的值

var arr1=sort([45,66,7777,23,56,88]));

console.log(arr1)：

//案列4：

//要求：利用函数封装的方法实现

输入一个年份，判断是否是闰年（闰年：能被4整除并且不能被100整除，或者能被400整除）

//声明一个变量并且带参数

function isRunYear(year){

//如果是闰年我们返回true 否则返回false

//定义一个变量存储flag

var flag=false;

if判断条件是否满足如果满足就执行true 否则就执行false

if（year % 4===0 && year % 100 ！=0 || year % 400===0）{

flag=true；

}

//返回return

return flag;

}

//调用函数

console.log(isRunYear(2022));

六、函数可以相互调用

//1.函数可以互相调用

//2.函数不调用自己不执行

//声明第一个函数

function first1(){

console.log(666);

//调用第二个函数

frist2();

}

//声明第二个函数

function frist2(){

console.log(88);

}

//调用函数

frist1();

//案列1：

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

//如果是闰年，则2月份是29天，如果是平年，则2月份是28天

//声明函数

function backDay(){

var yeat=+（"请输入年份:"）;

//if里面的条件必须是true或者是false 如果是文字的话就不能识别文字

if（inRunYear）{

alert（"当前年份是闰年2月份有29天"）;

}esle{

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

}

//调用函数

backDay();

//案列2：

//判断是否为闰年的函数

function inRunYear(year){

如果是闰年我们就返回true 否则返回false

var flag=false;

//并且与或者的关系

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

var flag=true;

}

return flag;

}

//案列3：

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

// 如果是闰年,则2月份是29天,如果是平年,则2月份是28天

function backDay() {

var year = prompt("请输入年份");

// if 里面的条件必须是true或者是false 如果是文字的话不能识别文字

if (isRunYear) {//调用另一个函数

alert("当前年份是闰年2月份有29天");

} else {

alert("当前年份是平年2月份有28天");

}

backDay();

// 判断是否为闰年的函数

function isRunYear(year) {

// 如果是闰年我们返回true 否则返回false

var flag = false;

// 并且与或者的关系

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

var flag = true;

}

return flag;

}

七、函数的作用域与块级作用域

//（1）作用域：

//1.作用域：表示代码在某个范围内起作用,目的是提高程序的可靠性重要的是减少命名的冲突

//2.作用域分为：全局作用域局部作用域

// 全局作用域：整个javascript标签

var num=10;

console.log(num);

// 局部作用域（函数作用域）：在函数内部就是局部作用域这个代码的名字只在这个函数里面起作用

function fn() {

// 局部作用域

var num=20;

console.log(num);

}

fn();

//（2）变量作用

// 全局变量：只有浏览器关闭的时候才会销毁，比较占内存资源

// 局部变量：当我们程序执行完毕就会销毁，比较节约内存资源

//变量作用域：分为全局变量局部变量

// 1.全局变量：在全局作用域下的变量

// 注意：如果在函数内部,没有声明的变量直接赋值的变量也是全局变量

var num = 10;//num就是一个全局变量,在全局下都可以使用

console.log(num);

function fn() {

console.log(num);

}

fn();

// 2.局部变量：在局部作用域下的变量在函数内部的变量就是局部变量

// 注意：函数的形参也是一个局部变量

function fun() {

var num1 = 10;//num1就是局部变量，只能只在寒暑假内部使用

}

fun();

console.log(num1)

//（3）作用域链：

作用域链:(采用就近原则)内部函数访问外部函数的变重，采取的是链式查找的

方式来决定取那个值这种结构我们称为作

//案列1：

// 站在目标出发,一层一层的往外找

function f1() {//外部函数

var num = 123;

function f2() {//内部函数

console.log(num);

}

f2();

}

var num = 456;

f1();

//案列2：

var a = 1;

function fn1() {

var a = 2;

var b = '22';

fn2();

function fn2() {

var a = 3;

fn3();

function fn3() {

var a = 4;

console.log(a);

console.log(b);

}

fn1();

八、闭包函数

// 案列1：

//一个函数里面再定义一个函数，返回值市里面的函数，再函数的外部通过函数表达式的方式调用

function out() {

let a = 100, b = 50;

function inner() {

// 内层的行数返回的是a和b的和

return a + b;

}

//inner();再函数内部调用内部函数是可以的

// 外层返回的是inner()函数

console.log(inner);

return inner;

}

// 如何使用闭包,想要得到a+b的和

// out();

// inner();再函数外边调用函数内部函数是不可以的

//我想要再函数外部调用内部函数，获得内部函数的返回值，怎么办呢?

let getSum = out();//getSum===inner

console.log(getSum);

// 调用内部函数

let resurt = getSum();

console.log(resurt);

//案列2：

function out(a,b) {

function inner() {

// 内层的行数返回的是a和b的和

return a + b;

}

//inner();再函数内部调用内部函数是可以的

// 外层返回的是inner()函数

console.log(inner);

return inner;

}

// 函数外部定义两个变量

let num1=100,num2=50;

// 函数表达式方式获取函数

let result=out(num1,num2);

console.log(result());

// 修改外部变量

num1=999,num2=666;

console.log(result());

let result2=out(num1,num2);

console.log(result2());

//小结：闭包避免变量的污染

九、回调函数

//回调函数:方法的参数是一个函数，那么这个函数称为回调函数

//案列1：

let num1 = [11, 22, 33, 44, 55, 66, 77];

// 放大两倍

function gt(val) {

return val*2;

}

//缩小两倍

function lt(val) {

return val/2;

}

//自定义回调函数的方法

//将数组元素放大2倍 arr:数组 callBack:回调函数

function zhuScale(arr,callBack) {

// 创建一个空数组

let emptyArr = [];

for (let i = 0; i < arr.length; i++) {

emptyArr.push(callBack(arr[i]));

}

return emptyArr;

}

let resurt = zhuScale(num1,gt);

console.log(resurt);

//案列2：

// arr.forEach(function (index, item) {

// console.log(item);

// })

// // 排序

// arr.sort((a, b) => b - a)

// console.log(arr);

//案列3：

回调函数写到原型里面

//回调函数:方法的参数是一个函数，那么这个函数称为回调函数

let num1 = [11, 22, 33, 44, 55, 66, 77];

// 放大两倍

function gt(val) {

return val*2;

}

//缩小两倍

function lt(val) {

return val/2;

}

//自定义回调函数的方法

//将数组元素放大2倍arr:数组 callBack:回调函数

Array.prototype.zhuScale=function(callBack) {

// 创建一个空数组

let emptyArr = [];

for (let i = 0; i < this.length; i++) {

emptyArr.push(callBack(this[i]));

}

return emptyArr;

}

let resurt =num1.zhuScale(gt);

console.log(resurt);

//案列4：

回调函数实现数组的排序

let nums = [1,2,3,4,5];

console.log(nums);

// 排序方法,给数组

function myPaoPao(arr, callback) {

// 冒泡排序

for (let i = 0; i < arr.length - 1; i++) {

for (let j = 0; j < arr.length - 1 - i; j++) {

// 判断:降序

if (callback(arr[j+i],arr[i])>0) {

let temp;

temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

// 调用

myPaoPao(nums,(a,b)=>b+a);

console.log(nums);

、函数的返回值

●break :结束当前的循环体(如for, while )

●continue : 跳出本次循环,继续执行下次循环(如for, while )

●return :不仅可以退出循环,还能够返回return语句中的值,同时还可以结束当前的函数体内的代码

posted on 2022-10-04 21:58 青&&风阅读(28) 评论(0) 收藏举报

刷新页面返回顶部