ES6 中的 Promise 是一种处理异步操作的机制，它可以避免回调地狱，使得异步代码更加易读和可维护。下面是如何运用 ES6 Promise 进行异步编程的一些常见方式：

Promise.resolve() 和 Promise.reject()
Promise.resolve() 和 Promise.reject() 是两个常用的静态方法，它们可以用来快速地创建一个已经成功或已经失败的 Promise 对象。比如：

const p1 = Promise.resolve('成功');
const p2 = Promise.reject('失败');

Promise.then() 和 Promise.catch()

Promise.then() 方法用来处理 Promise 对象的成功情况，Promise.catch() 方法用来处理 Promise 对象的失败情况。可以通过链式调用的方式来处理 Promise 对象的结果，比如：

const p = new Promise((resolve, reject) => {
  // 异步操作
  setTimeout(() => {
    const result = Math.random() < 0.5 ? '成功' : '失败';
    if (result === '成功') {
      resolve(result);
    } else {
      reject(result);
    }
  }, 1000);
});

p.then((result) => {
  console.log(result); // 处理成功的情况
}).catch((result) => {
  console.log(result); // 处理失败的情况
});

Promise.all()

Promise.all() 方法可以同时处理多个 Promise 对象，等待所有 Promise 对象都完成后，再将它们的结果按照顺序依次返回。如果其中任何一个 Promise 对象失败了，则整个 Promise.all() 也会失败。比如：

const p1 = Promise.resolve('第一个 Promise 对象');
const p2 = Promise.resolve('第二个 Promise 对象');
const p3 = Promise.reject('第三个 Promise 对象');

Promise.all([p1, p2, p3])
  .then((results) => {
    console.log(results); // [ '第一个 Promise 对象', '第二个 Promise 对象', '第三个 Promise 对象' ]
  })
  .catch((error) => {
    console.log(error); // 第三个 Promise 对象
  });

Promise.race()

Promise.race() 方法可以同时处理多个 Promise 对象，等待其中任何一个 Promise 对象完成后，就将它的结果返回。如果其中任何一个 Promise 对象失败了，则整个 Promise.race() 也会失败。比如：

const p1 = new Promise((resolve) => {
  setTimeout(() => {
    resolve('第一个 Promise 对象');
  }, 1000);
});
const p2 = new Promise((resolve) => {
  setTimeout(() => {
    resolve('第二个 Promise 对象');
  }, 500);
});

Promise.race([p1, p2])
  .then((result) => {
    console.log(result); // 第二个 Promise 对象
  })
  .catch((error) => {
    console.log(error);
  });

综上所述，ES6 Promise 提供了一种优雅和灵活的方式来处理异步编程，可以提高代码质量和开发效率。