Javascript 在以下承诺结束之前多次发出vue组合api

即使承诺没有结束，下面的“状态”也会发出两次。嗯，我知道每个参数（successData、loading、errored）分别执行得非常好。但每当我合并它们时，就会出现错误

import{computed，reactive，toRefs，watch，ref}来自'@vue/compositionapi'；
从“@vue/composition-api/dist/component”导入{Data}；
导出默认函数usePromise（fn:any）{
如果（！fn）{
抛出新错误（`[usePromise]：需要第一个参数（必须是函数）`）；
}
如果（fn的类型！==‘功能’）{
抛出新类型错误（`[usePromise]：参数必须是函数，但收到${typeof fn}`）；
}
常数状态：任意=无功({
successData:{}，
加载：对，
错误：错误，
错误消息：“”，
错误代码：0，
完:错,，
});
让我们承诺；
const use=async（…args:any）=>{
state.loading=true；
常量promise=（lastPromise=fn（…args））；
试一试{
const result=等待承诺；
如果（最后承诺===承诺）{
state.successData=result.data；
state.errored=false；
}
}捕获（错误）{
如果（！error.response）{
state.errorCode=900；
state.errorMessage='网络错误'；
}
state.errorMessage=error.response.data.error；
state.errorCode=error.response.status；
state.errored=true；
}最后{
state.loading=false；
state.end=true；
}
};
const responsePayload=已计算（（）=>{
返回状态；
});
返回{
责任书，
使用，
};
}

我又试了一次导致了错误

  const responsePayload = computed(() => {
    if (state.end === true) {
      return state;
    }
  });

而且这种事情是不允许的。我只想在承诺结束时才发出一次回应

  const state: any = reactive({
    responsePayload : {
      successData: {},
      loading: true,
      errored: false,
      errorMessage: '',
      errorCode: 0,
      end: false,
    }
  });

方法，如Object.assign。。不工作。 我别无选择，只能这样分别参考所有数据

function useUpdateResetToken(axios) {
  const { successData, errored, errorMessage, errorCode, loading, use: create } = usePromiseFn((toAddress) =>
    axios.post('/api/v1/admin/users/updateResetToken', { toAddress }),
  );
  const updateResetToken = (toAddress) => {
    return create(toAddress);
  };
  return { updateResetToken, successData, errored, errorMessage, errorCode, loading };
}

[更新] 这可以工作，但发射未定义

import { computed, reactive, toRefs, watch, ref } from '@vue/composition-api';
import { Data } from '@vue/composition-api/dist/component';

interface PromiseFields {
  successData: any;
  loading: boolean;
  errored: boolean;
  errorMessage: string;
  errorCode: number;
}

export default function usePromise(fn: any) {
  if (!fn) {
    throw new Error(`[usePromise]: 1st argument is required (must be a function)`);
  }

  if (typeof fn !== 'function') {
    throw new TypeError(`[usePromise]: argument has to be function, but received ${typeof fn}`);
  }

  const _loading = ref(false);
  const state: any = reactive({
    successData: {},
    loading: computed(() => _loading.value),
    errored: false,
    errorMessage: '',
    errorCode: 0,
  });

  let lastPromise;
  const use = async (...args: any) => {
    _loading.value = true;
    const promise = (lastPromise = fn(...args));
    try {
      const result = await promise;
      if (lastPromise === promise) {
        state.successData = result.data;
        state.errored = false;
      }
    } catch (error) {
      if (!error.response) {
        state.errorCode = 900;
        state.errorMessage = 'Network Error';
      }
      state.errorMessage = error.response.data.error;
      state.errorCode = error.response.status;

      state.errored = true;
    } finally {
      _loading.value = false;
    }
  };

  const responsePayload = computed(() => {
    if (_loading.value === false) {
      return state;
    } else {
      return undefined;
    }
  });
  return {
    responsePayload,
    use,
  };
}

import { computed, reactive, toRefs, watch, ref } from '@vue/composition-api';
import { Data } from '@vue/composition-api/dist/component';

interface PromiseFields {
  successData: any;
  loading: boolean;
  errored: boolean;
  errorMessage: string;
  errorCode: number;
}

export default function usePromise(fn: any) {
  if (!fn) {
    throw new Error(`[usePromise]: 1st argument is required (must be a function)`);
  }

  if (typeof fn !== 'function') {
    throw new TypeError(`[usePromise]: argument has to be function, but received ${typeof fn}`);
  }

  const _loading = ref(false);
  const state: any = reactive({
    successData: {},
    loading: computed(() => _loading.value),
    errored: false,
    errorMessage: '',
    errorCode: 0,
  });

  let lastPromise;
  const use = async (...args: any) => {
    _loading.value = true;
    const promise = (lastPromise = fn(...args));
    try {
      const result = await promise;
      if (lastPromise === promise) {
        state.successData = result.data;
        state.errored = false;
      }
    } catch (error) {
      if (!error.response) {
        state.errorCode = 900;
        state.errorMessage = 'Network Error';
      }
      state.errorMessage = error.response.data.error;
      state.errorCode = error.response.status;

      state.errored = true;
    } finally {
      _loading.value = false;
    }
  };

  const responsePayload = computed(() => {
    if (_loading.value === false) {
      return state;
    } else {
      return undefined;
    }
  });
  return {
    responsePayload,
    use,
  };
}