函数概述
用function修饰的一个代码块
函数实际是多行代码的抽取(多行代码会构成特定的功能)(方法)
函数的优点
代码的冗余(重复的代码放在函数里面 在需要的时候调用)函数封装(特定的一些代码使用函数来抱起来)
提高了代码的课维护性以及可阅读性
函数的分类
系统函数 window里面的所有函数都属于系统函数(console.log)alert()prompt()
内置函数 所有的内置对象里面的函数 都叫内置函数(Maht.pow())
自定义函数(自己定义的函数)
函数的创建(自己定义的函数)
1.匿名创建(没有名字 不具有复用价值)
(function(){
console.log("hello")
})()//自执行函数
2.具名函数(有名字的函数,具备复用性)
//具名函数
/* function 函数名(参数,...){
执行的代码
} */
functionfn(){
console.log('hello world');
}
fn()
//具名函数的第二种写法
vara=function(){
console.log('你好');
}
//调用
a()
3.函数对象创建 (使用new 关键词)
//函数对象创建的方式 里面的参数是字符串
varfn1=newFunction('alert("123")')
fn1()
参数传递
//传递参数
//计算俩数之和 在函数声明的时候他传递的参数是形参(变量名)（随便写 建议语义化）
functionsum(a,b){
console.log(a+b);
}
// 调用执行 传递的参数是实参 一定有对应的值
sum(1,2)
//new Function的方式传递参数
varsum1=newFunction('a','b','alert(a+b)')
sum1(1,2)
JavaScript的程序预编译过程
预编译过程属于编译之前做的事情 他会进行如下操作
优先编译function
优先编译变量（不会进行赋值操作的）
console.log(a);//undefined
// a() //报错 a 不是一个函数 预编译不会编译赋值操作
//调用 方法名(实际的参数)
fn()
//具名函数
/* function 函数名(参数,...){
执行的代码
} */
functionfn(){
console.log('hello world');
}
//具名函数的第二种写法
vara=function(){
console.log('你好');
}
//调用
a()
//在JavaScript中程序运行有个预编译过程
//他会先去加载对应的方法 function修饰的方法 加载对应的变量 var修饰的变量(并不会优先编译赋值)
练习
传入俩个数 打印他们间最大的
functionmax(number1,number2){
if(typeofnumber1!="number"||typeofnumber2!="number") {
// console.error('输入出错');
//抛出新的错误
thrownewError('输入出错')//当程序报错 底下的所有内容将不会再执行
}
//比对最大值
varmaxValue=number1>number2?number1:number2
console.log(maxValue)
}
max(1,2)//打印2
计算传入的数值是否是回文数值 是打印是回文 不是打印不是回文
//计算传入的数值是否是回文数值 是打印是回文 不是打印不是回文
//传入一个数值
functionisPalindrome(number1) {
if(typeofnumber1!="number") {
//抛出新的错误
thrownewError('输入出错')//当程序报错 底下的所有内容将不会再执行
}
varx=number1
if(number1==0) {
console.log('当前是回文');
}elseif(number1==10) {
console.log('不是回文');
}
varresve=0
//进行反转操作
while(x>0) {
resve=resve*10+x%10
x=parseInt(x/10)
}
//进行判断
if(number1==resve) {
console.log('当前是回文');
}else{
console.log('不是回文');
}
}
isPalindrome(11011)
return 关键词
return 译为返回 他是用于对应的函数中返回对应的数据的一个关键词 当你的数据返回了那么当前这个函数就没有意义了 所以当前这个函数再return后面的代码就不会再执行了
function 方法名(形参1,形参2,....){
相关操作
return 数据
}
示例
计算俩个数的和 将这个和返回
//return 后面的内容是不会执行的
functionsum(n1,n2) {
console.log('之前执行的')
returnn1+n2
console.log('之后执行的')
}
varresult=sum(1,2)
console.log(result)
// 当你没有return关键词 他也会返回对应的数据 他的返回是在程序执行完以后 返回的值undefined
functionfn(){
console.log('程序运行');
return;//没有指定对应的数据 相当没有return 相当于将return关键词放在最后面
console.log('结束');
}
console.log(fn());
return的特点
1、他会结束对应的函数，在本身这个函数函数内容 执行了return后面的内容将不会再执行了
2、我们一般在程序的结尾返回对应的数据
3、也可以利用对应的retrun的特性帮助我们来对应的函数
functionsum(number1,number2){
//如果当前传递的数不是数值 那么就结束这个函数
if(typeofnumber1!='number'||typeofnumber2!='number'){
return
}
returnnumber1+number2
}
return 关键词 和 抛出错误的区别（throw new Error()）
return 关键词只是结束当前的函数
抛出错误是结束整个程序
函数的对应的运行过程
gc回收机制 垃圾回收机制（垃圾回收机制 不能强制执行的 对应的运行机制）
gc的俩大回收机制
引用计数法 （针对于引用数据类型的 有变量指向当前引用就给他+1 当这个变量不再指向它就-1 到0就回收了）
标记清除法 （针对于值类型 有用yes 没有用 no 当你是no的时候就回收）
执行机制
函数是在对应的方法执行栈上执行的
打开代码空间拿出里面的代码进行执行
当你执行完以后对应的gc就会把这个内容从执行栈上移走 对应的代码空间就会还原
arguments
概述：arguments简介 arguments是函数的里面的所有参数的集合，它是一个伪数组（具备数组特性 有下标 有length（长度））
functionfn() {
//所有的函数都具备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)
示例
传入任意的数值来取出它的和
functionsum(){
//获取所有的参数 数值
varresult=0
//遍历arguments里面的所有的数值
for(vari=0;i<arguments.length;i++){
result+=arguments[i]
}
returnresult
}
console.log(sum(1,2,3,4,5))
使用arguments来获取对应的值的时候 我们一般不写形参
arguments使用的相关
arguments通过[下标] 来返回对应的元素
arguments的length属性表示传入参数的个数
作用域及作用域链
作用域概述：
一个变量的作用范围称为作用域，在全局声明的变量就是全局作用域，在函数内容声明的变量它的作用域就是局部作用域（仅在当前函数内可用 函数作用域）
vara=10//全局变量 全局作用域
functionfn(){
vara=20//局部变量 局部作用域
console.log(a)//20
}
console.log(a)//10
作用域链
作用范围内容变量的查找，它是链式查找 从局部到全局。
//查找变量的过程 从局部到全局
vara=10//全局变量
varc=50
varb=60
functionfn(){
// console.log(a); //undefined
console.log(a);//10
// var a = 20; //局部
a=20;//全局的
console.log(b);//60
console.log(c);//undefined
varc=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
varc=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
函数的嵌套
函数是可以互相嵌套的
functionfn(){
functionfn1(){
console.log('hello')
//fn(3) //报错
}
functionfn2(){
console.log('hello')
functionfn3(){
console.log('hello')
}
}
fn1()
console.log('world')
}
fn()//hello world
在函数内部可以定义函数和调用的函数 函数内部不能调用优先级比自己要低的
事件驱动（利用对应的事件来调用对应的函数）
简单的一个dom操作
获取对应的dom元素
var 变量 = document.getElementById('对应的标签的id属性')
给对应的变量添加点击事件
变量名.onclick = 处理函数
简单示例
<divid='content'>点击</div>
<inputtype="text"id="myInput"><buttonid="btn">点击按钮获取input显示的值</button>
<script>
//获取对应的div 根据id获取
varcontent=document.getElementById('content')
//给对应的div添加事件 由事件触发的函数被称为事件驱动
content.onclick=function() {
alert('hello')
}
//1.获取按钮
varbtn=document.getElementById('btn')
//2.给按钮添加点击事件
functionhello(){
//3.在点击事件执行的函数里面获取对应的input的内容
//3.1 获取input
varmyInput=document.getElementById('myInput')
//3.2 再获取里面的内容 value属性 获取input的显示内容 也可以进行设置
console.log(myInput.value);
}
btn.onclick=hello
</script>
递归
递归属于一个对应的算法 所有的算法都是套路。递归能做所有循环能做的事情。
递归的三大要素 (O(logn))
找规律
找初始值 没有规律的已知条件
自己调用自己
示例
问第100个位置的值的什么 2 4 6 8 10 12 14 ... 当前值 = 上一个值 + 2
functionfn(n){
if(n==1){//没有规律的
return2
}else{//有规律的 自己调用自己
returnfn(n-1)+2
}
}
console.log(fn(100))
练习
1-100的所有偶数和
//2 6 12 20 30 2 + 4 6 + 6 上一个 + 位数*2
functionfn1(n){
if(n==1){
return2
}else{
returnfn1(n-1)+n*2
}
}
console.log(fn1(50));
求对应的阶乘 5的阶乘 1 2 6 24
functionfn(n){
if(n==1){
return1
}else{
returnfn(n-1)*n
}
}
fn(5)
1 2 4 7 11 16 问第10位
functionfn(n){
if(n==1){
return1
}else{
returnfn(n-1)+n-1
}
}
fn(10)
1 2 3 5 8 13 问第10位
