前端学习--JavaScript基础(函数)

函数（function类型）

作用：处理重复代码

不会自己执行，需要调用函数名(); 如：fn()

Js自带的函数：isNaN() ; Number(); String(); parseInt(); parseFloat()…

自定义函数（方法）

//构造函数
function 函数名(){
	代码块

}
//调用函数
函数名();

类型

function num(){
    var a=1;
    var b=2;
	var c=a+b;
}
console.log(typeof(num)); //控制台显示function类型

赋值式函数

var a = function num(){
    var a=1;
    var b=2;
	var c=a+b;
    consol.log(c);
}
//里面的num不能被调用，可以不写，变成匿名函数。

匿名函数

// 没有名字的函数
var a = function(){
    var a=1;
    var b=2;
	var c=a+b;
    consol.log(c);
}

匿名函数调用（自调用函数）

（）起来函数才能独立存在，在后面在（）就可以调用，但是只能调用一次。

(function(){
    var a=1;
    var b=2;
	var c=a+b;
    consol.log(c);
})()

带参数的函数

函数中有些变量多次调用时需要发生变化，所以用形参。

//a,b是形参
function sun(a,b){
	var c=a+b;
	consol.log(c);
}
sum(1,2)	//c=3
sum()    //underfined;
sum(1,3,2)  //多出的参数无效

带返回值的函数（return）

调用函数的结果，更好的控制。

function sum(){
	return a+b;
}
console.log("1+2="+sum(1,2));

return后面的代码不执行；

没有return，输出underfined；

return 后面没有值，默认返回underfined。

构造函数

概念：当一个对象目的就是为了跟new配合创建对象的，这个函数就叫构造函数

function fn() {}

var f = new fn()
f.name = '小白'
console.log(f);

预解析

作用：教我们如何看懂代码。

JS执行过程：先预解析，在执行代码。

内容：先找到代码中定义的变量（赋值不会提前）和函数的变量(不包括赋值式函数)，然后把它们提升到所有代码最前面。

规则：

2、代码报错后，后面的代码不执行。
3、不能执行的代码中，如果有变量或函数的定义，也可以提升。
4、能提示的是变量的定义，而不是变量的赋值。
5、赋值式的函数，叫做变量的定义，不叫定义函数。

错误案例：

//var fn 提前
console.log(fn);
fn();  //fn报错不是一个function

var fn= faction(){
console.log(123);
}
输出 第一行console显示：underfined， fn报错不是一个function。

函数书写步骤：

1、先写好核心代码
2、把代码放在function里面
3、分析变量，那些是形参
4、分析其中那个数据需要调用函数后得到结果，将他作为返回值
5、调用，添加实参

作用域

概念：能起作用的区域

全局作用域：script标签内的是全局作用域

全局变量：在全局任何地方都可以使用

局部作用域：某个函数内部的区域

局部变量：只能在局部使用

作用域链

概念：由于作用域发生嵌套关系形成的链式结构。

<script>  //0级链
    var a=10;
    function one(){			//1级链
    	function two(){    		//2级链
        	function three(){		//3级链
            console.log(a)   			//a=10
        }
    }
}
    </script>

作用域链规则

规则1：找变量，从里到外，不能从外到里。

规则2：局部没变量，就去上一级去找没有就定义一个变量，在赋值；直到全局定义去找。

var a=10;
function sum(){      //函数里没有定义变量，去上一级寻找，找到定义a，所以把20赋值给a
	a=20;
}
sum()
console.log(a)  // a=20

递归

概念理解：在函数内部调用自己形成循环。我觉得就是自己循环自己（套娃）。

但是越简单的解释往往最难理解，我被搞得心太炸裂了。（可能是我脑子太笨了，转不过来吧）

写递归的步骤

1、分析题目，寻找递推关系。

2、定义一个函数并调用，传入实参；书写核心代码

3、给递归设置一个临界条件，结束循环。（不加临界条件，会陷入死循环，控制台报错,如下）

4、换参数

function a() {
    console.log();
    a()
}
a()

//给console.log(2) 会一直循环输出2

简单案例

1、求1-5的和

<script>   
function sum(a){
        if(a==0){		//临界条件，结束循环
            return 0
        }
        return a + sum(a-1)     //5+ 4  +3+2+1
    }
 var text=sum(5)
 document.write(text)
</script>   

2、求5的阶层

 function jiece(a){
        if(a==1){     //临界条件，结束循环
            return 1
        }
        return a * jiece(a-1)   //5* 4 → 5*4*3
}
var sum=jiece(5)
document.write(sum) 

3、斐波那契数列

1、1、2、3、5、8、13、21、34…

规律：这个数列从第3项开始，每一项都等于前两项之和。F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)

function fei(a){
    if(a==1){     //第一个为1
        return 1
    }if(a==2){      //第二个位1
        return 1
    }
        return fei(a-1)+fei(a-2)
}
var sum=fei(10)
document.write(sum)

/*改进
function fei(a){
    if(a==1 ||a==2){     //第一个为1     //第二个位1
        return 1
    }
        return fei(a-1)+fei(a-2)
}
var de=fei(10)
document.write(de)
*/

先简单记录点，我也没搞太明白，阿巴阿巴。

对象（object）

概念：复杂数据，在一个内存空间，存储多个小内存空间。(存放的是键值对)。

键值对：数据是由多个键和值组成的。

语法定义：

//方法一
var  a={

	键：值，

	键：值，

}

例子：

var people = {
    name: '小白',
    age: 23     // 尽量在最后一个键值对后面不要加逗号
}
console.log(people);

方法二

通过 new关键字定义，其中 Object是系统提供的一个函数.

var people = new Object()   //注意是一个空对象，需要添加键值对。
console.log(people)

对象内容操作

获取内容：people.name 或 people[name]
添加内容；people.name="小黑"  或 people[age]=100
删除内容：delete people.name  或   delete people[age]

对象的遍历

语法

对象的遍历语法：
for(var 变量名 in 对象) {
    变量名代表每个键
}

例子

for(var a in people){
    console.log(a);
    console.log( people.name );
    console.log(people.a);  // 有歧义,一般不应用定义的变量
    
      // console.log( obj[a] );
    // 当使用一个变量代表键的时候，必须使用[]语法来获取值
}
// 当获取一个对象并不存在的键对应的值，会获取到undefined

结尾

这几天都陷进去了，被逻辑运算、循环，函数搞得有点脑子不灵光了，感觉还是要花点时间啃得，先简单记录一下，和经典案例。我的文章就像笔记一样，可能不是很严谨，希望大家及时纠正我一起学习，冲冲冲。