Js基础总结二

函数的定义与调用

定义一个绝对值函数 method(args){} 这里的args 在传入参数时没有限制，可以多个。

function abs(x) {
    if (x >= 0) {
        return x;
    } else {
        return -x;
    }
}

传一个参数

var abs1 = abs(-1);
console.log(abs1);

传多个参数， 只会获取第一个

var abs2 = abs(-898,'xxxx',-7777);
console.log(abs2);

function 传入的参数，会装在一个arguments 数组里面

function multiplyArgs(){
	var args=[];
	//输出传入进来的参数
	for(var i in arguments){
		args[i]=arguments[i];
	}
	console.log(arguments.length);
	console.log(args);
}
multiplyArgs(123,'ffewi',['a','b','c']);

变量/常量

主要是全局变量以及局部变量，和常量。

全局变量

var globalVar = 'this is globalVar';
function partVar(){
	var part1 = "just part variable";
	console.log("全局变量"+globalVar+"  局部变量"+part1);
}
partVar();
console.log("全局变量"+globalVar+"  局部变量"+'part1');//part1 is not defined

ES6标准引入了新的关键字const来定义常量，const与let都具有块级作用域 let 需要声明在{}中

const var1 = 3.14,var2='aa';
var1 = 3.88;//不可以修改了
var2 = 3.88;//必须在初始化时赋值
console.log(var1+"  "+var2); 
function letVar(){
	let v1;
	alert(v1);
	//let var3;//怎么无效
	if(true){
		let var3 = 3.88;
		alert(var3);
		console.log(var3);
	}
	
}
letVar();

方法

定义一个带方法属性的对象

var ffewi = {
	name:'ffewi',
	birth:1993,
	age:function(){
		var date = new Date().getFullYear();
		return date - this.birth;
	}
}
console.log("ffewi:["+ffewi.name+","+ffewi.birth+","+ffewi.age()+"]");

如果把function() 提到外边，效果不一样。

function getAge(){
	var date = new Date().getFullYear();
		return date - this.birth;
}
//此时 age :NaN  原因是 this对象获取不到ffewi的birth属性值
ffewi.age=getAge();

为什么：修改对象获取方式 function 调用时，没有对象进去，自动获取的windows对象 而windows.birth为undifined。

怎么解决：通过 apply(object,args[]) 修复对象丢失，同样的方法 还有 call(object,args1,args2,…)。

age = getAge.apply(ffewi,[]);
age = getAge.call(ffewi,null,null);

高阶函数

方法中传入参数带有函数进入，返回函数对象 如：

a , b 为数值参数，f为函数对象。

function add(a,b,f) {
	return f(a)+f(b)
}

function f(args){
	if(args<0)
		return -args;
	return args;
}

下面效果为绝对值相加。

var result = add(-123,-16,f);
console.log(result);

map/reduce filter sort

javascript自带有的高阶函数。

map

object.map(fun());

对于object里面的对象逐一进行fun() 如：

var arr1 = [1,3,5,7,9];
function pow2(args){
	//console.log(args);
	return args*args;
}
console.log("进行map函数之前："+arr1);//1,3,5,7,9
var catresult = arr1.map(pow2);// 1,9,25,49,81
console.log("进行map函数之后："+catresult);

reduce

object.reduce(fun());

对于object里面的对象进行两两fun() 如：

var arr2 = [1,2,3,4,5,6,7,8,9,10];
function sum(a,b){
	return a+b;
}
var sums = arr2.reduce(sum);
console.log("arr2:  "+arr2+" 里面elements total sum ： " +sums);

filter

将里面符合要求的过滤出来

var arr3 = ['A','C',33,'B',44,'894'];
var re3 = arr3.filter(function(a){return !isNaN(a)});
console.log(re3);

sort

sort 函数比较简单;

大概是这样的:

sort();

sort(function(){

//自己定义的比较回调函数，应该是这个意思

})

var arr4 = [1,7,5,67,8];
var re4 = arr4.sort();
console.log(re4);

arr4 = [1,3,5,967,8];
var re5 = arr4.sort(function(a,b){
	if(a>b){
		return 1;
	}else if(a<b){
		return -1;
	}else{
		return 0;
	}
	});
console.log(re5);

闭包

一个比较繁琐的函数问题， Ta使函数返回的值是函数。。。

闭包的使用 模拟面向对象 private成员。

function counter_timer(init){
	var x = init || 0;//保证不传值时初始化x=0
	return {
		inc: function (){
			x +=1;
			return x;
		}
	}
}
var ct = counter_timer();
console.log(ct.inc()+" 函数本身："+ct.inc);
console.log(ct.inc()+" 函数本身："+ct.inc);
console.log(ct.inc()+" 函数本身："+ct.inc);
//带初始值的
var ct1 = counter_timer(100);
console.log(ct1.inc()+" 函数本身："+ct1.inc);
console.log(ct1.inc()+" 函数本身："+ct1.inc);
console.log(ct1.inc()+" 函数本身："+ct1.inc);
console.log(('x' in ct1)+" "+ct1.x);

模拟一个x的n次方

function pown(x){
	return function(n){
		return Math.pow(x,n);
	}
}
var p = pown(2);
console.log(p(5));//2的5次方
var p1 =pown(3);
console.log(p1(3));//3的3次方
//可以这样输出哦
console.log("5'2次方=："+pown(5)(2));

一个用自然语言的命令玩法

定义：

初步分析了下 f为函数 x 为参数内容

zero()(var);

传入什么，返回什么

var zero = function(f){
	return function(x){
		return x;
	}
}

one(fun)(var);

定义一个函数fun，后面为函数的参数

var one = function(f){
	return function(x){
		return f(x);
	}
}

add(fun1, fun2);

两个函数操作:

返回fun2(fun)(fun1(fun)(var2));
–> fun1(fun)(var2) = var2;
–> fun2(fun)(var2);
则表示 fun1运行一次，fun2运行一次。
返回结果为fun2(f)(v)中f的返回值。

var add = function(n,m){
	return function(f){
		return function(x){
			return m(f)(n(f)(x))
		}
	}
}

console.log(zero()("初始值为0"));
(one(function (x){
	console.log(x);
}))("这里就是我要打印的东西，而且只打印了一次！");
var three = add(one,(add(one,one)));
console.log(three);

three(function (x){
	if(!x || x == 0){
		console.log("默认第一次打印，或者指定为0次打印！");
	}else
		console.log("这里就是我要打印的东西，而且这是"+x+"次打印了！");
	return (x || 1) + 1;
})(0);

Arrow Function（箭头函数）

箭头函数，顾名思义 可以用 =>来指定一个函数体 如：

方法 method= 参数 x => 指向函数运算 x*x。

var m1 = x => x*x;

var ob = (name,age,habits) => ({
	ffewi:{
		name:name,
		age:age,
		habits:habits
	}
});

//结果是一个对象 看起来是不是有点像java中的对象构造方法
var myself =ob('ffewi',23,['java','js','sql']);

//重写写toString
myself.toString=(function(){
	return "["+this.name+","+this.age+","+this.habits+"]";
}).apply(myself.ffewi);
console.log(myself.toString);

//其它方法
function toString1(){
	return "["+this.name+","+this.age+","+this.habits+"]";
};
//alert(toString1.apply(myself.ffewi,null));
console.log(ob('ffewi',23,['java','js','sql']));

来看看箭头函数的 this Ta指向的是调用者

定义一个箭头函数

var mthis = ()=>{
	if(this.bb!=null)
		alert(this.bb);
		return this.bb+"  [ffewi]";
	if(this.bb!=undefined)
		return this.bb='sdf';
};
var t1 ={
	name:'ffewi',
	bb:'ooooo',
	birth: 1990,
    getAge: function () {
        var b = this.birth; // 1990
        var fn = () => new Date().getFullYear() - this.birth; // this指向obj对象
        return fn();
    }
}
console.log(t1.getAge()+"  "+t1.bb);

generator（生成器）

generator（生成器）是ES6标准引入的新的数据类型。 一个generator看上去像一个函数，但可以返回多次。
声明方式 ： function* method(){}

斐波那契函数 1 1 2 3 5 8 13…

function* fb(max){
	var a=1,b=1,t;
	do{
		yield a;
		t=a+b;
		a=b;
		b=t;
	}while(max>=a)
	return a;
}
console.log(fb(60));
var arr =[];
for(var v of fb(55)){
	arr.push(v);
}
console.log(arr);