前端笔记02

迭代器

forEach()

//迭代方法 forEach(function(value,index,arr){})
index 下标
value 数值
arr 原数组
	arr.forEach(function(value,index,arr){
		console.log(value+"---下标" + index + "---原数组" + arr);
	});

map() 映射

map(function(value,index,arr){})
	
	var result = arr.map(function(value,index,arr){
		return value * 2;
	});
	console.log(result);

every(每个) some(一些)

every(function(value,index,arr){})

#every 每一个都满足当前的条件才返回true#
var result = arr.every(function(item){
	return item % 2 == 0;
});
console.log(result);

#some 只要有一个条件成立就会返回true，否则返回false#
var result = arr.some(function(item){
	return item % 2 == 0;
});
console.log(result);

filter(过滤)：

​ 把当前符合条件的值返回，不符合条件的进行过滤

function(){}等同于()=>{}:
					使用一个箭头函数，当时一个值是可以省略，多个值必须添加小括号

arr.filter(function(item){
	return item % 2 ==0;
	//console.log(index);
});
console.log(result);

reduce (累加)

reduce((initValue,currentValue,index,arr)=>{})

初始值:initvalue 如果设置那第一个值就为初始值，如果不设置则为数组第一个值

arr.reduce((initValue,currentValue)=>{
	return initvalue + currentValue;
	console.log(initvalue,currentValue);
}, 10);
console.log(result);

问题:

​ 数组去重?

字符串转数组

var str = "hello world";
split();//把字符串转为数组
str.split();
console.log(str);

var num = [1,2,3,4];

reverse 翻转

var res = num.reverse();
console.log(res);

join连接:

​ 可以把数组变成字符串

var String = num + "";
var Str1 = num,join("***");
console.log(Str1);

var str = "你好"；
var str1 = str.split("");//转成一个数组
var str2 = str1.reverse();//数组翻转
var str3 = str2.join("");//将数组转为字符串
console.log(str3);

链式调用：
		通过连续点的方式进行调用
		str.split().reverse().join()

原型和原型链

 //面向对象
        function preson(name,age,love) {
        //属性
            this.name=name;
            this.age=age;
            this.love=love;
            //方法
            this.like = function() {
                console.log(this.name + this.age + this.love);
            };

            }
        var fn1 = new preson("张三",10,"打游戏");
        var fn2 = new preson("李四",10,"打游戏");
        console.log(fn1);
        consoe.log(fn2);

每个函数身上都有一个属性prototype(原型),并且有一个–proto–的指针指向下一级原型直到–proto–指针为null，形成的这个链条叫做原型链

constructor 构造器,特指向上一级构造函数

// var str = "你好,李焕英";
        // var str1 = str.split("");//转成一个数组
        // var str2 = str1.reverse();//数组翻转
        // var str3 = str2.join("");//将数组转为字符串
        // console.log(str3);


        //面向对象
        function preson(name,age,love) {
            //属性
            this.name=name;
            this.age=age;
            this.love=love;
            //方法
            // this.like = function() {
            //     console.log(this.name + this.age + this.love);
            // };

            preson.prototype.like = function() {
                console.log("爱好");
            }
            }
        var fn1 = new preson("张三",10,"打游戏");
            console.log(fn1.construction == preson);
            console.log(fn1.instanceoof == preson);


        // var fn2 = new preson("李四",10,"打游戏");
        // fn1.like();
        // console.log(fn1.__proto__.__proto__.__proto__);
        // // console.log(fn1);
        // consoe.log(fn2);


            class preson {
                construction(name,age) {
                    this.name=name;
                    this.age=age;
                    this.like = function(){
                        console.log("这是爱好");
                    };
                }
            }

全局环境 函数环境

js两个阶段:创建和执行阶段（生命周期）

console.log(a);//undefined
var a = 10;
window.a = 10;
console.log(a);

var a 在初始化阶段之定义未赋值
function 在创建阶段声明并赋值

b(x,y);
function b(x,y) {
	return x + y;
}

闭包（能够读取其他函数内部变量的函数）

​ 在执行上下文中,A函数中创建一个B函数,这个函数能够访问函数中A的变量

function a() {
	var name = "张三";
	var age = 18;
	return function() {
		console.log(name,age);
	};
}

this

局部:
	谁调用this，this指向谁
	var a = "1";
	console.log(a);
	
	function 

call apply bind 改变this 指针

​ call(obj,arg…)一个一个传递

​ apply(obj,[] ):数组的形式传递

​ bind(obj):返回一个函数，也是一个一个传递

var a = 20;
var obj = {
	a: 40
};
function fn() {
	console.log(this.a);
}
function fn(x,y) {
	console.log(this.x + this.y);
}
fn.call(obj);//call可以改变this指向



function sum(x,y) {
	console.log(this.a + x + y);
}
var obj = {
	a: 10
};
var fn = sum.bind(obj,10,10);
fn();


fn();//20
fn.call(obj);
var fn1 = fn.bind(obj);
fn1();

手写一个new

function _new() {
//创建一个新对象
let newObj = {};
//获取构造函数
console.log(arguments);

let Constructor = Array.prototype.shift.call(arguments);
[
	function person(name,age) {
		this.name = name;
		this.age = age;
	}
]
//连接新对象原型，新对象可以访问原型中的对象
newObj.__proto__ = Constructor.prototype;
//执行构造函数，即绑定this，并且为这个新对象添加属性
Constructor.apply(newObj,arguments);
//返回该函数
return newObj;
}
function person(name,age) {
this.name = name;
this.age = age;
}
var fn = new(person,"张三",12);
console.log(fn);