js获取web上下文

❶ vue使用require.context,动态变量怎么办

在日常的功能练习和调试过程中，需要一个demo项目进行功能测试，由于频繁.vue页面的同时，又要再router.js文件里面注册路由，感觉有点无聊和枯燥。基于此出发点，考虑能否自动读取文件夹下的文件进行路由注册。

借鉴拍纤思路：
参考vue的功能基础组件的自动化全局注册，看到一个require.context方法，可以读取某个文件夹下的文件信息。因此考虑，使用这个方法，获取views文件夹下的.vue页面，文件夹名称作为路由名称

require.context的使用介绍：

一个webpack的api,通过执行require.context函数获取一个特定的上下文,主要用来实现自动化导入模块,在前端工程中,如果遇到从一个文件夹引入很多模块的情况,可以使用这个api,它会遍历文件夹中的指定文件,然后自动导入,使得不需要每次显式的调用import导入模块

页面代码：
如下图示，views文件夹下的内容，都需要进行路由注册。

文件的路径有2种，（1）简单的vue功能页面，直接挂在views文件夹下；（2）复杂的页面，在views下在新建文件夹进行处理。

目前需要自动注册的路由页面，是针对“直接挂在views文件夹”下的页面。（因为views下的二级页面，暂时没有想到好的方案）



router/index.js页面代码
心路历程：

（1）一开袭渣仿始的想法，是想着用数组对象的方式定义好，路由名称和引入的路径地址，但是觉得还是不够自动化，新建.vue文件的时候还是需要手动添加；

（2）后来想到用使用require.context方法得到fileName，然后根据字符串裁减和拼接，得到我所需的url和文件相对路径；

例如： component: () =>import(【变量】)，但是后来发现，import()里面，不能使用变量!!!!!!!!!

原因：根据es6mole语法，由于import是静态执行，所以不能使用表达式和变量这些只有在运行时才能得到结果的语法结构。
（3）由由于import的使用限制，不能动态使用() =>import的语法，因此在考虑，能否直接替换掉这种异梁冲步加载引入的写法。经过分析，得出pathConfig字段里面有一个属性的内容，是指定的vue页面的default模块内容。经测试，可以使用。

pathConfig的打印内容如下示：



（4）因此“views”文件夹下的".vue"文件，引入成功，并用变量routerAry存储起来，使用concat方法把其他需要手动注册的路由信息，连接起来，进行路由注册。

❷ iOS - OC 与 JS 交互六种方式总结

在 APP 中，免不了与 H5页面打交道，所以掌握 与 JS 交互就显的至关重要，本文总结了常见的与 JS 交互方式。

注意事项

在 OC 原生中

在 html 文件中

早期的JS与原生交互的开源库很多都是用得这种方式来实现的，例如：PhoneGap、 WebViewjavascriptBridge 。

效果图

使用WKNavigationDelegate中的代理方法，拦截自定义的 URL 来实现 JS 调用 OC 方法。

注意点

关于如何区分执行不同的OC 方法，也与UIWebView的处理方式一样,通过URL 的host 来区分执行不同的方法：

JS 调用OC 方法后，有的操作可能需要将结果返回给JS。这时候就是OC 调用JS 方法的场景。
WKWebView 提供了一个新的方法 evaluateJavaScript:completionHandler: ，实现OC 调用JS 等场景。

注意点

运行结果

在iOS 7之后，apple添加了一个新的库JavaScriptCore，用来做JS交互，因此JS与原生OC交互也变得简单了许多。

首先导入JavaScriptCore库, 然后在OC中获取JS的上下文。

再然后定义好JS需要调用的方法，例如JS要调用share方法：
则可以在UIWebView加载url完成后，在其代理方法中添加要调用的share方法：

OC 调用 JS 方法有多种，首先介绍使用JavaScriptCore框架的方式。

使用JSContext 的方法 -evaluateScript ，可以实现 OC 调用 JS 方法

效果图

使用WKWebView的时候，如果想要实现JS调用OC方法，除了拦截URL之外，还有一种简单的方式。那就是利用WKWebView的新特性MessageHandler来实现JS调用原生方法。

创建 WKWebViewConfiguration 对象，配置各个API对应的MessageHandler。

然后在界面即将显示的时候添加MessageHandler

需要注意的是addScriptMessageHandler很容易引起循环引用，导致控制器无法被释放，所以需要移除MessageHandler

这里实现了两个协议 <WKUIDelegate,WKScriptMessageHandler> ， WKUIDelegate 是因为我在JS中弹出了alert 。 WKScriptMessageHandler 是因为我们要处理JS调用OC方法的请求。

WKScriptMessage 有两个关键属性 name 和 body 。
因为我们给每一个OC 方法取了一个name，那么我们就可以根据name 来区分执行不同的方法。body 中存着JS 要给OC 传的参数。

关于参数body 的解析，我就举一个body中放字典的例子，其他的稍后可以看demo。
解析JS 调用OC 实现分享的参数：

message.boby 就是JS 里传过来的参数。我们不同的方法先做一下容错性判断。然后正常取值就可以了。

下面只列举一个shareClick()方法，其他看Demo

这里使用WKWebView 实现OC 调用JS方法与之前说的文章一样，通过
- evaluateJavaScript:completionHandler:

效果图如下图所示

详情看下面文章链接
iOS下 JS 与 OC 互相调用(五) - UIWebView+WebViewJavascriptBridge

详情看下面文章链接
iOS下 JS 与 OC 互相调用(六) - WKWebView+WKWebViewJavascriptBridge

iOS下 JS 与OC 互相调用(一) - UIWebView 拦截 URL
iOS下 JS 与OC 互相调用(二) - JavaScriptCore
iOS 下 JS 与 OC 互相调用(三) - WKWebView 拦截 URL
iOS下JS与OC互相调用(四)-MessageHandler
iOS下 JS 与 OC 互相调用(五) - UIWebView+WebViewJavascriptBridge
iOS下 JS 与 OC 互相调用(六) - WKWebView+WKWebViewJavascriptBridge

❸ 什么是JS

您好，非常荣幸能在此回答您的问题。以下是我对此问题的部分见解，若有错误，欢迎指出。展开全部
JavaScript是个脚本编程语言,支持Web应用程序的客户端和服务器端构件的开发.在客户端,它用於编写Web浏览器在Web页面上下文中执行的程序,在服务器端,它可用於编写用於处理Web浏览器提交的信息并相应地更新浏览器显示的页面。在前面介绍HTML时,我们曾经讲到如果想要实现更多的互动网页,就要在客户端和服务器端对数据进行处理,而对於客户端的处理主要是配合客户端网页技术的Script语言,它在设计网页时扮演的角色
◆动态网页:JavaScript能够开发与用户双向互动的功能,因为不需要将数据在客户端和服务器间来回传递,在速度上拥有即时的反应效果,因为程序直接在浏览器执行。
◆表单处理与验证:作为表单栏位的验证,检查表单栏位是否输入错误。
◆浏览器对象:直接使用浏览器对象,建立复杂的网页内容,例如:打开新窗口载入网页。当然利用JavaScript我们还可以制作出各种个样的图片,文字,鼠标,动画和页面的效果,甚至还 可以做各种客户端的小游戏呢!JavaScript可以插入到HTML文件内进行制作。若想使用JavaScript，应通过下面的格式将其插入HTML文件。 JavaScript代码
◆LANGUAGE:设定Script语言的种类。若为JavaScript,则填写JavaScript;若为VBScript,则填写VBScript。
◆SRT:设定包含路径的文件名,例如"C:/JScript/test.js"。Script标记可以放在HTML文档的head或body中,多数情况下,最好把Script标记放在文档头部,以确保脚本中的所有JavsScript定义均在文档主体之前。
◆JavaScript的说明语句使用了类似C++和JAVA的语法,"//"表示说明直到行尾,"/*"和"/*"表示其中的内容为说明信息。通过JavaScript不仅可以向Document对象写入简单文本,也可以用JavaScript生成在当前文档中显示的HTML元素。JavaScript和其它编程语言一样,用变量存放数值.变量可以在程序其他部分使用。变量名可以用大写字母(A-Z),小写字母(a-z),和下划线开头,其余的字符可以使用字母,下划线或数字,变量名是区分大小写的。与其他语言不同的是,JavaScript并不要求指定变量中包含的数据类型(甚至无法指定)。事实上，JavaScript能够自动识别所输入的数字或符号，所以在JavaScript中，不需设定数据类型。但另一方面,由於JavaScript自动完成不同类型之间的转换,所以一定要跟踪变量的数值类型,及其变量表达式中的转换过程。
JavaScript支持以下四种基本数值类型。整数：表示整数的方法有10进制,8进制和16进制。就一般使用的数值而言，16进制是指0-15的数值,在JavaScript中,在其前面加"0x",标志其为16进制,8进制是在0-7前面加"0"。 浮点数：表示小数,很大的数或极小数,也可以是要用指数计数表示的数。表示较大数值时，可用E表示指数。 字符串：字符串被双引号("")或单引号(')标识后加以使用。双引号中或单引号中的数字不作为数字而作为字符串使用。因此这些数字不能参加计算。NaN：NaN即'Not a Number'表示是非数字的含义。在JavaScript内使用内置函数或错误字符串时,将会返回NaN这一特殊值。 Null：Null是指JavaScript内使用了空值。没有声明的变量，或者没有赋予任和值的变量就会返回Null值。它与数值0和空字符串("")有所区别。
除了前面介绍的基本类型外,JavaScript还支持两个复杂类型的变量,数组和对象,它们是用基本字符串,数字和逻辑类型构造起来的。 数组：数组是能够存放一序列数值的对象，这些数值存放在数组的索引位置中。例如：可以用数组存放公司员工的资料，要在Web页面上显示员工姓名,可以用数组名跟踪员工姓名。非常感谢您的耐心观看，如有帮助请采纳，祝生活愉快！谢谢！

❹ Web前端学习之Javascript继承的常用4种方法

今天小编要跟大家分享的文章是关于Javascript继承的常用4种方法。相信很多学习web前端开发技术的小伙伴在学习前端开发的javascript部分的时候，在面向对象的部分就很难走下去了，主要的原因还是逻辑更加复杂了，需要理解的内容比直观的开发布局难一点。

在面向对象编程里，封装和继承是比较重要的，这中间，薯链手继承是相对而言比较难理解的，因为javascript的继承方式比较多，也有不同的优缺点。今天小编为大家带来这篇文章就是来和大家一起说一说Javascript继承的常用4种方法，希望能够对你有所帮助。


1、原型链继承


核心：将父类的实例作为子类的原型


缺点：父类新增原型方法/原型属性，子类都能访问到，父类一变其它的都变了

2、构造继承


基本思想


借用构造函数的基本思想就是利用call或者apply把父类中通过this指定的属性和方法复制(借用)到子类创建的实例中。


因为this对象是在运行时基于函数的执行环境绑定的。也就是说，在全局中，this等于window，而当函数被作为某个对象的方法调用时，this等于那个对象。


call、apply方法可将一个函数的对象上下文从初始的上下文改变为由thisObj指定的新对象。


所以，这个借用构造函数就是，new对象的时候(new创建的时候，this指唤昌向创建的这个实例)，创建了一个新的实例对象，并且执行Parent里面的代码，而Parent里面用call调用了Person，也就是说把this指向改成了指向新的实例，所以就会把Person里面的this相关属性和方法赋值到新的实例上，而不是赋值到Person上面,所以所有实例中就拥有了父类定义的这些this的属性和方法。


因为属性是绑定到this上面的，所以调用的时候才赋到相应的实例中，各个实例的值就不会互相影响了。


核心：使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类(没用到原型)


缺点：方法都在构造函数中定义，
只能继承父类的实例属性和方法，不能继承原型属性/方法，无法实现函数复用，每个子类都有父类实例函数的数嫌副本，影响性能

3、组合继承


组合继承(所有的实例都能拥有自己的属性，并且可以使用相同的方法，组合继承避免了原型链和借用构造函数的缺陷，结合了两个的优点，是最常用的继承方式)


核心：通过调用父类构造，继承父类的属性并保留传参的优点，然后再通过将父类实例作为子类原型，实现函数复用


缺点：调用了两次父类构造函数，生成了两份实例(子类实例将子类原型上的那份屏蔽了)

4、寄生组合继承


核心：通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点


缺点：堪称完美，但实现较为复杂

以上就是小编今天为大家分享的关于web前端学习之Javascript继承的常用4种方法的文章，希望本篇文章能够对正在学习web前端技术的小伙伴们有所帮助。想要了解更多web前端知识记得关注北大青鸟web培训官网。


文章转载自公众号：前端研究所

❺ js上下文传递

functionFUNC(){}
FUNC.prototype={
	show:function(obj){
闹缓液或模//==============在这里如何获得invoker对象的引用？============
		//obj为当前invoker对象的引用
	}
};
varf=newFUNC();

functionINVOKER(){}
INVOKER.prototype={
	invoke:团纤function(){
		f.show(this);
	}
};
varinvoker=newINVOKER();
invoker.invoke();

❻ webView换成WKWebView后，js注入self.jsContext应该怎么处理才行

-(void)webView:(WKWebView *)webView didFinishNavigation:(WKNavigation *)navigation
{
// 设置javaScriptContext上下文
self.jsContext = [webView valueForKeyPath:@"documentView.webView.mainFrame.javaScriptContext"];
self.jsContext[@"ios"] = self; self.jsContext.exceptionHandler = ^(JSContext *context, JSValue *exceptionValue) {
context.exception = exceptionValue; NSLog(@"异常内信容息：%@", exceptionValue);
};

}

❼ 通过javascript执行链获取上下文对象

一、介绍

本篇继上一篇深入理解js执行--单线程的JS，这次我们来深入了解js执行过程中的执行上下文。

本篇涉及到的名词：预执行，执行上下文，变量对象，活动对象，作用域链，this等

二、预执行

在上一篇说到，在js代码被执行，执行上下文会被压进执行栈中，但是在此之前还有一步工作要做，就是创建好执行上下文，因为创建好才能被压进去啊。

创建执行上下文就是预执行过程：接下来说说创建执行上下文的细节部分。

三、创建执行上下文

（1）执行上下文组成

执行上下文：也叫一个执行环境，有全局执行环境和函数执行环境两种。每个执行环境中包含这三部分：变量对象/活动对象，作用域链，this的值

代码模拟

//可以把执行上下文看作一个对象exeContext = {
VO = [...], //VO代表变量对象，保存变量和函数声明
scopeChain = [...]; //作用域链
thisValue = {...}; //this的值}

创建执行上下文就是创建变量对象，作用域链和this过程

接下来就分别细说创建变量对象/活动对象，作用域链，this值的过程。

（2）变量对象(variable object)

变量对象中存储了在上下文（环境）中定义的变量和函数声明

创建变量对象（VO）时就是将各种变量和函数声明进行提升的环节：

//用下面代码为例子console.log(a);console.log(b);console.log(c);console.log(d);var a = 100;
b = 10;function c(){};var d = function(){};

上述代码的变量对象：

//这里用VO表示变量对象VO = {
a = undefined; //有a，a使用var声明，值会被赋值为undefined
//没有b，因为b没用var声明
c = function c (){} //有c，c是函数声明，并且c指向该函数
d = undefined; //有d，d用var声明，值会被赋值为undefined}

解说：执行上述代码的时候，会创建一个全局执行上下文，上下文中包含上面变量对象，创建完执行上下文后，这个执行上下文才会被压进执行栈中。开始执行后，因为js代码一步一步被执行，后面赋值的代码还没被执行到，所以使用console.log函数打印各个变量的值是变量对象中的值。

在运行到第二行时会报错（报错后就不再执行了），因为没有b（b is no defined）。把第二行注释掉后，再执行各个结果就是VO里面的对应的值。

讲到这里我想大家对变量对象理解了吧，以及对变量提升和函数提升有个深入了解。

（3）活动对象（activation object）

活动对象是在函数执行上下文里面的，其实也是变量对象，只是它需要在函数被调用时才被激活，而且初始化arguments，激活后就是看做变量对象执行上面一样的步骤。

//例子function fn(name){ var age = 3; console.log(name);
}
fn('ry');

当上面的函数fn被调用，就会创建一个执行上下文，同时活动对象被激活

//活动对象AO = { arguments : {0:'ry'}, //arguments的值初始化为传入的参数
name : ry, //形参初始化为传进来的值
age ： undefined //var 声明的age，赋值为undefined}

活动对象其实也是变量对象，做着同样的工作。其实不管变量还是活动对象，这里都表明了，全局执行和函数执行时都有一个变量对象来储存着该上下文（环境内）定义的变量和函数。

（4）作用域链（scope chain）

在创建执行上下文时还要创建一个重要的东西，就是作用域链。每个执行环境的作用域链由当前环境的变量对象及父级环境的作用域链构成。

创建作用域链过程：

//以本段代码为例function fn(a,b){ var x = 'string',
}
fn(1,2);

1.函数被调用前，初始化function fn，fn有个私有属性[[scope]],它会被初始化为当前全局的作用域，fn.[[scope]="globalScope"。

2.调用函数fn(1,2)，开始创建fn执行上下文，同时创建作用域链fn.scopeChain = [fn.[[scope]]]，此时作用域链中有全局作用域。

3.fn活动对象AO被初始化后，把活动对象作为变量对象推到作用域链前端，此时fn.scopeChain = [fn.AO,fn.[[scope]]]，构建完成，此时作用域链中有两个值，一个当前活动对象，一个全局作用域。

fn的作用域链构建完成，作用域链中有两个值，第一个是fn函数自身的活动对象，能访问自身的变量，还有一个是全局作用域，所以fn能访问外部的变量。这里就说明了为什么函数中能够访问函数外部的变量，因为有作用域链，在自身找不到就顺着作用域链往上找。

（5）this的值

上面说过执行上下文有两种，一个全局执行上下文，一个函数执行上下，下面分别说说这两种上下文的this。

a.全局执行上下文的this

指向window全局对象

b.函数执行上下文的this(主要讲函数的this)

在《JavaScript权威指南》中有这么几句话：
1.this是关键字，不是变量，不是属性名，js语法不允许给this赋值。
2.关键字this没有作用域限制，嵌套的函数不会从调用它的函数中继承this。
3.如果嵌套函数作为方法调用，其this指向调用它的对象。
4.如果嵌套函数作为函数调用，其this值是window（非严格模式），或undefined（严格模式下）。

解读一下：上面说的概括了this两种值的情况：
1.函数直接作为某对象的方法被调用则函数的this指向该对象。
2.函数作为函数直接独立调用（不是某对象的方法），或是函数中的函数，其this指向window。

我们看几个栗子便可理解：
栗子1：（这个例子我相信都能理解）当函数被独立运行时，其this的值指向window对象。

function a(){ console.log(this);
}//独立运行a(); //window

栗子2：（函数中函数，这里嵌套了个外围函数）这里也是指向window对象，也相当于函数作为函数调用，就是独立运行。其实这个例子也说明闭包的this指向Window。

//外围函数function a(){ //b函数在里面
function b(){ console.log(this);
} //虽然在函数中，但b函数独立运行,不是那个对象的方法
b();
}
a(); //window

栗子3：（再写复杂点的话）x函数即使在对象里面，但它是函数中的函数，也是作为函数运行，不是Object的方法。getName才是objcet的方法，所以getName的this指向object（在下个栗子有）。

//一个对象var object = { //getName是Object的方法
getName : function(){ //x是getName里面的函数，它是作为函数调用的，this就是window啦
function x(){ console.log(this);
}
x();
}
}
object.getName(); //window

以上三个都是输出window，下面是this指向某个对象的情况。

栗子4：函数作为某个对象的方法被调用。

//一个对象var object = {
name : "object", //getName是Object的方法
getName : function(){
console.log(this === object);
}
}object.getName(); //true ， 说明this指向了object

这里的getName中的this是指向objct对象的，因为getName是object的一个方法，它作为对象方法被调用。

栗子5：再来个栗子。

var name = "window";var obj = {
name : "obj"};function fn (){ console.log(this.name);
}//将fn通过call或bind或apply直接绑定给obj，从而成为obj的方法。fn.call(obj); //obj

再总结一下this的值

全局执行上下文：this的值是window
函数执行上下文：this的值两种：
1.函数中this指向某对象，因为函数作为对象的方法：怎么看函数是对象的方法，一种是直接写在对象里面（不是嵌套在对象方法中的函数，不懂再看看栗子3），另一种是通过call等方法直接绑定在对象中。

2.函数中this指向window：函数独立运行，不是对象的方法，函数中的函数（闭包），其this指向window。

四、总结整个js代码执行过程

（1）JS执行过程

js代码执行分成了两部分：预执行和执行

• 预执行：创建好执行上下文，有两种，一种是开始执行js代码就创建全局的执行上下文，一种是当某个函数被调用时创建它自己的函数执行上下文。这里也就是本节主要讲的东西，创建执行上下文的三个重要成分。

• 执行：在执行栈中执行，栈顶的执行上下文获得执行权，并按顺序执行当前上下文中的代码，执行完后弹栈销毁上下文，执行权交给下一个栈顶执行上下文。

（2）放上图示

某个执行上下文生命周期：



五、后话

整个js的执行过程就这样了，一开始可能有点难理解，但看多几遍就慢慢领会了。希望大家能够理解。如果觉得写得好，记得点赞，关注哦。

❽ 如何查找网页元素对应的JS代码（如图）

如果会调试，可以用打开浏览器的调试功能。
以chrome为例，按F12打开调试窗口内，切换到Sources选项卡，最右边的容Event Listener Breakpoints里勾选Mouse下的mouseover即可，当鼠标移动到图片上时触发mouseover事件，chrome可响应事件设置断点，跟踪js代码查看就可以。

❾ Web前端工程师应该知道的JavaScript的10个难点！

今天小编要跟大家分享的文章是关于Web前端工程师应该知道的JavaScript的10个难点。相信很多正在学习Web前端知识的小伙伴对于JavaScript存在很多疑问，宏郑敬为了帮助大家更好的学习Web前端知识，成为一名优秀的web前端工程师，今天小编为大家分享了这篇Web前端应该知道的JavaScript难点的问题，下面我们一起看一看吧！

1、立即执行函数


立即执行函数，即
(IIFE)，正如它的名字，就是创建函数的同时立即执行。它没有绑定任何事件，也无需等待任何异步操作：

1.(function(){

2.

3.//代码

4.

5.//...

6.

7.})();

function(){}是一个匿名函数，包围它的一对括号将其转换为一个表达式，紧跟其后的一对括号调用了这个函数。立即执行函数也可以理解为立即调用一个匿名函数。立即执行函数最常见的应用场景就是：将var变量的作用域限制于你们函数内，这样可以避免命名冲突。


2、闭包


对于闭包(closure)，当外部函数返回之后，内部函数依然可以访问外部函数的变量。

1.(function(){

2.

3.//代码

4.

5.//...

6.

7.})();

代码中，外部函数f1只执行了一次，变量N设为0，并将内部函数f2赋值给了变量result。由于外部函数f1已经执行完毕，其内部变量N应该在内存中被清除，然而事实并不是这样：我们每次调用result的时候，发现变量N一直在内存中，并且在累加。为什么呢?这就是闭包的神奇之处了!


3、使用闭包定义私有变量


通常，JavaScript开发者使用下划线作为私有变量的前缀。但是实际上，这些变量依然可以被访问和修改，并非真正的私有变量。这时，使用闭包可以定义真正的私有变量：1.functionProct(){

2.

3.varname;

4.

5.this.setName=function(value){

6.name=value;

7.};

8.

9.this.getName=function(){

10.returnname;

11.};

12.}

13.

14.varp=newProct();

15.p.setName("Fundebug");

16.

17.console.log(p.name);//输出undefined

18.console.log(p.getName());//输出Fundebug

代码中，对象p的的name属性为私有属性，使用p.name不能直接访问。


4、prototype


每个JavaScript构造函数都有一个prototype属性，用于设置所有实例对象需要共享的属蔽慎性和方法。prototype属性不能列举。JavaScript仅支持通过prototype属性进行继承属性和方法。1.functionRectangle(x,y)

2.{

3.this._length=x;

4.this._breadth=y;

5.}

6.

7.Rectangle.prototype.getDimensions=function()

8.{

9.return{

10.length:this._length,

11.breadth:this._breadth

12.};

13.};

14.

15.varx=newRectangle(3,4);

16.vary=newRectangle(4,3);

17.

18.console.log(x.getDimensions());//{length:3,breadth:4}

19.console.log(y.getDimensions());//{length:4,breadth:3}

代码中，x和y都是构造函数Rectangle创建的对象实例，丛返它们通过prototype继承了getDimensions方法。


5、模块化


JavaScript并非模块化编程语言，至少ES6落地之前都不是。然而对于一个复杂的Web应用，模块化编程是一个最基本的要求。这时，可以使用立即执行函数来实现模块化，正如很多JS库比如jQuery以及我们Fundebug都是这样实现的。1.varmole=(function(){

2.varN=5;

3.

4.functionprint(x){

5.console.log("Theresultis:"+x);

6.}

7.

8.functionadd(a){

9.varx=a+N;

10.print(x);

11.}

12.

13.return{

14.description:"Thisisdescription",

15.add:add

16.};

17.})();

18.

19.

20.console.log(mole.description);//输出"thisisdescription"

21.

22.mole.add(5);//输出“Theresultis:10”

所谓模块化，就是根据需要控制模块内属性与方法的可访问性，即私有或者公开。在代码中，mole为一个独立的模块，N为其私有属性，print为其私有方法，decription为其公有属性，add为其共有方法。


6、变量提升


JavaScript会将所有变量和函数声明移动到它的作用域的最前面，这就是所谓的变量提升(Hoisting)。也就是说，无论你在什么地方声明变量和函数，解释器都会将它们移动到作用域的最前面。因此我们可以先使用变量和函数，而后声明它们。但是，仅仅是变量声明被提升了，而变量赋值不会被提升。如果你不明白这一点，有时则会出错：1.console.log(y);//输出undefined

2.

3.y=2;//初始化y

上面的代码等价于下面的代码：1.vary;//声明y

2.

3.console.log(y);//输出undefined

4.

5.y=2;//初始化y

为了避免BUG，开发者应该在每个作用域开始时声明变量和函数。


7、柯里化


柯里化，即Currying，可以是函数变得更加灵活。我们可以一次性传入多个参数调用它;也可以只传入一部分参数来调用它，让它返回一个函数去处理剩下的参数。1.varadd=function(x){

2.returnfunction(y){

3.returnx+y;

4.};

5.};

6.

7.console.log(add(1)(1));//输出2

8.

9.varadd1=add(1);

10.console.log(add1(1));//输出2

11.

12.varadd10=add(10);

13.console.log(add10(1));//输出11

代码中，我们可以一次性传入2个1作为参数add(1)(1)，也可以传入1个参数之后获取add1与add10函数，这样使用起来非常灵活。


8、apply，call与bind方法


JavaScript开发者有必要理解apply、call与bind方法的不同点。它们的共同点是第一个参数都是this，即函数运行时依赖的上下文。


三者之中，call方法是最简单的，它等价于指定this值调用函数：1.varuser={

2.name:"RahulMhatre",

3.whatIsYourName:function(){

4.console.log(this.name);

5.}

6.};

7.

8.user.whatIsYourName();//输出"RahulMhatre",

9.

10.varuser2={

11.name:"NehaSampat"

12.};

13.

14.user.whatIsYourName.call(user2);//输出"NehaSampat"

·apply方法与call方法类似。两者唯一的不同点在于，apply方法使用数组指定参数，而call方法每个参数单独需要指定：


·apply(thisArg,[argsArray])1.varuser={

2.greet:"Hello!",

3.greetUser:function(userName){

4.console.log(this.greet+""+userName);

5.}

6.};

7.

8.vargreet1={

9.greet:"Hola"

10.};

11.

12.user.greetUser.call(greet1,"Rahul");//输出"HolaRahul"

13.user.greetUser.apply(greet1,["Rahul"]);//输出"HolaRahul"

使用bind方法，可以为函数绑定this值，然后作为一个新的函数返回：1.varuser={

2.greet:"Hello!",

3.greetUser:function(userName){

4.console.log(this.greet+""+userName);

5.}

6.};

7.

8.vargreetHola=user.greetUser.bind({greet:"Hola"});

9.vargreetBonjour=user.greetUser.bind({greet:"Bonjour"});

10.

11.greetHola("Rahul")//输出"HolaRahul"

12.greetBonjour("Rahul")//输出"BonjourRahul"

9、memoization


Memoization用于优化比较耗时的计算，通过将计算结果缓存到内存中，这样对于同样的输入值，下次只需要中内存中读取结果。

1.functionmemoizeFunction(func)

2.{

3.varcache={};

4.returnfunction()

5.{

6.varkey=arguments[0];

7.if(cache[key])

8.{

9.returncache[key];

10.}

11.else

12.{

13.varval=func.apply(this,arguments);

14.cache[key]=val;

15.returnval;

16.}

17.};

18.}

19.

20.

21.varfibonacci=memoizeFunction(function(n)

22.{

23.return(n===0||n===1)?n:fibonacci(n-1)+fibonacci(n-2);

24.});

25.

26.console.log(fibonacci(100));//输出354224848179262000000

27.console.log(fibonacci(100));//输出354224848179262000000

代码中，第2次计算fibonacci(100)则只需要在内存中直接读取结果。


10、函数重载


所谓函数重载(method
overloading)，就是函数名称一样，但是输入输出不一样。或者说，允许某个函数有各种不同输入，根据不同的输入，返回不同的结果。凭直觉，函数重载可以通过if...else或者switch实现，这就不去管它了。jQuery之父John
Resig提出了一个非常巧(bian)妙(tai)的方法，利用了闭包。


从效果上来说，people对象的find方法允许3种不同的输入:
0个参数时，返回所有人名;1个参数时，根据firstName查找人名并返回;2个参数时，根据完整的名称查找人名并返回。


难点在于，people.find只能绑定一个函数，那它为何可以处理3种不同的输入呢?它不可能同时绑定3个函数find0,find1与find2啊!这里的关键在于old属性。


由addMethod函数的调用顺序可知，people.find最终绑定的是find2函数。然而，在绑定find2时，old为find1;同理，绑定find1时，old为find0。3个函数find0,find1与find2就这样通过闭包链接起来了。


根据addMethod的逻辑，当f.length与arguments.length不匹配时，就会去调用old，直到匹配为止。

1.functionaddMethod(object,name,f)

2.{

3.varold=object[name];

4.object[name]=function()

5.{

6.//f.length为函数定义时的参数个数

7.//arguments.length为函数调用时的参数个数

8.if(f.length===arguments.length)

9.{

10.returnf.apply(this,arguments);

11.}

12.elseif(typeofold==="function")

13.{

14.returnold.apply(this,arguments);

15.}

16.};

17.}

18.

19.

20.//不传参数时，返回所有name

21.functionfind0()

22.{

23.returnthis.names;

24.}

25.

26.

27.//传一个参数时，返回firstName匹配的name

28.functionfind1(firstName)

29.{

30.varresult=[];

31.for(vari=0;i
32.{

33.if(this.names[i].indexOf(firstName)===0)

34.{

35.result.push(this.names[i]);

36.}

37.}

38.returnresult;

39.}

40.

41.

42.//传两个参数时，返回firstName和lastName都匹配的name

43.functionfind2(firstName,lastName)

44.{

45.varresult=[];

46.for(vari=0;i
47.{

48.if(this.names[i]===(firstName+""+lastName))

49.{

50.result.push(this.names[i]);

51.}

52.}

53.returnresult;

54.}

55.

56.

57.varpeople={

58.names:["DeanEdwards","AlexRussell","DeanTom"]

59.};

60.

61.

62.addMethod(people,"find",find0);

63.addMethod(people,"find",find1);

64.addMethod(people,"find",find2);

65.

66.

67.console.log(people.find());//输出["DeanEdwards","AlexRussell","DeanTom"]

68.console.log(people.find("Dean"));//输出["DeanEdwards","DeanTom"]

69.console.log(people.find("Dean","Edwards"));//输出["DeanEdwards"]

以上就是小编今天为大家分享的关于Web前端工程师应该知道的JavaScript的10个难点。希望本篇文章能够对正在从事Web前端学习的小伙伴们有所帮助。想要了解更多web前端相关知识记得关注北大青鸟Web培训官网最后祝愿小伙伴们工作顺利！


原文链接：#/a/1190000010371988

❿ ajaxupload.js无法获取上传文件

ajaxupload.js是一个开源的实现Ajax文件上传的jQuery插件，常用于向服务器上传文件。如果遇到该插件无法获取上传文件的问题，猜郑可能是以下几个方面的原因：
1、插件引用错误：首先需要确保插件已正确引用，可以检查HTML代码或控制台中是否出现引用错误或没有引用相关JS文件的情况。
2、表单设置错误：使用ajaxupload.js时，需要将表单对象传皮兆衫递给插件以表示文件上传的上下文。如果表单对象设置有误，插件可能无法获取上传文件。可以确保表单中存在file类型的input，并将其作为参数传递给插件。
3、上传文件格式不正确：如果上传文件的格式不受支持，则插件可能无法正确获取上传文件。可以确保上传的文件格式与插件支持的格式相同。
4、安全问题限制：有些情况下，安全设置可能会禁止通过JavaScript读取文件内容，防止网站被黑客攻击等。可以检查安全设置以确定是否存在限制。
5、程序服务端问题：如果前面几个问题都排除了，还是无法获取上传文件，则可能是由于程序服务端的设置或代码实现问题，需要进一步检查或调试燃腔。