JSDay2

函数
如何定义
c:
返回类型：函数名（形参列表）
{
函数体、
return；
}

js：
	指令式定义
	function 函数名（形参列表）{函数体}；
	
	表达式定义
	let 变量名=function(){};变量名指向匿名函数  匿名函数
	
	
		暂时性死区:
			let a=100;

			function add()
			{
				console.log(a);
				//上面会暂时性死区
				
				let a=200;//内部定义一个同名的变量
				console.log(a);
			}
			

	构造函数
	let 变量名=new Function(){}
	
	
函数名，在函数内部通过.name 可以访问；	
函数的参数，非必须，声明了参数可以不传，不声明参数可以传，参数的数量与存于的树龄可以不一致

arguments属性
函数内部的参数不依赖于形参类表，可以通过arguments来获取实际传入的参数
arguments不是数组，是一个长得像数组的对象
	let add =function()
	{
		console.log(arguments);
		console.log(arguments[1]);
	}

	add(12314,6);
	
	
let [a,b,c,d,e]=[1,2,3,4,5];


//rest
function add(...rest)//。。。扩展运算符
{
	console.log(rest);
}

add(a,b,c,d,e);


...扩展运算符
let arr1=[1,2,3],arr2=[4,5,6];
let arr3=(arr1.join('')+arr2.join('')).split('');
console.log(arr3);

//扩展运算符
let arr4=[...arr1,...arr2];
let arr5=arr1.concat[arr2];


function add2([a,b,c,d,e])
{
	
}
add2([1,2,3,4,5]);


作用域
	1，内部可以访问外部，外部不可以访问内部
	2，访问由内到外
	3，内外有同名变量，内部变量会优先访问，外部变量被隐藏
	
	
	let  a=200;
	let  b=300;
	function f()
	{
		b=400;//报错
		console.log(a);//undefine
		var a=100;
		console.log(b);
		//let 不能变量提升，之前都为b的死区
		let b=200;
	}
	f();

递归：

function Fibonacci(n)//产生一个调用栈
{
if(n<=2)
{
return 1;
}
else
{
return Fibonacci(n-1)+Fibonacci(n-2);
//等同于、
//let Fibonacci(n-1);
//let Fibonacci(n-2);
//return m+n；
}
}

console.log(Fibonacci(30));

//尾递归
function Fibonacci1(n,last=1,next=1)//产生一个调用栈
{
if(n<=2)
{
return next;
}
else
{
return Fibonacci1(n-1,next,last+next);//最后一项直接释放掉
//等同于、
//let Fibonacci(n-1);
//let Fibonacci(n-2);
//return m+n；
}
}

console.log(Fibonacci1(1000));

闭包：计数器困境（闭包可以解决全局变量计数）
1,在一个函数内部包裹另一个函数
2，内部函数能够记住他所处的环境
//闭包
function a()//a中的内存无法释放
{
let counter=0//计数的变量，不会对全局作用域造成污染
return function b()//有闭包的情况下，counter不会回收
{//function b为真正需要执行的函数，作为闭包返回
counter+=1;
console.log(counter);
}
}

		let excute=a();//由于excute内部存在闭包，所以执行完毕只有就被内存回收掉，导致counter 销毁
		excute();
		excute();
		excute();
		excute();

立即执行函数
let a=(function(){});
let p=function(){};

let f=(里面给一个function)(100)

One Interview Question
ver test =(function(a){
this.a=a;
return function(b){
return this.a+b;
}
}(function(a,b){
return a;
}(1,2)));

console.log(test(2));
//简化
let test= (function(a){
this.a=a;
return function(b){
return this.a+b;
}
}(1));
//简化
let test =(2,
return function(1){
return 2+1;
}
)

对象
狭义的对象 （实例）：
{key:value,key:value}
一对大括号包含的键值对的组合
坐标：
{x:100,y:100}
//键值对
{name:kk,age:30};

let point ={x:100,y:200}//最后一行不需要，号
多行建议加上对号

键名：
1，js解释器会将所有的键名解析为字符串
2，键名如果可以作为标识符存在，可以加引号，也可以不加
3，不符合标识符规则的必须要加上“ ”
4，数字键也可以作为属性名
let personalInfo={
name :1,
age:2,
$123:22,
[‘naem1’]:‘dadff’,
“3_5”:330,
123：333,
123.44：665,
}

console.table(personalInfo);//以表格的形式输出

对象可以先定义再添加属性
let obj={}
obj.name=‘zj’;
obj.age=66;
//如果不存在就会添加这个属性进去，如果没有会修改之前的数据
object[‘ss’]=22;
//以中括号必须打引号,取对象属性最安全的写法，什么样的情况都能够访问到

值： 可以是任何类型

对象的解构赋值
let point ={
x:100,
y:200,
}
es5写法
let width=point[“x”];
let height=point[“y”];

es6写法
let {“x”:width,“y”:height}=point;//创建的变量是width和height

let {x,y}=point;//Point的标识符为标准的标识符的时候
//当我们需创建一个与对象的属性名同名的变量时，可以简化解构赋值的写法
let {x,y}=vec;//等同于 let{x:x,y：y}=point

//ES6写法
function getPostion(){
let x=100,y=200,z=300;
return {x,y,z};
/return{
x:100,
y:200,
z:300
}ES5写法/
}

数据类型
原始的数据类型：number string boolen //传值
let a=1100,b=a;
b=11;
console.log(a,b)//传值

引用数据类型：对象（数组，键值对，函数）
let arr1=[1,2,3]
let arr2=arr1;
arr2[0]=111;
console.log(arr1);//节约内存
//都是数组的引用，操作同一个内存的空间

//怎么样copy一份，改变arr2时不改变arr

拷贝：
浅拷贝：一所房子，一把钥匙，赋值一把钥匙
深拷贝：房子和钥匙都拷贝一份
let obj1={x:100,y:200};
let obj2=obj1;//浅拷贝

for(let key in object){
obj2[key]=obj1[key]
}
obj2[“x”]=111；
cosnole.log(obj1,obj2);//深拷贝

//forEach
let arr=[1,2,[3,[4,5]],[6,7]];
function reduction(arr,target=[]){
arr.forEach(function(e){
if(e instanceof Array){
reduction(e,target)
}
else{
target.push(e);
}
}

)
return target;

}
console.log(reduction(arr));

let test_arr=reduction(arr);
let num_add=0
function xx(arr){
arr.forEach(function(e,index){
//console.log(e);
num_add+=e;
arr[index]=e*2;

}
)

}

xx(test_arr);
console.log(reduction(test_arr));
console.log(num_add);

for in
//for IN 循环Object

let obj={a:‘1’,b:‘2’,c:‘3’,d:‘4’};
for(let o in obj){
console.log(o);
console.log(obj[o]);
}

例题：将[1,2,[3,[4,5]],[6,7]]转为[1,2,3,4,5,6,7]
let arr=[1,2,[3,[4,5]],[6,7]];
function reduction(arr,target=[]){
arr.forEach(function(e){
if(e instanceof Array){
reduction(e,target)
}
else{
target.push(e);
}
}

)
return target;

}
console.log(reduction(arr));

自己的办法

let arr=[1,2,[3,[4,5]],[6,7]];

function change(str1){
let str=str1.toString();
console.log(str.split(","));
}

change(arr);

对象的成员函数内部的指向问题
函数内部如果有this，this始终指向调用该函数的对象
this.a=100;//windows对象
let obj={
a:200,
f:function()//函数时引用类型
{
return this.a;//指向调用的对象F
}
}
console.log(this.a,obj.f());//100,200
let g=obj.f;
console.log(this.a,g());//100,100

函数自身所处的作用域，函数定义时所在的作用域
function g(){
let m=100;
let f=function(){
return m+10;
}
return f;
}
let m=200;
let f=g();
let ff=function(){
return m+10
}
console.log(f(),ffo());
//函数优先访问最近的数据，如果没有才升到更高的

广义的对象
莫个类的实例
数组

继承

异步