做和做有什么区别

const value = useMemo(() => {
     ...
});

和

const value = useMemo(() => {
     ...
}, []);

？

项目结构

我有以下项目结构：

/
| - .vscode/
| - - - - settings.json
|
| - packages/
| - - - - app/
| - - - - - - index.js
| - - - - - - package.json
| - - - - website/
| - - - - - - .vscode/
| - - - - - - - - settings.json
| - - - - - - index.html
| - - - - - - styles.scss
| - …

这是我第一次使用 useReducer() 钩子，我面临一个问题，我需要向它传递一个值作为参数。

这是我的减速器的样子：

  const memoizedReducer = useCallback((state, action) => {
    switch (action.type) {
      case "save":
        const refreshedBookData = {
          ...state.bookData,
          ...(state.bookData.totalSaves >= 0 && {
            totalSaves: state.bookData.totalSaves + 1,
          }),
          isSaved: true,
        };
       
        // Add the new book data to a Map which I have in a Context provider
        currentUser.addBookToVisitedBooks(bookId, refreshedBookData);
        
        // Update my context provider data
        currentUser.setData((prevCurrentUserData) => {
          return {
            ...prevCurrentUserData,
            ...(prevCurrentUserData.totalSaves >= 0 && {
              totalSaves: prevCurrentUserData.totalSaves + 1,
            }),
          };
        });
        
        return refreshedBookData;

    case "unsave": …

我有一个二进制存储桶（在 Firebase Storage 中），并且正在实现一个 node.js 云函数，它获取音频（audio/m4a 或 audio/caf），验证其格式和持续时间，然后将其 uri 与文档关联我的数据库（或者如果音频文件的持续时间无效则删除该音频文件）。

在数据库中创建文档之前，我需要验证音频文件。

为了从存储中下载文件，我使用此功能：

exports.downloadBinaryFileFromUrl = function (fileUrl) {
  /* This function downloads a binary-encoded file from its URL and returns it */
  return axios
    .get(fileUrl, {
      responseType: "arraybuffer",
    })
    .then((res) => Buffer.from(res.data, "binary"))
    .catch((err) => {
      if (err.response) {
        /* 
          The request was made and the server responded with a status code
          that falls out of the range of 2xx
        */
        throw err.response.data;
      } else if (err.request) {
        // Client never …

我已经实现了一个 HTTPs (onCall) 函数，如果工作成功完成，它会向客户端抛出一些错误或返回true。问题是我不明白为什么要返回 true （因为当我抛出错误时我不返回false）。

由于 HTTP 协议需要向客户端返回响应才能完成请求，那么我应该向客户端返回什么？我正在考虑删除我抛出的错误并返回一个经典的 HTTP 响应（状态代码、正文...）。

有任何想法吗？这是我在做什么：

exports.function = functions
  .region("us-central1")
  .runWith({ memory: "2GB", timeoutSeconds: 120 })
  .https.onCall(async (data, context) => {

        // Lazy initialization of the Admin SDK
        if (!is_function_initialized) {
          // ... stuff
          is_uploadImage_initialized = true;
        }
    
        // ... asynchronous stuff
    
        // When all promises has been resolved...
        // If work completed successfully
        return true;
    
       /*
         Is it correct instead ???
         return {code: "200 OK", date: date, body: message …

在我的 React 开发生涯中，我发现我们可以在 RN 应用程序中使用多种缓存/持久化。

1. 第一个是 React Native 直接提供的AsyncStorage。这允许我们将数据存储在用户设备的持久性中。

2. 我们还可以开发自己的内存缓存，它可以通过避免向服务器发出不必要的请求来提高应用程序的性能。

3. 最后一个对我来说不是缓存，是React Context。这个工具对于同步我们的应用程序路由来说非常酷。例如，典型的 UsersProvider，我们可以在其中存储用户数据的上下文。我也看到一些程序员也使用这个工具作为“缓存”。

我的问题是关于干净的代码。在结合了这 3 个“工具”的 React 架构中，我们如何正确地将它们的使用委托给应用程序的每个部分？

例如，在具有以下文件夹的项目中

components/
   auth/
      AuthForm.js


contexts/
    users/
        UsersContext.js


screens/
   Profile/
       EditProfile.js

services/
   api/
      firebase/
         content/
           getContentFeed.js
           cache/
              contentCache.js
   
         users/
             getUserData.js 
             cache/
                 usersCache.js

在不考虑第三个工具（上下文）的情况下，上下文是专门可从钩子/组件使用/访问的，每个“memoizer”（异步存储和内存中缓存）应该在哪里使用而不违反任何模式或“干净代码”规则？

AsyncStorage 是否设计为可在任何地方使用？我的意思是，在组件、钩子、上下文、类、utils、helpers、api...内部有完全的自由吗？

内存缓存怎么样？例如，看一下我的“usersCache.js”，我在其中存储从服务器获取的用户数据。正如你所看到的，我已经定义了自己的 api 来向后端发出请求...所以，如果在我的“getUserData.js”中我正在从缓存中存储/获取/更新数据，以避免发出不必要的请求，你会吗？您是否认为在 api 外部（组件内部或前端的任何位置）使用这种缓存是不良组织或反模式的产物？

有什么建议或建议吗？

我有一个关于多重orderBy工作原理的问题。

假设这些文件：

collection/   
    doc1/
       date: yesterday at 11:00pm
       number: 1
    doc2/
       date: today at 01:00am
       number: 6
    doc3/
       date: today at 13:00pm
       number: 0

如果我按这样的两个字段排序：

collection/   
    doc1/
       date: yesterday at 11:00pm
       number: 1
    doc2/
       date: today at 01:00am
       number: 6
    doc3/
       date: today at 13:00pm
       number: 0

这些文档是如何排序的？而且，反其道而行之又如何？

.orderBy("date", "desc")
.orderBy("number", "desc")
.get()

这会产生相同的顺序吗？

我有点困惑，因为我不知道它是否总是会在最后订购orderBy。

我有多个关于 FlatList 的问题，阅读文档后无法回答。

什么时候需要使用listKey，什么时候需要使用keyExtractor？有时，当我有同级 FlatList 时，我必须在每个列表中指定 listKey，如下所示：

      renderItem = (item, index) => (<View key={item.id} />)

      <FlatList
           keyExtractor={({id}) => id}
           listKey="MusicList"
           renderItem={this.renderItem}
       />

       <FlatList
           keyExtractor={({id}) => id}
           listKey="BooksList"
       />

我可以同时拥有listKey和keyExtractor吗？

到目前为止我一直在想的是 listKey 就像一个 keyExtractor 但对于列表来说，并且 keyExtractor 标识列表中的每个项目......是吗？

谢谢。

当我将 Date 对象写入 Firestore 时，一切正常，我可以在数据库中看到以“时间戳”类型存储的日期。如果我尝试将 Date 对象传递给云函数，我不知道为什么，但是当我将它从云函数存储到 firestore 数据库时它是一个空对象。

  firebase.functions().httpsCallable("myFunction")({date: new Date()}) <---- // this doesn't work

因此，我决定在将 Date 对象发送到云函数之前，将其转换为客户端的 firestore 时间戳。如下：

  date = firebase.firestore.Timestamp.fromDate(date);
  firebase.functions().httpsCallable("myFunction")({date})

然后，如果我在云函数中获取它并将其存储在我的 firestore 中，我会看到一个带有“seconds”和“nanoseconds”字段的对象，但不是时间戳（我的意思是它不是以 Timestamp 类型存储的）。 . 所以当我得到这个日期时，我不能应用方法 .toDate()

在这种情况下，有没有什么好方法可以将日期存储为时间戳而不是对象？

我一直在尝试使用这些安全规则使子集合中的所有文档完全可读：

 match /books {
     allow write, update, delete: if false; // This collection cannot be modified
  
     match /sells {
         allow read: if true; // All documents and sub-collections of this collection are readable
     }
 }

但是，当我尝试读取 sell 子集合的文档时，我收到 Firebase 权限错误。我究竟做错了什么？

这样做的区别

const Card = ({ contentType }) => {
   const isPost = useRef(contentType === "post");

   ...
}

和这个

const Card = ({ contentType }) => {
   const isPost = contentType === "post";

   ...
}

是不是在第一种情况下， isPost 只会被计算一次并被记忆，而在另一种情况下，它会在每次重新渲染时计算，对吗？

因此，如果我们进行像这样的计算，每次重新渲染时值都相同，我们是否应该将它们放入 useRef 中？

我知道 useRef 用于避免重新渲染时的值更改，某种 useState 不会重新渲染组件，但是如果该值是常量并在组件主体中计算，该怎么办？

注意：我知道这看起来像是“个人意见”，但我的问题是关于性能影响和 useRef 钩子的正确使用。

我有一个自定义标头组件：

function CustomHeader() {
    return (
       <View style={{ height: headerHeight }}>
          {/* Some buttons in a row... */}
          <View 
            style={{ 
              position: "absolute",
              alignSelf: "center",
              top: headerHeight/2
            }} 
          />
       </View>
    )
}

正如您所看到的，我绝对将视图定位在标题的中心，顶部为 headerHeight/2。

为了获得标题高度，我正在做：

 import { useHeaderHeight } from "@react-navigation/elements";

 const headerHeight = useHeaderHeight();

但是...它返回我 0，就像我在堆栈导航器中所做的那样：

 screenOptions={{
    headerShown: false,
 }}

因为，我正在屏幕内渲染自定义标头。

我怎么解决这个问题？我需要获取堆栈导航器中使用的默认标题高度，以便对我的组件进行风格化。