Javascript 在运行下一个变量之前重置值

我在

getFriendId（）

内部运行一个graphql查询，该查询返回一个id，然后是一个变异（在

addFriend（）

内部，它使用该id以及一个输入（电子邮件）用户输入。问题是，在第一次尝试时，变异工作正常，值正确。但是，当我更改输入的电子邮件地址并再次运行查询/变异时，使用的是我上次尝试的值

例如，在第二次尝试中，变异仍然使用我们在第一次尝试中获得的id。因此，基本上，

setId

和setEmail的值没有及时更新。我如何解决这个问题

const [id, setId] = useState('');
const [friendEmail, setFriendEmail] = useState('');

const [loadUsers, { loading, data, error }] = useLazyQuery(LoadUsersQuery);
const [createUserRelationMutation, { data: addingFriendData, loading: addingFriendLoading, error: addingFriendError }] = useCreateUserRelationMutation();

const getFriendId = () => {
    console.log('Email', friendEmail.toLocaleLowerCase());
    loadUsers({
      variables: {
        where: { email: friendEmail.toLocaleLowerCase() },
      },
    });
    if (data) {     
        console.log('ID', data.users.nodes[0].id);
        setId(data.users.nodes[0].id);      
    } 
    addFriend();
  };

  const addFriend = () => {
    console.log('Whats the Id', Number(id));
       createUserRelationMutation({
        variables: {
               input: {relatedUserId: Number(id), type: RelationType.Friend, userId: 7 }
            },
       });
       if (addingFriendData){
         console.log('Checking')
         console.log(data);
       }
       if(addingFriendError){
         console.log('errorFriend', addingFriendError.message);
         setErrorMessage(addingFriendError.message);
       }
  }


const handleSubmit = () =>
    {getFriendId();};

返回的内容如下所示：

<Input
                  placeholder="Email"
                   onChangeText={(text) => setFriendEmail(text)}
                  value={friendEmail}
                />

<Button
                  rounded
                  onPress={() => handleSubmit()}>
                    Add Friend{' '}
                </Button>

setFriendEmail（文本）}
值={friendEmail}
/>
handleSubmit（）}>
添加好友{'}

我的代码的当前图片：

export const AddFriendEmailPage: React.FunctionComponent<AddFriendEmailPageProps> = ({
  toggleShowPage,
  showAddFriendEmailPage,
}) => {
  const [id, setId] = useState('');
  const [friendEmail, setFriendEmail] = useState('ana@hotmail.com');
  const [errorMessage, setErrorMessage] = useState('');

  const [loadUsers, { loading, data, error }] = useLazyQuery(LoadUsersQuery, {
    variables: {
      where: { email: friendEmail.toLocaleLowerCase() },
    },
    onCompleted: ( data: any ) => {
      console.log('Working');
      if (data) {
        console.log(data);
        if (data.users.nodes.length == 0) {
          console.log('No user');
          setErrorMessage('User Not Found');
        } else {
          const friendId = data.users.nodes[0].id; 
          console.log('friendId', friendId);
          // setId(data.users.nodes[0].id);

          const relationParams = {
            input: {
              relatedUserId: Number( friendId ),
              type: RelationType.Friend,
              userId: 8, // current user?
            },
          }                             
          console.log("relation params", relationParams);

          // fire second query/mutation using received data
          createUserRelationMutation( { variables: relationParams } );

        }
      } else {
        if (error) {
          setErrorMessage(error.message);
        }
      }
    }
  });

  const [
    createUserRelationMutation,
    {
      data: addingFriendData,
      loading: addingFriendLoading,
      error: addingFriendError,
    },
  ] = useCreateUserRelationMutation( {
    variables: {
      input: {
        relatedUserId: Number(id),
        type: RelationType.Friend,
        userId: 8,
      },
    },
    onCompleted: ( addingFriendData: any) => {
      console.log("relation created", addingFriendData);
    }
  });

  return (
            <View style={scaledAddFriendEmailStyles.searchTopTextContainer}>
            </View>
            <View style={scaledAddFriendEmailStyles.searchFieldContainer}>
              <Item style={scaledAddFriendEmailStyles.searchField}>
                <Input
                  placeholder="Email"
                  //onChangeText={(text) => setFriendEmail(text)}
                  value={friendEmail}
                />
              </Item>
              <View style={scaledAddFriendEmailStyles.buttonContainer}>
                <Button
                  rounded
                  style={scaledAddFriendEmailStyles.button}
                  //onPress={() => handleSubmit()}
                  onPress={()=>loadUsers()}
                  >
                  <Text style={scaledAddFriendEmailStyles.text}>
                    Add Friend{' '}
                  </Text>
                </Button>
              </View>
  );
};

export const AddFriendEmailPage:React.FunctionComponent=({
切换ShowPage，
showAddFriendEmailPage，
}) => {
const[id，setId]=useState（“”）；
const[friendEmail，setFriendEmail]=useState（'ana@hotmail.com');
常量[errorMessage，setErrorMessage]=使用状态（“”）；
const[loadUsers，{loading，data，error}]=useLazyQuery（LoadUsersQuery{
变量：{
其中：{email:friendEmail.toLocaleLowerCase（）}，
},
未完成：（数据：任何）=>{
console.log（'Working'）；
如果（数据）{
控制台日志（数据）；
if（data.users.nodes.length==0）{
console.log（“无用户”）；
setErrorMessage（“未找到用户”）；
}否则{
const-friendId=data.users.nodes[0].id；
console.log（'friendId'，friendId）；
//setId（data.users.nodes[0].id）；
常量关系参数={
输入：{
relatedUserId:编号（friendId），
类型：RelationType.Friend，
userId:8，//当前用户？
},
}                             
log（“关系参数”，relationParams）；
//使用接收到的数据进行第二次查询/变异
CreateUserRelationSpection（{variables:relationParams}）；
}
}否则{
如果（错误）{
setErrorMessage（error.message）；
}
}
}
});
常数[
CreateUserRelationVariation，
{
数据：添加FriendData，
加载：添加Friendloading，
错误：添加FriendError，
},
]=UseCreateUserRelationSpection（{
变量：{
输入：{
relatedUserId:编号（id），
类型：RelationType.Friend，
用户ID:8，
},
},
未完成：（添加好友数据：任意）=>{
console.log（“已创建关系”，添加FriendData）；
}
});
返回(
setFriendEmail（文本）}
值={friendEmail}
/>
handleSubmit（）}
onPress={（）=>loadUsers（）}
>
添加好友{'}
);
};

两者（突变和懒散查询）都可以定义

onCompleted

（内部选项对象）函数来处理响应/结果

如果（数据）

未等待结果-

数据来自组件范围，将在第一次
useLazyQuery
触发后定义

onCompleted
处理程序接收
数据
作为参数，它将是当前请求结果（与组件范围中的
数据
不同-稍后，在下一次渲染中，“流”将相同）

更新
其中
useCreateUserRelationSpection
来自何处。它是一个自定义钩子。如果是，您能显示它吗？请注意，建议不用于扩展讨论；此对话已被删除。
 const [loadUsers, { loading, data, error }] = useLazyQuery(LoadUsersQuery, {
    variables: {
      where: { email: friendEmail.toLocaleLowerCase() },
    },
    onCompleted: ( data ) => {
      // getFriendId
      console.log('Working');
      if (data) {
        console.log(data);
        if (data.users.nodes.length == 0) {
          console.log('No user');
          setErrorMessage('User Not Found');
        } else {
          const friendId = data.users.nodes[0].id; 
          console.log('friendId', friendId);
          // needed?
          // setId(data.users.nodes[0].id);

          const relationParams = {
            input: {
              relatedUserId: Number( friendId ),
              type: RelationType.Friend,
              userId: 5, // current user?
            },
          }                             
          console.log("relation params", relationParams);

          // fire second query/mutation using received data
          createUserRelationMutation( { variables: relationParams } );

        }
      } else {
        if (error) {
          setErrorMessage(error.message);
        }
      }
    }
  });

  const [
    createUserRelationMutation,
    {
      data: addingFriendData,
      loading: addingFriendLoading,
      error: addingFriendError,
    },
  ] = useMutation(CreateUserRelationMutation, {
    variables: {
      input: {
        relatedUserId: Number(id),
        type: RelationType.Friend,
        userId: 5,
      },
    },
    onCompleted: ( data ) => {
      console.log("relation created", data);
    }
  });