通常，程序的过程是直接执行的， 一次发生的一件事 。如果功能取决于另一个函数的结果，则必须等待结果的返回，并且它发生了，整个程序实际上都停止了从视角RIO。

根据您使用的编程环境（在Web开发的情况下），它们提供 api的（ fetch ，in> Promise ， works ）允许您在分配中执行这些任务，IE执行处理主线程外 ，完成后，返回结果。<<<<<<<。 /p>

tim cnica async （Asancrones）非常重要，尤其是在Web程序中。当Web应用程序在浏览器中执行并执行严格的冲突而无需将控件返回浏览器时，它似乎已经崩溃了。这称为阻止;浏览器被阻止以继续处理用户的输入并执行Web应用程序返回处理器控件的其他任务。

繁重的任务，例如耗时或寻求服务器信息可能会占用并阻止浏览器，这对用户来说是一个不好的体验。

线程

a 线程基本上是程序可以用来完成任务的过程。每个线程一次只是一个任务：

每个任务将依次执行，必须在开始附近的任务之前完成一个任务。

javascript 传统上是单线程。即使使用处理过程，您也可以使自己在线程中执行任务，称为 main thread （主线程）。

过了一会儿，JavaScript获得了一些工具来解决此类问题。 Web workers允许您将部分JavaScript处理发送到单独的线程。

您通常会使用工人执行一个繁重的过程，以免UI被阻止。

主线程：tarefa a-> tarefa c

工作线程：tarefa pesada b

费用Assamancron

os 作品在并行处理方面有帮助，它们具有局限性，并且不是 javascript 处理ashonchronism的主要解决方案。浏览器允许我们通过 Promises 等资源以重要的方式执行某些操作，允许您执行操作，然后在执行另一个操作之前等待结果：

Main thread: Tarefa A                   Tarefa B
Promise:         | ---> operação async ---> |

操作正在其他地方发生，主线程在处理突击操作时不会被阻止。P>

JavaScript异步

水编程是一种允许您的程序启动潜在长期任务的技术，并且在执行此任务时仍然能够响应其他事件，而不必等到完成此任务完成。

浏览器提供的许多功能可能需要很长时间，因此是异步的。例如：

• 使用 fetch（）提出HTTP请求
• 使用 gethutics（）访问用户的相机或麦克风
• 要求用户使用 showopenfilepicker（）选择文件

在编程中，程序每次按照我们编写的顺序执行一行执行，等待上一个任务的最终确定到附近。

这种方法的问题是，当浏览器需要处理可能耗时耗尽页面锁定的处理时，直到处理结果返回。

异步的概念用于解决此类问题，因为我们可以将处理委派给函数并继续执行后继续执行。

• 事件处理程序是使用异步性的示例，因为它们会在基于事件的射击上执行的功能（回调）。

funã§de回调

回调是作为其他函数参数传递的函数，当调用特定事件/过程时，它被称为back ，例如以示例为例，浏览器事件如 click 。

function doStep1(init, callback) {
  const result = init + 1;
  callback(result);
}

function doStep2(init, callback) {
  const result = init + 2;
  callback(result);
}

function doStep3(init, callback) {
  const result = init + 3;
  callback(result);
}

function doOperation() {
  doStep1(0, (result1) => {
    doStep2(result1, (result2) => {
      doStep3(result2, (result3) => {
        console.log(`result: ${result3}`);
      });
    });
  });
}

console.log(doOperation()); // => result: 6

function doStep1(init) {
  return new Promise((resolve, reject) => {
    const result = init + 1;

    resolve(result);

    // tratar possíveis erros - reject(erro)
  });
}

function doStep2(init) {
  return new Promise((resolve, reject) => {
    const result = init + 2;

    resolve(result);

    // tratar possíveis erros - reject(erro)
  });
}

function doStep3(init) {
  return new Promise((resolve, reject) => {
    const result = init + 3;

    resolve(result);

    // tratar possíveis erros - reject(erro)
  });
}

function doOperation() {
  return doStep1(0)
    .then((result1) => doStep2(result1))
    .then((result2) => doStep3(result2))
    .then((result3) => console.log(`result: ${result3}`))
    .catch((err) => console.log(err));
}

doOperation(); // => result: 6

function doStep1(init) {
  return new Promise((resolve, reject) => {
    const result = init + 1;

    resolve(result);

    // tratar possíveis erros - reject(erro)
  });
}

function doStep2(init) {
  return new Promise((resolve, reject) => {
    const result = init + 2;

    resolve(result);

    // tratar possíveis erros - reject(erro)
  });
}

function doStep3(init) {
  return new Promise((resolve, reject) => {
    const result = init + 3;

    resolve(result);

    // tratar possíveis erros - reject(erro)
  });
}
async function doOperation() {
  try {
    const result1 = await doStep1(0);
    const result2 = await doStep2(result1);
    const result3 = await doStep3(result2);

    console.log(`result: ${result3}`);
  } catch (err) {
    console.log(err);
  }
}

doOperation(); // => result: 6