day04-函数 function

1.什么是函数

        函数用function修饰的一个代码块,这个代码块一般是抽取对应的功能代码形成对应的复用。在一定程度减少代码冗余。函数的核心的思想封装,封装完去让别人调用。

2.函数的分类

  1. 系统函数 属于系统的函数(属于global对象的函数的 alert() console.log() isNaN()...)
  2. 内置函数 属于对应的内置对象的函数 (Math.pow()...)
  3. 自定义函数 自己定义的函数(自己封装抽取的代码)

3.函数的创建(自定义的函数创建)

        a、匿名创建 (没有名字 不具备复用价值  声明就需要调用)

//匿名的 不具备复用 声明就需要调用
// function(参数,...){
//     对应的代码
// }
//自执行函数
(function(){
    console.log('hello')
})()

        b、具名函数 (有名字的函数 具备复用价值)

//具名函数
/* function 函数名(参数,...){
            执行的代码
        } */
function fn(){
    console.log('hello world');
}
fn()
//具名函数的第二种写法
var a = function(){
    console.log('你好');
}
//调用
a()

        c、函数对象创建 (使用new关键词)

//函数对象创建的方式 里面的参数是字符串
var fn1 = new Function('alert("123")')
fn1()

4.参数的传递

//传递参数
//计算俩数之和 在函数声明的时候他传递的参数是形参(变量名)(随便写 建议语义化)
function sum(a,b){
    console.log(a+b);
}
// 调用执行 传递的参数是实参 一定有对应的值
sum(1,2)
//new Function的方式传递参数
var sum1 = new Function('a','b','alert(a+b)')
sum1(1,2)

5.JavaScript的程序预编译过程

预编译过程属于编译之前做的事情 他会进行如下操作

  1. 优先编译function

  2. 优先编译变量(不会进行赋值操作的)

    console.log(a); //undefined
    // a() //报错 a 不是一个函数 预编译不会编译赋值操作
    //调用 方法名(实际的参数)
    fn()
    //具名函数
    /* function 函数名(参数,...){
                执行的代码
            } */
    function fn(){
        console.log('hello world');
    }
    //具名函数的第二种写法
    var a = function(){
        console.log('你好');
    }
    //调用
    a()
    //在JavaScript中程序运行有个预编译过程 
    //他会先去加载对应的方法 function修饰的方法 加载对应的变量 var修饰的变量(并不会优先编译赋值)

    练习:传入两个数 打印他们间最大的

    function max(number1,number2){
        if (typeof number1 != "number" || typeof number2 != "number") {
            // console.error('输入出错');
            //抛出新的错误
            throw new Error('输入出错') //当程序报错 底下的所有内容将不会再执行
        } 
        //比对最大值
        var maxValue = number1>number2?number1:number2
        console.log(maxValue)
    }
    max(1,2)//打印2

    练习:计算传入的数值是否是回文数值 是打印是回文 不是打印不是回文

    //计算传入的数值是否是回文数值 是打印是回文 不是打印不是回文
    //传入一个数值
    function isPalindrome(number1) {
        if (typeof number1 != "number") {
            //抛出新的错误
            throw new Error('输入出错') //当程序报错 底下的所有内容将不会再执行
        } 
        var x = number1
        if (number1 == 0) {
            console.log('当前是回文');
        } else if (number1 == 10) {
            console.log('不是回文');
        }
        var resve = 0
        //进行反转操作
        while (x > 0) {
            resve = resve * 10 + x % 10
            x = parseInt(x / 10)
        }
        //进行判断
        if (number1 == resve) {
            console.log('当前是回文');
        } else {
            console.log('不是回文');
        }
    }
    isPalindrome(11011)

6.return 关键词 和 抛出错误的区别(throw new Error())

        a.return 关键词只是结束当前的函数

        b.抛出错误是结束整个程序

7.return 关键词         

        return 译为返回 他是用于对应的函数中返回对应的数据的一个关键词 当你的数据返回了那么当前这个函数就没有意义了 所以当前这个函数再return后面的代码就不会再执行了

function 方法名(形参1,形参2,....){
	相关操作
	return 数据
}

练习:计算俩个数的和 将这个和返回

//return 后面的内容是不会执行的
function sum(n1, n2) {
    console.log('之前执行的')
    return n1 + n2
    console.log('之后执行的')
}
var result = sum(1, 2)
console.log(result)




// 当你没有return关键词 他也会返回对应的数据 他的返回是在程序执行完以后 返回的值undefined
function fn(){
    console.log('程序运行');
    return; //没有指定对应的数据 相当没有return 相当于将return关键词放在最后面
    console.log('结束');
}
console.log(fn());

 8.return 的特点

        a、他会结束对应的函数,在本身这个函数函数内容 执行了return后面的内容将不会再执行了

        b、我们一般在程序的结尾返回对应的数据

        c、也可以利用对应的retrun的特性帮助我们来对应的函数

function sum(number1,number2){
	//如果当前传递的数不是数值 那么就结束这个函数
	if(typeof number1 != 'number' || typeof number2 != 'number'){
		return
	}
	return number1+number2
}

 9.arguments 参数

         arguments是函数的里面的所有参数的集合,它是一个伪数组(具备数组特性 有下标 有length(长度))

        【注意】使用arguments来获取对应的值的时候 我们一般不写形参

function fn() {
    //所有的函数都具备arguments  arguments特殊的值里面包含所有的参数
    console.log(arguments)
    //获取arguments里面的参数的第一个 arguments[下标] 来获取对应的下标的值
    console.log(arguments[0]);
    //查询当前arguments的长度 arguments.length
    console.log(arguments.length);
}
//对应的下标从0开始 0表示第一个 最大值 对应的长度-1   length 当前的个数-1
fn(1, 2, 3, 4, 5)

练习:传入任意的数值来取出它的和

function sum(){
	//获取所有的参数 数值
	var result = 0
	//遍历arguments里面的所有的数值
	for(var i =0;i<arguments.length;i++){
		result += arguments[i]
	}
	return result
}
console.log(sum(1,2,3,4,5))

arguments使用的相关

  1. arguments通过[下标] 来返回对应的元素

  2. arguments的length属性表示传入参数的个数

10.函数的对应的运行过程

        gc回收机制 垃圾回收机制(垃圾回收机制 不能强制执行的 对应的运行机制)

gc的俩大回收机制

        引用计数法 (针对于引用数据类型的 有变量指向当前引用就给他+1 当这个变量不再指向它就-1 到0就回收了)

        标记清除法 (针对于值类型 有用yes 没有用 no 当你是no的时候就回收)

执行机制

        a.函数是在对应的方法执行栈上执行的

        b.打开代码空间拿出里面的代码进行执行

        c.当你执行完以后对应的gc就会把这个内容从执行栈上移走 对应的代码空间就会还原

11.作用域及作用域链

        一个变量的作用范围称为作用域,在全局声明的变量就是全局作用域,在函数内容声明的变量它的作用域就是局部作用域(仅在当前函数内可用 函数作用域)

var a = 10 //全局变量 全局作用域
function fn(){
 var a = 20 //局部变量 局部作用域
 console.log(a)  //20
}
console.log(a)  //10

        作用域链

                作用范围内容变量的查找,它是链式查找 从局部到全局。

                 没有被var关键词修饰的向外找对应的值,一层一层向上称为作用域链

//查找变量的过程 从局部到全局
var a = 10 //全局变量
var c = 50
var b = 60
function fn(){
    // console.log(a); //undefined
    console.log(a); //10
    // var a = 20; //局部
    a = 20; //全局的
    console.log(b);//60
    console.log(c);//undefined
    var c = b = 100;
    // console.log(a); //20
    // console.log(a); //20
    (function(){
        // console.log(a); //undefined
        console.log(a); //20
        // var a = 30 //局部
        console.log(b);//100
        console.log(c);//undefined
        var c = b = 200
        a = 30 //全局的
        // console.log(a); //30
        // console.log(a); //30
    })()
}
console.log(a); //10
fn()
console.log(a); //30
console.log(b);//200
console.log(c);//50

12.函数的嵌套

        函数是可以互相嵌套的

        [注意]在函数内部可以定义函数和调用的函数 函数内部不能调用优先级比自己要低的

function fn(){
	function fn1(){
		console.log('hello')
       //fn(3) //报错
	}
    function fn2(){
		console.log('hello')
        function fn3(){
			console.log('hello')
		}
	}
	fn1()
	console.log('world')
}
fn() //hello  world

13.事件驱动(利用对应的事件来调用对应的函数)

        简单的一个dom操作

        获取对应的dom元素

var 变量 = document.getElementById('对应的标签的id属性')

        给对应的变量添加点击事件

变量名.onclick = 处理函数

案列:

<div id='content'>点击</div>
<input type="text" id="myInput"> <button id="btn">点击按钮获取input显示的值</button>
<script>
    //获取对应的div 根据id获取
    var content = document.getElementById('content')
    //给对应的div添加事件 由事件触发的函数被称为事件驱动
    content.onclick = function () {
        alert('hello')
    }
    //1.获取按钮
    var btn = document.getElementById('btn')
    //2.给按钮添加点击事件
    function hello(){
        //3.在点击事件执行的函数里面获取对应的input的内容
        //3.1 获取input
        var myInput = document.getElementById('myInput')
        //3.2 再获取里面的内容 value属性 获取input的显示内容 也可以进行设置
        console.log(myInput.value);
    }
    btn.onclick = hello

14.递归

        递归属于一个对应的算法 所有的算法都是套路。递归能做所有循环能做的事情。

递归的三大要素 (O(logn))

  1. 找规律

  2. 找初始值 没有规律的已知条件

  3. 自己调用自己

练习:问第100个位置的值的什么 2 4 6 8 10 12 14 ... 当前值 = 上一个值 + 2

function fn(n){
	if(n == 1){ //没有规律的
		return 2
	}else{ //有规律的 自己调用自己
		return fn(n-1) + 2
	}
}
console.log(fn(100))

练习:1-100的所有偶数和

//2 6 12 20 30    2 + 4  6 + 6 上一个 + 位数*2
function fn1(n){
    if(n == 1){
        return 2
    }else{
        return fn1(n-1) + n * 2
    }
}
console.log(fn1(50));

练习:求对应的阶乘 5的阶乘 1 2 6 24

function fn(n){
	if(n == 1){
		return 1
	}else{
		return fn(n-1)*n
	}
}
fn(5)

练习:1 2 4 7 11 16 问第10位

function fn(n){
 if(n == 1){
 	return 1
 }else{
 	return fn(n-1) + n - 1
 }
}
fn(10)

练习:1 2 3 5 8 13 问第10位

function fn(n){
	if(n == 1){
	   return 1
	}else if(n == 2){
		return 2
	}else{
		return fn(n-2) +fn(n-1)
	}
}
fn(10)

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值