javascript难点,js难点看这一篇就够了

javascript是不是相对于其他语言比较难？听很多人都说javascript的难度仅次于c语言，比那些php，java都要

javascript语言，皮毛好学，容易上手，但真正深入学习的话，确实像好多人说的那样，比较难。JavaScript语言，零散，不像java那样系统，而且编写调试JavaScript语言比较麻烦，不像java那样直接有编写错误提示。种种方面结合起来，JavaScript语言就比较难学，难掌控，而且涉及到浏览器兼容问题，也是一大难点，比如有的命令在Firefox上可以出来效果，但在IE上就报错了。要是像某些人说，一周学会的话，有点儿可笑了，真正的天才都达不到几天学会的。最多最多这几天，了解了下JavaScript语言的基础皮毛而已。

相关问答

Q1: 学软件开发需要有什么基础？

学软件开发需要的基础知识有:1、数学和英语基础知识;2、基础编程语言;3、数据库知识;4、web相关知识。软件开发是根据用户要求建造出软件系统或者系统中的。1.

基础知识 学软件开发往往要与数学和英文打交道,所以要有一定的数学、 英语基础,有一定的基础在学习软件开发上可以说是事半功倍了。如 果英语、数学不错的,可以跳过这一步。

2.

基础编程语言知识 北大青鸟佳音校区的资深软件开发老师指出, 实现软件运行都由 某种程序语言来实现, 所以学好程序语言是做好软件开发工作的必修 课。

Q2: js中最难的部分

最难的是函数是对象，函数又不仅仅是对象，还可以做面向对象中的类使用。

数组可以是对象集合，数组也可以是函数集合。

对象变化又过于灵活。所以要想深入学习，不在于语法，学会语法之后更需多加练习多加体会。

从 基本的对象方法、事件、属性

到 函数调用 匿名函数

到 JSON

到 函数套用 匿名函数套用 闭包

到 prototype

需要不断地学习和体会。

Q3: 学软件开发要会什么？

软件开发是根据用户要求，建造出软件系统或者系统中的软件部分的过程。 软件开发是一项包括需求捕捉，需求分析，设计，实现和测试的系统工程。

软件一般是用某种程序设计语言来实现的。 通常采用软件开发工具可以进行开发。 软件分为系统软件和应用软件。 软件并不只是包括可以在计算机上运行的程序，与这些程序相关的文件一般也被认为是软件的一部分。 软件设计思路和方法的一般过程，包括设计软件的功能和实现的算法和方法、软件的总体结构设计和模块设计、编程和调试、程序联调和测试以及编写、提交程序。

一般来说，学软件开发需要学会与之相关的编程语言，常见的软件开发语言有：JAVA、C语言、C#、C++、JSP、ASP、PB、DELPHI等，而与软件应用最关键的需要用到数据库，我们常说的数据库，有：MYSQL、SQLSERVER、ORACLE等。这些都是软件开发所需要学习的开发语言，只有把这些都学会了，再多加运用和联系，你就不愁找不到一份好的工作了。

至于学习上述编程语言工具的学习，需要会高中英语、数学物理方面的基础知识，所谓的“零基础”学编程，指的是编程语言0基础！

1、开始自学软件编程课程

编程语言种类繁多，各有千秋，在学习之前需要明确自己要学习哪一门编程语言。确定之后需要制订一个合理的学习计划，并且持之以恒地执行学习计划。在学习过程中要养成良好的学习习惯。

不爱研究、坐不住，但凡三天打鱼两天晒网，或者对计算机不喜欢等一类人不适合学习编程,哪怕一时努力，最后也不是结不了业，就是功败垂成，难以在这条路上走远。编程入门点是兴趣。兴趣是学习的最大动力源。需要有恒心有耐心，进入这个行业并不难，就算你没有基础和经验，也是可以学好的。那些创造编程语言的人，创造计算机的人也都是从零开始的。他们也是在不断揣摩、不断学习和实践之火才获得成果。没有一个技术大牛是从一开始就什么都会的，都是从什么也不会开始的。只需你有兴趣而且肯努力，可能慢慢就会发现学习软件开发也没有想象中的那么难。

2、要重视编程基本功

绝大部分行业内的大牛都是经历过辛苦而又长期的程序开发学习和实战进程的，假如你想要成为一名优秀的程序员，最基本的编码学习肯定是不能跳过的，底层的知识必需要扎实掌握，就如同Java开发，项目训练前提是掌握一定的java课程基础，假如不先把基础稳固，就直接做项目的话，是很难做出来而且学不会那种逻辑思考的能力。

3、附加技能的学习

前面说了软件开发涉及到一种逻辑思维，那么必定要学习一些数学知识，学会数学公式的运算。软件开发行业是特别注重效率的，假如你编写的某个功能的逻辑不是很清楚，可能整个项目都会绕一个很大的圈子，这样的代码存在许多冗余成分，浪费很多时间，所以要懂得培养自己必定的逻辑思维。其次就是英语的学习了，虽然学软件开发不需要有很强的英语能力，但有必定的英语才能的话，更加有利于自己往更深邃的技术发展。

4、动手能力的培养

作为一个程序员动手能力是非常重要的，你学习的各个知识点和思维都自己去开发操练才能稳固，作为老师最怕的学生就是他们只停留在书本或许课堂上的了解，而自己不去实实在在的把它完成出来，着手做的过程中你会不断发现问题，然后自己去解决问题，这样你才能成为一个真正的高手。也要学会找到有效的学习办法，这样学起来会如鱼得水的。可以先看视频学习，学起来就比曾经看书快许多，并且也更简略，觉得自己掌握了一定的知识后，可以尝试做项目，从小项目开始练手到商业项目实战，懂得实操的软件开发工程师才是企业真正喜欢的。

1、Web开发领域。Web开发是当前一个重要的开发领域，Web开发涉及到的应用领域也十分广泛，可以说有互联网的地方就有Web软件。Web开发分为前端开发和后端开发两大部分，前端开发需要学习三个基本知识，包括Html、CSS和JavaScript，其中JavaScript是重点也是难点。后端开发可以采用众多开发语言，其中比较流行的编程语言包括PHP、Java和Python。另外，Web开发还需要掌握数据库知识以及云计算平台的相关知识（IaaS、PaaS）。

2、移动端开发。随着移动互联网的发展，目前移动端开发的任务也比较多，移动端开发集中在三个领域，分别是Android开发、iOS开发和各种小程序开发。其中Android开发需要学习Java或者kotlin语言，而iOS开发需要学习OC或者Swift，小程序开发则需要掌握其对应的开发语言，大部分小程序开发语言都属于类前端开发语言，还是比较容易掌握的。

3、嵌入式开发领域。随着5G标准的落地应用，未来嵌入式开发领域将释放出大量的开发任务，包括大量的可穿戴设备开发等等。嵌入式开发涉及到三方面内容，分别是设备（各种传感器等）、网络和平台，编程语言通常可以从C语言开始学起。

4、最后，不论从事哪个领域的开发，都应该具备扎实的计算机基础知识，包括操作系统（体系结构）、计算机网络、数据库等。如果想走研发级程序员路线，一定要重视数学基础，另外需要系统的学习算法设计、数据结构和编译原理等内容。

Q4: 前端开发的难点到底在什么地方？

前端开发的难点在掌握HTML。

掌握HTML是前端开发的核心，HTML是一种制作万维网页面的标准语言，是万维网浏览器使用的一种语言，它消除了不同计算机之间信息交流的障碍。

因此，它是网络上应用最为广泛的语言，也是构成网页文档的主要语言，学好HTML是成为Web开发人员的基本条件。

常见前端开发工程师职位职责要求：

1、使用Div+css并结合Javascript负责产品的前端开发和页面制作。

2、熟悉W3C标准和各主流浏览器在前端开发中的差异，能熟练运用DIV+CSS，提供针对不同浏览器的前端页面解决方案。移动HTML5的性能和其他优化，为用户呈现最好的界面交互体验和最好的性能。

3、负责相关产品的需求以及前端程序的实现，提供合理的前端架构。改进和优化开发工具、开发流程、和开发框架。

4、与产品、后台开发人员保持良好沟通，能快速理解、消化各方需求，并落实为具体的开发工作，能独立完成功能页面的设计与代码编写，配合产品团队完成功能页面的需求调研和分析。

Q5: javascript中异步操作的异常怎么处理

一、JavaScript异步编程的两个核心难点

异步I/O、事件驱动使得单线程的JavaScript得以在不阻塞UI的情况下执行网络、文件访问功能，且使之在后端实现了较高的性能。然而异步风格也引来了一些麻烦，其中比较核心的问题是：

1、函数嵌套过深

JavaScript的异步调用基于回调函数，当多个异步事务多级依赖时，回调函数会形成多级的嵌套，代码变成

金字塔型结构。这不仅使得代码变难看难懂，更使得调试、重构的过程充满风险。

2、异常处理

回调嵌套不仅仅是使代码变得杂乱，也使得错误处理更复杂。这里主要讲讲异常处理。

二、异常处理

像很多时髦的语言一样，JavaScript 也允许抛出异常，随后再用一个try/catch

语句块捕获。如果抛出的异常未被捕获，大多数JavaScript环境都会提供一个有用的堆栈轨迹。举个例子，下面这段代码由于'{'为无效JSON

对象而抛出异常。

?

12345678

function JSONToObject(jsonStr) { return JSON.parse(jsonStr);}var obj = JSONToObject('{');//SyntaxError: Unexpected end of input//at Object.parse (native)//at JSONToObject (/AsyncJS/stackTrace.js:2:15)//at Object.anonymous (/AsyncJS/stackTrace.js:4:11)

堆栈轨迹不仅告诉我们哪里抛出了错误，而且说明了最初出错的地方：第4 行代码。遗憾的是，自顶向下地跟踪异步错误起源并不都这么直截了当。

异步编程中可能抛出错误的情况有两种：回调函数错误、异步函数错误。

1、回调函数错误

如果从异步回调中抛出错误，会发生什么事？让我们先来做个测试。

?

1234567

setTimeout(function A() { setTimeout(function B() { setTimeout(function C() { throw new Error('Something terrible has happened!'); }, 0); }, 0);}, 0);

上述应用的结果是一条极其简短的堆栈轨迹。

?

12

Error: Something terrible has happened!at Timer.C (/AsyncJS/nestedErrors.js:4:13)

等等，A 和B 发生了什么事？为什么它们没有出现在堆栈轨迹中？这是因为运行C 的时候，异步函数的上下文已经不存在了，A 和B 并不在内存堆栈里。这3

个函数都是从事件队列直接运行的。基于同样的理由，利用try/catch

语句块并不能捕获从异步回调中抛出的错误。另外回调函数中的return也失去了意义。

?

1234567

try { setTimeout(function() { throw new Error('Catch me if you can!'); }, 0);} catch (e) {console.error(e);}

看到这里的问题了吗？这里的try/catch 语句块只捕获setTimeout函数自身内部发生的那些错误。因为setTimeout

异步地运行其回调，所以即使延时设置为0，回调抛出的错误也会直接流向应用程序。

总的来说，取用异步回调的函数即使包装上try/catch 语句块，也只是无用之举。（特例是，该异步函数确实是在同步地做某些事且容易出错。例如，Node

的fs.watch(file,callback)就是这样一个函数，它在目标文件不存在时会抛出一个错误。）正因为此，Node.js

中的回调几乎总是接受一个错误作为其首个参数，这样就允许回调自己来决定如何处理这个错误。

2、异步函数错误

由于异步函数是立刻返回的，异步事务中发生的错误是无法通过try-catch来捕捉的，只能采用由调用方提供错误处理回调的方案来解决。

例如Node中常见的function (err, ...)

{...}回调函数，就是Node中处理错误的约定：即将错误作为回调函数的第一个实参返回。再比如HTML5中FileReader对象的onerror函数，会被用于处理异步读取文件过程中的错误。

举个例子，下面这个Node 应用尝试异步地读取一个文件，还负责记录下任何错误（如“文件不存在”）。

?

1234567

var fs = require('fs'); fs.readFile('fhgwgdz.txt', function(err, data) { if (err) { return console.error(err); }; console.log(data.toString('utf8'));});

客户端JavaScript 库的一致性要稍微差些，不过最常见的模式是，针对成败这两种情形各规定一个单独的回调。jQuery 的Ajax

方法就遵循了这个模式。

?

1234

$.get('/data', { success: successHandler, failure: failureHandler});

不管API 形态像什么，始终要记住的是，只能在回调内部处理源于回调的异步错误。

三、未捕获异常的处理

如果是从回调中抛出异常的，则由那个调用了回调的人负责捕获该异常。但如果异常从未被捕获，又会怎么样？这时，不同的JavaScript环境有着不同的游戏规则……

1. 在浏览器环境中

现代浏览器会在开发人员控制台显示那些未捕获的异常，接着返回事件队列。要想修改这种行为，可以给window.onerror

附加一个处理器。如果windows.onerror 处理器返回true，则能阻止浏览器的默认错误处理行为。

?

123

window.onerror = function(err) { return true; //彻底忽略所有错误};

在成品应用中， 会考虑某种JavaScript 错误处理服务， 譬如Errorception。Errorception

提供了一个现成的windows.onerror 处理器，它向应用服务器报告所有未捕获的异常，接着应用服务器发送消息通知我们。

2. 在Node.js 环境中

在Node 环境中，window.onerror 的类似物就是process 对象的uncaughtException 事件。正常情况下，Node

应用会因未捕获的异常而立即退出。但只要至少还有一个uncaughtException 事件处理

器，Node 应用就会直接返回事件队列。

?

123

process.on('uncaughtException', function(err) { console.error(err); //避免了关停的命运！});

但是，自Node 0.8.4 起，uncaughtException 事件就被废弃了。据其文档所言，对异常处理而言，uncaughtException

是一种非常粗暴的机制，请勿使用uncaughtException，而应使用Domain 对象。

Domain 对象又是什么？你可能会这样问。Domain 对象是事件化对象，它将throw 转化为'error'事件。下面是一个例子。

?

123456789

var myDomain = require('domain').create();myDomain.run(function() { setTimeout(function() { throw new Error('Listen to me!') }, 50);});myDomain.on('error', function(err) { console.log('Error ignored!');});

源于延时事件的throw 只是简单地触发了Domain 对象的错误处理器。

Error ignored!

很奇妙，是不是？Domain 对象让throw

语句生动了很多。不管在浏览器端还是服务器端，全局的异常处理器都应被视作最后一根救命稻草。请仅在调试时才使用它。

四、几种解决方案

下面对几种解决方案的讨论主要集中于上面提到的两个核心问题上，当然也会考虑其他方面的因素来评判其优缺点。

1、Async.js

首先是Node中非常著名的Async.js，这个库能够在Node中展露头角，恐怕也得归功于Node统一的错误处理约定。

而在前端，一开始并没有形成这么统一的约定，因此使用Async.js的话可能需要对现有的库进行封装。

Async.js的其实就是给回调函数的几种常见使用模式加了一层包装。比如我们需要三个前后依赖的异步操作，采用纯回调函数写法如下：

?

12345678910111213141516

asyncOpA(a, b, (err, result) = { if (err) { handleErrorA(err); } asyncOpB(c, result, (err, result) = { if (err) { handleErrorB(err); } asyncOpB(d, result, (err, result) = { if (err) { handlerErrorC(err); } finalOp(result); }); });});

如果我们采用async库来做：

?

12345678910111213141516171819202122

async.waterfall([ (cb) = { asyncOpA(a, b, (err, result) = { cb(err, c, result); }); }, (c, lastResult, cb) = { asyncOpB(c, lastResult, (err, result) = { cb(err, d, result); }) }, (d, lastResult, cb) = { asyncOpC(d, lastResult, (err, result) = { cb(err, result); }); }], (err, finalResult) = { if (err) { handlerError(err); } finalOp(finalResult);});

可以看到，回调函数由原来的横向发展转变为纵向发展，同时错误被统一传递到最后的处理函数中。

其原理是，将函数数组中的后一个函数包装后作为前一个函数的末参数cb传入，同时要求：

每一个函数都应当执行其cb参数;cb的第一个参数用来传递错误。我们可以自己写一个async.waterfall的实现：

?

12345678910111213141516171819202122

let async = { waterfall: (methods, finalCb = _emptyFunction) = { if (!_isArray(methods)) { return finalCb(new Error('First argument to waterfall must be an array of functions')); } if (!methods.length) { return finalCb(); } function wrap(n) { if (n === methods.length) { return finalCb; } return function (err, ...args) { if (err) { return finalCb(err); } methods[n](...args, wrap(n + 1)); } } wrap(0)(false); }};

Async.js还有series/parallel/whilst等多种流程控制方法，来实现常见的异步协作。

Async.js的问题：

在外在上依然没有摆脱回调函数，只是将其从横向发展变为纵向，还是需要程序员熟练异步回调风格。

错误处理上仍然没有利用上try-catch和throw，依赖于“回调函数的第一个参数用来传递错误”这样的一个约定。

2、Promise方案

ES6的Promise来源于Promise/A+。使用Promise来进行异步流程控制，有几个需要注意的问题，

把前面提到的功能用Promise来实现，需要先包装异步函数，使之能返回一个Promise：

?

12345678910

function toPromiseStyle(fn) { return (...args) = { return new Promise((resolve, reject) = { fn(...args, (err, result) = { if (err) reject(err); resolve(result); }) }); };}

这个函数可以把符合下述规则的异步函数转换为返回Promise的函数：

回调函数的第一个参数用于传递错误，第二个参数用于传递正常的结果。接着就可以进行操作了：

?

123456789101112131415

let [opA, opB, opC] = [asyncOpA, asyncOpB, asyncOpC].map((fn) = toPromiseStyle(fn)); opA(a, b) .then((res) = { return opB(c, res); }) .then((res) = { return opC(d, res); }) .then((res) = { return finalOp(res); }) .catch((err) = { handleError(err); });

通过Promise，原来明显的异步回调函数风格显得更像同步编程风格，我们只需要使用then方法将结果传递下去即可，同时return也有了相应的意义：

在每一个then的onFullfilled函数（以及onRejected）里的return，都会为下一个then的onFullfilled函数（以及onRejected）的参数设定好值。

如此一来，return、try-catch/throw都可以使用了，但catch是以方法的形式出现，还是不尽如人意。

3、Generator方案

ES6引入的Generator可以理解为可在运行中转移控制权给其他代码，并在需要的时候返回继续执行的函数。利用Generator可以实现协程的功能。

将Generator与Promise结合，可以进一步将异步代码转化为同步风格：

?

1234567891011

function* getResult() { let res, a, b, c, d; try { res = yield opA(a, b); res = yield opB(c, res); res = yield opC(d); return res; } catch (err) { return handleError(err); }}

然而我们还需要一个可以自动运行Generator的函数：

?

123456789101112131415161718192021222324252627282930

function spawn(genF, ...args) { return new Promise((resolve, reject) = { let gen = genF(...args); function next(fn) { try { let r = fn(); if (r.done) { resolve(r.value); } Promise.resolve(r.value) .then((v) = { next(() = { return gen.next(v); }); }).catch((err) = { next(() = { return gen.throw(err); }) }); } catch (err) { reject(err); } } next(() = { return gen.next(undefined); }); });}

用这个函数来调用Generator即可：

?

1234567

spawn(getResult) .then((res) = { finalOp(res); }) .catch((err) = { handleFinalOpError(err); });

可见try-catch和return实际上已经以其原本面貌回到了代码中，在代码形式上也已经看不到异步风格的痕迹。

类似的功能有co/task.js等库实现。

4、ES7的async/await

ES7中将会引入async function和await关键字，利用这个功能，我们可以轻松写出同步风格的代码，

同时依然可以利用原有的异步I/O机制。

采用async function，我们可以将之前的代码写成这样：

?

12345678910111213

async function getResult() { let res, a, b, c, d; try { res = await opA(a, b); res = await opB(c, res); res = await opC(d); return res; } catch (err) { return handleError(err); }} getResult();

和Generator Promise方案看起来没有太大区别，只是关键字换了换。

实际上async

function就是对Generator方案的一个官方认可，将之作为语言内置功能。

async function的缺点：

await只能在async function内部使用，因此一旦你写了几个async function，或者使用了依赖于async

function的库，那你很可能会需要更多的async function。

目前处于提案阶段的async

function还没有得到任何浏览器或Node.JS/io.js的支持。Babel转码器也需要打开实验选项，并且对于不支持Generator的浏览器来说，还需要引进一层厚厚的regenerator

runtime，想在前端生产环境得到应用还需要时间。

以上就是本文的全部内容，希望对大家的学习有所帮助。