JavaScript进阶

函数

 

1，普通函数
	function(args){
	
		}


2，匿名函数(顾名思义没有名字的函数)
	setInterval("function()", 5000)
	
	
	匿名函数：
	setInterval(function(){
		console.log('123');
	
	}, 5000)
	
	 
3，自执行函数（创建函数并自动执行）

	一般的函数需要定义，然后执行。
	function func(){
	
	}      #  
	//func()
	
	
	自执行函数：
	(function(args){
		console.log(args)
	})(1)
	

注意：自执行函数背景，之所以会有自执行函数，是因为当有大量第三方的插件时，会存在重名的函数从而造成冲突，而自执行函数则不管是否重名，都进行执行。

　　

序列化

　　JSON.stringify() 将对象转换为字符串
　　JSON.parse() 将字符串转换为对象

 

转义

decodeURI( )               		URl中未转义的字符
decodeURIComponent( )  		 	URI组件中的未转义字符
encodeURI( )                   	URI中的转义字符
encodeURIComponent( )   		转义URI组件中的字符
escape( )                       对字符串转义
unescape( )                     给转义字符串解码
URIError                        由URl的编码和解码方法抛出


客户端（cookie） => 服务端
将数据经过转义后，保存在cookie

　　

eval

python:
	val = eval(表达式)	# 执行不了逻辑代码（比如lambda表示式，for循环等无法执行），执行表达式有返回值，
	exec(执行代码)  　　# 可以执行复杂的逻辑代码，但是没有返回值。
	
JavaScript:
	eval（表达式或者代码） 是python中两种功能的合集

　　

时间

Date类

var d = new Date()

d.getxxxx  	获取
d.setxxxx	设置

　　

JavaScript作用域（必知必会）

1， *********************以函数作为作用域*****************

	其他语言：以代码块作为作用域(Java C#)
	
		public void Func(){
			if 1==1{
				string name = 'java'
			}
			console.writeline(name);
		}
		Func()
		//报错，'name'没有定义。其他语言为块级作用域
		
		
	python：
	
		情况一：
	
			def Func():
				name='tom'
			print(name)
			
			Func()
			
			//正常执行，python没有块级作用域。
		
		
		情况二：
		
		def Func():
				name='tom'
			print(name)
			
		Func()
		print(name)
		//报错，'name'没有定义。
		
		
	总结：其他语言是以块作为作用域，python和JavaScript是以函数作为作用域的。
	

		JavaScript:以函数作为作用域
			function Func(){
				if(1==1){
					var name = 'java';
				}
			
				console.log(name);
			}
			Func()
			//成功



2, **********************函数的作用域在函数未被调用之前就已经创建********************

		function Func(){
			if(1==1){
				var name = 'java';
			}
		
			console.log(name);
		}


3，**********************函数的作用域存在作用域链，并且也是在被调用之前创建**********

		xo = 'alex'
		function func(){
			xo = 'eric';
			function inner(){
				xo = 'tony';
				console.log(xo);
			}
			inner()
		}
		
		func()
		//输出: 'tony',遵循上述规则
		
		
		xo = 'alex'
		function func(){
			xo = 'eric';
			function inner(){
				console.log(xo);
			}
			return inner;
		}
		
		ret = func()
		ret()
		
		//输出为：'eric'
		
		其实上述函数就相当于执行inner(),函数内部要打印xo,作用域链一次为: xo='alex'--->xo='eric'，
		由内向外去找，所以结果显然为'eric'
		
		
		xo = 'alex'
		function func(){
			xo = 'eric';
			function inner(){
				console.log(xo);
			}
			xo = 'tony';
			return inner;
		}
		
		ret = func()
		ret()
		
		//输出为：'tony'
		
		
		分析：
		
		作用域链：
		
		1，首先执行最上面全局变量 xo='alex'
		2，接着，函数func（不执行）加载内存，
		3，开始执行ret=func()这一行，执行xo='eric'，inner（不执行）加载内存，再向下走，xo='tony',此时的xo将取代上面的xo='eric',
			然后返回inner函数
		4, 接着向下走执行，ret=func()，此时的ret为innner, ret(),表示要执行inner()，所以结果为'tony'

	
4，***************************函数内局部变量: 声明提前*******************************

		function func(){
			console.log(xo);
		}
		func)();
		// 程序直接报错
		
		
		
		function func(){
			console.log(xo);
			var xo = 'alex';
		}
		func)();
		// 输出为：undefined
		
		
		解释器在解释的过程中会找到所有的局部变量，执行var xo,相当于声明一个变量。
		所以当xo一直没有被赋值,所有会输出undefined。
		
		
		注意：这和上面的小例子之所以结果不同，注意执行流程。注意理解！！！

　　

 JavaScript面向对象

前奏：

	function foo(){
		var xo = 'alex';
	}
	foo()
	
	
	function Foo(n){
		this.name = n;   	#this就相当于python中的self,对象中封装的值为name
	}
	var obj = new Foo('we');		# 创建对象，创建对象前必须加new才表示创建对象，为固定用法。		
	obj.name
	



JavaScript面向对象：
	function Foo(n){
		this.name = n;
		this.sayName = function(){
				console.log(this.name)
			}
	}
	
	var obj1 = new Foo('we');
	obj1.name
	obj1.sayName()
	
	var obj2 = new Foo('wwe');
	obj2.name
	obj2.sayName()
	
	
	注意事项：
		1，this代指对象(python self)
		2，创建对象时用关键字： new 函数()
	
	
	
	由上可知：对象obj1,obj2都封装了方法sayName，造成了资源的浪费，下面来看看python中如何处理？



python面向对象：

	class Foo:
	def __init__(self, name):
		self.name = name
		
	def sayName(self):
		print(self.name)
		
	obj1 = Foo('we')
	obj2 = Foo('wwe')
	
	obj1,obj2分别只分装了name='we',name='wwe'。而方法sayName则保存在类中
	
	
	
下面开始对JavaScript进行改造：

原型：

	function Foo(n){
		this.name = n;
	}
	
	# Foo的原型
	Foo.prototype = {
		'sayName': function(){
			console.log(this.name);
		}
	}
	
	obj1 = new Foo('we')
	obj1.sayName()
	
	
	注意：prototype为固定用法
	执行流程：
	obj1 = new Foo('we')即首先通过类创建对象，name封装到对象中，第二步当执行obj1.sayName时，则会去类中的
	原型中去找，而不是去类中去找，因此减少了资源的浪费。注意：原型是放在类中的，这和python很类似。