小编Joj*_*oji的帖子

我正在尝试像这个启动器一样配置我的 Gatsby 项目https://github.com/gatsbyjs/gatsby-starter-blog

在我的gatsby-node.js我有

const path = require(`path`)
const { createFilePath } = require(`gatsby-source-filesystem`)

exports.createPages = ({ graphql, actions }) => {
  const { createPage } = actions

  const blogPost = path.resolve(`./src/templates/blog-post.js`)
  return graphql(
    `
      {
        allMarkdownRemark(
          sort: { fields: [frontmatter___date], order: DESC }
          limit: 1000
        ) {
          edges {
            node {
              fields {
                slug
              }
              frontmatter {
                title
              }
            }
          }
        }
      }
    `
  ).then(result => {
    if (result.errors) {
      throw result.errors
    }

    // Create blog …

这是现场演示：https://codesandbox.io/s/strange-bash-qj7ld ?file=/src/App.js

所以我有一个这样的组件

const fn = () => {
  console.log("useState");
  return ["string"];
};

export default function App() {
  const [counter, setCounter] = useState(0);

  const [nonprimitive, setNonprimitive] = useState(fn());

  useEffect(() => {
    console.log("useEffect");
  }, [nonprimitive]);

  return (
    <>
      <button onClick={() => setCounter(counter + 1)}>Counter {counter}</button>
      <div>{nonprimitive[0]}</div>
    </>
  );
}

每次我单击该按钮时，计数器都会增加并且组件将重新渲染。然后fn()会再次调用，然后会返回一个数组。并在发生变化useEffect时触发nonprimitive。我有两个问题：

1. 为什么useEffect只触发一次，而不是每次后续调用都触发？nonprimitive是一个数组，它是非原始类型，因此即使其中的字符串项保持不变，它每次也应该不同。React 似乎正在幕后进行一些深入的比较。
2. 为什么useState每当组件重新渲染时，gets 都会打印两次？当我按下按钮时，即 console.log("useState");内部被调用两次。fn

我制作了一个实用程序类型来添加两个数字类型

type createArray<Len, Ele, Arr extends Ele[] = []> =  Arr['length'] extends Len ? Arr : createArray<Len, Ele, [Ele, ...Arr]>

type Add<A extends number, B extends number> = [...createArray<A, 1>, ...createArray<B, 1>]['length']

这样就Add<1,2>可以得到3数字类型。然而我正在努力实现Minus实用程序类型来实现minus计算

理想情况下Minus<3,1>会给你2。

我试图在浏览器（例如 Chrome）中获取数字和字符串的实际大小（以字节为单位）。

我了解到，在 JavaScript 中，数字以双精度表示，占用 64 位，而字符串是 UTF-16 代码单元，因此需要 2 个字节或 4 个字节。

我第一次尝试使用new Blob，但它将字符串组成字符编码为 UTF-8 而不是 UTF-16。我知道 Node 中有一个Buffer.fromAPI，但它在浏览器环境中不可用。

我的问题是如何从浏览器（例如 Chrome）获取数字和字符串的实际大小（以字节为单位）？

伙计们，我是Flow新手。

我有这个代码

type importItem = {
  name: string,
  groupRank: number,
  rank: number,
  node: Object,
};
function findTargetImportItem(importedItems: Array<importItem>, outOfOrderItem: importItem) : importItem {

return importedItems.find((importedItem: importItem) => importedItem.rank > outOfOrderItem.rank);}

我得到这个错误

Cannot return importedItems.find(...) because undefined [1] is incompatible with importItem [2].

     src/rules/import-order.js
 [2]  74? function findTargetImportItem(importedItems: Array<importItem>, outOfOrderItem: importItem) : importItem {
      75?   /**
      76?      * Return the import where the unordered imports will be moving towards
      77?      */
      78?   return importedItems.find((importedItem: importItem) => importedItem.rank > outOfOrderItem.rank);
      79? } …

我正在使用redux-toolkitwithcreateAsyncThunk来处理异步请求。

我有两种异步操作：

1. 从 API 服务器获取数据

2. 更新 API 服务器上的数据

export const updateData = createAsyncThunk('data/update', async (params) => {
  return await sdkClient.update({ params })
})

export const getData = createAsyncThunk('data/request', async () => {
  const { data } = await sdkClient.request()
  return data
})

我把它们extraReducers加到一片里

const slice = createSlice({
  name: 'data',
  initialState,
  reducers: {},
  extraReducers: (builder: any) => {
    builder.addCase(getData.pending, (state) => {
      //...
    })
    builder.addCase(getData.rejected, (state) => {
      //...
    })
    builder.addCase(
      getData.fulfilled,
      (state, { payload …

这几天在刷LeetCode，遇到了挑战162.Find Peak Element：

\n

峰值元素是严格大于其邻居的元素。

\n

给定一个整数数组nums，找到一个峰值元素，并返回其索引。如果数组包含多个 Peak，则返回任意 Peak 的索引。

\n

你可能会想象到nums[-1] = nums[n] = -\xe2\x88\x9e。

\n

您必须编写一个及时运行的算法O(log n)。

\n

限制条件：

\n

\n
• 1 <= nums.length <= 1000
\n
• -231 <= nums[i] <= 231 - 1
\n
• nums[i] != nums[i + 1]对于所有有效的i
\n

\n

本题是关于使用二分查找来查找数组中的峰值元素。

我知道我们可以将数组视为交替的升序和降序序列。这是我的解决方案

var findPeakElement = function(nums) {\n    if(nums.length <= 1) return 0\n    let left = 0, right = nums.length - …

我想编写一个函数，它接受压缩的字符串并输出解压缩的字符串。

压缩字符串如a2b2c3和解压缩字符串aabbccc 更多示例是

`a` -> `a`
`ab12` -> `abbbbbbbbbbbb`
`a3b2a2` -> `aaabbaa

我尝试实现它，但对于像这样的压缩字符串来说，它确实很混乱且有缺陷ab12

function isNumeric(num) {
    if (num === '') return false
    if (num === null) return false
    return !isNaN(num)
  }
  

function decompress(compressedStr) {
    const array = compressedStr.split('')
    let prevChar, str = ''
    for(let i = 0; i < array.length; i++) {
        if(i === 0) {prevChar = array[i]}
        if(isNumeric(array[i])) {
            str += prevChar.repeat(Number(array[i]))
            prevChar = null
        } else {
            if(!prevChar) prevChar = array[i] 
            else {
                str …

如果我们有

int a = 123;
int b = 123;

我们最终会为整数分配两个不同的内存块123，还是最终只为123和 变量分配一个内存块a，并且b只是加载到相同的内存地址？

关于什么

int a = 123;
int b = a;

这会改变答案吗？

我尝试打印出C++中两个变量的内存地址，发现它们是不同的

  int a = 123;
  cout << &a << endl; // 0x7fff46512da0
  int b = 123; 
  cout << &b << endl; // 0x7fff46512da4

这是否意味着在该特定环境中程序int 123在两个不同的内存块中存储重复项？

如果值是字符串，答案会改变吗？

我问这个问题的原因是我发现在Python中，如果原始值相等，那么内存地址总是相同的。我听说是因为常量池。我想知道这是否仍然适用于 C 和 C++？

例如

a = 123
b = 123

print(id(a)) // 9792896
print(id(b)) // 9792896