避免嵌套的订阅调用是通过使用异步编程的一种方式来解决的。可以使用Promise、async/await或者RxJS等工具来实现。

下面是一个使用Promise的解决方法的示例代码：

function firstFunction() {
  return new Promise((resolve, reject) => {
    // 异步操作
    setTimeout(() => {
      resolve('First function completed');
    }, 1000);
  });
}

function secondFunction() {
  return new Promise((resolve, reject) => {
    // 异步操作
    setTimeout(() => {
      resolve('Second function completed');
    }, 2000);
  });
}

function thirdFunction() {
  return new Promise((resolve, reject) => {
    // 异步操作
    setTimeout(() => {
      resolve('Third function completed');
    }, 3000);
  });
}

async function main() {
  try {
    const result1 = await firstFunction();
    console.log(result1);

    const result2 = await secondFunction();
    console.log(result2);

    const result3 = await thirdFunction();
    console.log(result3);
  } catch (error) {
    console.error(error);
  }
}

main();

在上面的代码中，每个异步函数都返回一个Promise对象。main函数通过使用async/await来依次执行这些异步函数，并且在每个函数执行完成后打印结果。使用async/await可以使代码更加简洁和易读，避免了嵌套的订阅调用。

另外，如果你更喜欢使用RxJS，可以使用flatMap或者concatMap等操作符来解决嵌套订阅的问题。下面是一个使用RxJS的解决方法的示例代码：

import { of } from 'rxjs';
import { delay, concatMap } from 'rxjs/operators';

function firstFunction() {
  return of('First function completed').pipe(delay(1000));
}

function secondFunction() {
  return of('Second function completed').pipe(delay(2000));
}

function thirdFunction() {
  return of('Third function completed').pipe(delay(3000));
}

of(null)
  .pipe(
    concatMap(() => firstFunction()),
    concatMap(result1 => {
      console.log(result1);
      return secondFunction();
    }),
    concatMap(result2 => {
      console.log(result2);
      return thirdFunction();
    })
  )
  .subscribe(result3 => console.log(result3));

在上面的代码中，使用concatMap操作符来执行每个异步函数，并在每个函数执行完成后进行下一个函数的调用。这样可以保证函数的顺序执行，并且避免了嵌套的订阅调用。