函数
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很类似。