20230524----重返学习-useEffect()与useLayoutEffect()-TaskOA任务管理系统

最新推荐文章于 2024-06-07 10:29:21 发布
最新推荐文章于 2024-06-07 10:29:21 发布
阅读量560 收藏
点赞数 1
分类专栏： 重返学习 React 文章标签： 学习 数学建模 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seetoyou/article/details/130857853
版权

day-077-seventy-seven-20230524-useEffect()与useLayoutEffect()-TaskOA任务管理系统

useEffect()与useLayoutEffect()

useEffect()与useLayoutEffect()的作用：在函数组件中使用生命周期函数。

Hook函数useEffect()细节

  1. useEffect必须处于函数组件的顶层，不能嵌入到判断/循环等操作中。

    // useEffect必须处于函数组件的顶层「不能嵌入到判断/循环等操作中」
if (x > 12) {
  useEffect(() => {
      console.log('AAA')
  })
} 
//修改为
useEffect(() => {
  if (x > 12) {
      console.log('AAA')
  }
}, [x]) 

    import { useState, useEffect, useLayoutEffect } from 'react'
import { Button } from 'antd'

export default function Demo() {
  let [x, setX] = useState(10),
    [y, setY] = useState(20),
    [z, setZ] = useState(30)

    // useEffect必须处于函数组件的顶层，不能嵌入到判断/循环等操作中。
    if(x>12){
      useEffect(()=>{
        console.log(`AAA`);
      })
    }

  return <div className="demo" style={{ padding: '50px' }}>
    <p>{x} - {y} - {z}</p>
    <Button type='primary' size='small' onClick={() => setX(x + 1)}>修改X</Button>
    <Button type='primary' size='small' onClick={() => setY(y + 1)}>修改Y</Button>
    <Button type='primary' size='small' onClick={() => setZ(z + 1)}>修改Z</Button>
  </div>
}

    • 应修改为：

      import { useState, useEffect, useLayoutEffect } from 'react'
import { Button } from 'antd'

export default function Demo() {
  let [x, setX] = useState(10),
    [y, setY] = useState(20),
    [z, setZ] = useState(30)

  // 会报错；
  // useEffect必须处于函数组件的顶层，不能嵌入到判断/循环等操作中。
  // if (x > 12) {
  //   useEffect(() => {
  //     console.log(`AAA`);
  //   })
  // }

  useEffect(() => {
    if (!(x > 12)) {
      return
    }

    console.log(`AAA`);
  })



  return <div className="demo" style={{ padding: '50px' }}>
    <p>{x} - {y} - {z}</p>
    <Button type='primary' size='small' onClick={() => setX(x + 1)}>修改X</Button>
    <Button type='primary' size='small' onClick={() => setY(y + 1)}>修改Y</Button>
    <Button type='primary' size='small' onClick={() => setZ(z + 1)}>修改Z</Button>
  </div>
}

  2. 在useEffect传递的callback函数中，不写返回值或者只能返回一个函数。

    // 在useEffect传递的 callback 函数中，不写返回值或者只能返回一个函数，所以导致 callback 不能基于 async 修饰「因为一但修饰，则直接返回 promise 实例」
const query = async () => {
  await api.query()
}
//应修改为：
useEffect(() => {
  // (async () => {
  //     await api.query()
  // })()
  query()
}, [])
    • 所以导致，callback函数不能基于async修改。

      • 因为一旦修饰，则直接返回promise实例对象。

        // 会报错；
// 在useEffect传递的callback函数中，不写返回值或者只能返回一个函数。所以导致，callback函数不能基于async修改。
useEffect(async () => {
  // await api.query()
},[])

        • 修改为：

          useEffect(async () => {
  // 
  (async () => {
    await api.query()
  })()
}, [])

          const query = async () => {
  await api.query()
}
useEffect(async () => {
  query()
}, [])

useEffect()基本语法回顾

  1. useEffect(callback) 在第一次渲染完毕和每一次组件更新完毕后，触发callback执行。

    • 等价于 componentDidMount 和 componentDidUpdate。

  2. useEffect(callback,[]) 只在第一次渲染完毕后触发执行。

    • 等价于 componentDidMount。

  3. useEffect(callback,[依赖的状态]) 在第一次渲染完毕后触发执行，以及依赖的状态发生改变后触发执行。

    • 类似于Vue2中watch监听器。

  4. useEffect(() => callback, []) 组件销毁之前，触发callback执行。

    useEffect(() => {
  // 第一次渲染完毕做的事情
  return () => {
    // 组件销毁之前做的事情
  }
}, [])

  5. useEffect(() => callback) 当用户第一次修改了状态，本次闭包触发了()=>callback第一次状态更新返回了第一个callback。之后下次闭包形成。

    • 之后等待用户第二次修改了状态。直到下次闭包触发了第二次状态更新，就会执行第一个callback，之后才是触发了()=>callback第二次状态更新返回了第二个callback。
    • 之后等待用户第三次修改了状态。

  6. useEffect(() => callback,[依赖的状态]) 当用户第一次修改了依赖的状态，本次闭包触发了()=>callback第一次状态更新返回了第一个callback。之后下次闭包形成。

    • 之后等待用户第二次修改了依赖的状态。直到下次闭包触发了第二次状态更新，就会执行第一个callback，之后才是触发了()=>callback第二次状态更新返回了第二个callback。
    • 之后等待用户第三次修改了依赖的状态。

  • 给useEffect传递的callback函数，其内部可以不写返回值，如果设置返回值，则"必须"返回一个函数！

    useEffect(() => {
  return () => {
    // 但凡有状态更新（或者依赖的状态发生改变），在组件更新之前，先把此函数执行 -> 通俗理解：产生新的闭包之前，处理的事情
  }
}, 不写数组或者设置依赖项)

useLayoutEffect()

  • useEffect()与useLayoutEffect()：

    • useEffect()：基于useEffect()放在effect链表中的callback函数，会在组件渲染与更新完毕后触发执行。

      • 实际上已经GUI线程的绘制与effect链表中的执行是两个线程同步进行的。
      • 完毕是指：已经把VirtualDOM渲染为真实DOM，并且浏览器已经把真实DOM绘制到页面中。
        • 也就是说，已经能在浏览器页面中看到该新DOM了。

    • useLayoutEffect：基于useLayoutEffect放在effect链表中的callback函数，会阻碍GUI线程的渲染，也就是在通知effect链表中的callback函数执行的时候，让浏览器停止对真实DOM的绘制，需要先把callback执行完，再去绘制。

      • 实际上是本来GUI线程的绘制与effect链表中的执行是两个线程要同步进行的。用了useLayoutEffect，就先执行effect链表中的执行，等effect链表中的执行完毕，之后再进行GUI线程的绘制。

    • VirtualDOM的生命周期：

      • 第一次渲染：
        • render返回jsx。
        • 对jsx变成createElement()格式。
        • createElement()格式变成虚拟DOM。
        • 虚拟DOM变成真实DOM。
        • 浏览器把真实DOM渲染到页面上，让用户可以看到。
          • 这一步就是useEffect与useLayoutEffect的区别。

ref的处理

  • ref的处理

    • 在类组件中：

      1. ref的设置方式：
        • 字符串：
          --> this.refs.AAA
        • 函数：<div ref={refObject=>this.box=refObject}> --> this.box
        • 基于React.createRef处理：
      2. ref的作用：
        • 给元素设置ref，其目的是获取这个真实DOM，操作非受控数组
        • 给子组件设置ref
          • 子组件是类组件：则是为了获取子组件的实例
            • 拿到实例后，就可以直接调用其实例上的属性和方法了！
          • 子组件是函数组件：默认会报错，说明函数组件不能直接设置ref。

    • 在函数组件中：

      1. ref的设置方式：

        • 字符串方式已经被淘汰了。

          <span ref="myRef">01</span>

          • 这样使用字符串方式声明 ref 并直接访问它的方式在函数组件中是不可行的！

          • 间接的做法：

            import React, { useRef } from "react";
export default function Demo() {
  const refs = useRef({});

  // 创建一个字符串 ref
  const myRef = useRef(null);

  // 将字符串 ref 存储到对象中
  refs.current["myRef"] = myRef;

  // 使用字符串方式获取 ref
  const getRef = (refName) => {
    return refs.current[refName];
  };

  const handleClick = () => {
    // 通过字符串方式获取 ref
    const ref = getRef("myRef");
    console.log(`getRef("myRef")`,ref.current); // 输出 ref 对应的值
  };

  return (
    <div>
      <span ref={myRef}>....</span>
      <button onClick={handleClick}>获取 ref 值</button>
    </div>
  );
}

        • 设置为函数。

          let spanBox1 = null
<span ref={refObject => spanBox1 = refObject}>01</span>
console.log('spanBox1', spanBox1);//第一个span。

        • 设置为ref对象。

          let spanBox2 = createRef()
<span ref={spanBox2}>02</span>
console.log('spanBox2.current', spanBox2.current);//第二个span。

          let spanBox3 = useRef()
<span ref={spanBox3}>03</span>
console.log('spanBox3.current', spanBox3.current);//第三个span。

        import { useState, useEffect, createRef,useRef } from "react";

export default function Demo() {
  let spanBox1 = null
  let spanBox2 = createRef()
  let spanBox3 = useRef()
  useEffect(() => {
    console.log('spanBox1', spanBox1);//第一个span。
    console.log('spanBox2.current', spanBox2.current);//第二个span。
    console.log('spanBox3.current', spanBox3.current);//第三个span。
  }, [])
  return (
    <div>
      <span ref={refObject => spanBox1 = refObject}>01</span>
      <span ref={spanBox2}>02</span>
      <span ref={spanBox3}>03</span>
    </div>
  );
}

      2. createRef()与useRef():

        • createRef可以用在任何组件中，useRef只能作用在函数组件中！
        • 在函数组件中，使用createRef和useRef是有区别的：

          • 使用createRef，则在每一次组件渲染和更新的时候即函数重新执行的时候，遇到createRef都会重新创建一个新的ref对象！这样比较浪费性能。

            import { useState, useEffect, createRef, useRef } from "react";
let prev
export default function Demo() {
  let [, setRandom] = useState(0)
  let spanBox = createRef()

  if (!prev) {
    prev = spanBox//把第一次渲染创建的ref对象赋值给prev。
  } else {
    // 在组件更新后，函数会重新执行，遇到createRef，又创建了一个ref对象。此时我们对比两次创建的是否是相同的对象！！
    console.log(`prev===spanBox`, prev === spanBox);//false;
  }
  useEffect(() => {
    console.log('spanBox.current', spanBox.current);
  })
  return (
    <div>
      <span ref={spanBox}>...</span>
      <button onClick={() => setRandom(+new Date())}>更新</button>
    </div>
  );
}

          • 使用useRef，在每一次组件渲染和更新的时候，并不会创建新的ref对象，而是把之前第一次创建的ref对象直接拿过来使用，节约性能。

            • 所以在函数组件中，我们使用useRef()来代替createRef()。

              import { useState, useEffect, createRef, useRef } from "react";
let prev
export default function Demo() {
  let [, setRandom] = useState(0)
  let spanBox = useRef()

  if (!prev) {
    prev = spanBox//把第一次渲染创建的ref对象赋值给prev。
  } else {
    // 在组件更新后，函数会重新执行，遇到useRef，依旧返回了之前的旧ref对象。此时我们对比两次创建的是否是相同的对象！！
    console.log(`prev===spanBox`, prev === spanBox);//true;
  }
  useEffect(() => {
    console.log('spanBox.current', spanBox.current);
  })
  return (
    <div>
      <span ref={spanBox}>...</span>
      <button onClick={() => setRandom(+new Date())}>更新</button>
    </div>
  );
}

      3. 设置REF的作用。

        • 给元素设置，其目的是获取真实DOM。
        • 给子组件设置。
          • 类组件：获取子组件的实例。
          • 函数组件：不能直接设置，需要经过处理。
            • 好像也可以用给prop传一个对象类型的ref值,不过prop好像不能改值;
      • 让函数组件更新，只能通过useState()拿到一个修改状态值的函数，之后调用那个函数，才让视图更新。

  • 拿到组件实例:

    • 给类组件类型的子组件设置ref，其目的是获取子组件实例。

      import { useState, useEffect, createRef, useRef,Component } from "react";
// 创建子组件-类组件
class Child extends Component{
  render(){
    return <div className="child-box">
      <span>子组件-类组件</span>
    </div>
  }
}
// 父组件
export default function Demo() {
  let children = useRef()
  useEffect(()=>{
    console.log(`children.current`,children.current);
  },[])
  return (
    <div>
      {/* //给类组件类型的子组件设置ref，其目的是获取子组件实例。这样想操作子组件中的那些东西，在子组件内部，就把这些东西挂载到实例上就可以了。 */}
      <Child ref={children}></Child>
    </div>
  );
}

      • 这样想操作子组件中的那些东西，在子组件内部，就把这些东西挂载到实例上就可以了。

        import { useState, useEffect, createRef, useRef, Component } from "react";
//给类组件类型的子组件设置ref，其目的是获取子组件实例。
// 创建子组件-类组件
class Child extends Component {
  spanBox = createRef()
  state = {
    x: 100,
  }
  submit = () => { }
  render() {
    return <div className="child-box">
      <span ref={this.spanBox}>子组件-类组件</span>
    </div>
  }
}
// 父组件
export default function Demo() {
  let children = useRef()
  useEffect(() => {
    console.log(`children.current`, children.current);
  }, [])
  return (
    <div>
      <Child ref={children}></Child>
    </div>
  );
}

    • 给函数类型的子组件设置ref，默认是报错的。

      <Child x="10" ref={children}>Child是函数类型组件</Child>

      • 报错：Warning: Function components cannot be given refs. Attempts to access this ref will fail. Did you mean to use React.forwardRef()?。

        import { useState, useEffect, createRef, useRef, Component } from "react";
// 创建子组件-函数
const Child=function Child(props)  {
  console.log(props);
    return <div className="child-box">
      <span>子组件-类组件</span>
    </div>
}
// 父组件
export default function Demo() {
  let children = useRef()
  useEffect(() => {
    console.log(`children.current`, children.current);
  }, [])
  return (
    <div>
      <Child x="10" ref={children}></Child>
    </div>
  );
}

      • 我们需要把函数子组件，基于React.forwardRef进行处理，实现ref的转发。

        • 就是把调用子组件的时候，设置的属性(包含ref属性)，都作为实参传递给子组件。

          const Child = forwardRef(
  function Child(props, ref) {
    // props是传递的属性；ref是调用子组件的时候，设置的ref属性值。
    //...
  }
)

      • 此时在子组件内部，如果我们把转发的ref值，赋值给子组件的某个元素的ref属性，这样在父组件中就可以直接获取到子组件这个元素的真实DOM了。

      • 在子组件内部，还可以基于useImperativeHandle()这个API，把子组件内部的某些内容直接返回，这样在父组件中也就可以调用这些信息了！

模拟forwardRef

  • forwardRef()源码模拟

    // 模拟forwardRef
function forwardRef1(FunctionalComponent) {
  // FunctionalComponent是传递进来的函数组件。
  // 返回的是一个做了处理的函数组件---真实源码中返回并不是函数组件，也不是类组件。而是内部专门做处理的一个专门类型。
  return function Proxy() {
    // 在源码中，返回的Proxy会接收到传递的属性以及为其设置的ref。
    return <FunctionalComponent></FunctionalComponent>
    // 在渲染这个组件的时候，把拿到的属性和ref，传递给这个组件！

  }
}

    ```jsx
import { useState, useEffect, createRef, useRef, Component, forwardRef } from "react";
// 创建子组件-函数
const Child = forwardRef(
  function Child(props, ref) {
    // props是传递的属性；ref是调用子组件的时候，设置的ref属性值。
    console.log(`props`, props, `;ref`, ref);
    return <div className="child-box">
      <span>子组件-类组件</span>
    </div>
  }
)
// 父组件
export default function Demo() {
  let children = useRef()
  useEffect(() => {
    console.log(`children.current`, children.current);
  }, [])
  return (
    <div>
      <Child x="10" ref={children}></Child>
    </div>
  );
}
```

  • forwardRef()的运行机制

    import { useState, useEffect, createRef, useRef, Component, forwardRef } from "react";
// 创建子组件-函数
const Child = forwardRef(
  function Child(props, ref) {
    // props是传递的属性；ref是调用子组件的时候，设置的ref属性值。
    console.log(`props`, props, `;ref`, ref);
    return <div className="child-box">
      <span>子组件-类组件</span>
    </div>
  }
)
// 父组件
export default function Demo() {
  let children = useRef()
  useEffect(() => {
    console.log(`children.current`, children.current);
  }, [])
  return (
    <div>
      <Child x="10" ref={children}></Child>
    </div>
  );
}

  • forwardRef()的ref转发流程

    import { useState, useEffect, createRef, useRef, Component, forwardRef } from "react";
// 创建子组件-函数
const Child = forwardRef(
  function Child(props, ref) {
    // props是传递的属性；ref是调用子组件的时候，设置的ref属性值。
    // console.log(`props`, props, `;ref`, ref);
    return <div className="child-box">
      <span ref={ref}>子组件-类组件</span>
    </div>
  }
)
// 父组件
export default function Demo() {
  let children = useRef()
  useEffect(() => {
    console.log(`children.current`, children.current);
  }, [])
  return (
    <div>
      <Child x="10" ref={children}></Child>
    </div>
  );
}

  • forwardRef()配合useImperativeHandle()后的ref转发加强-可转发对象

    • 在函数类型的子组件中,我们想把那些东西传给父组件,就把那些东西放在作为forwardRef()入参的函数组件内部中useImperativeHandle()第二个回调函数入参中的return返回的对象中;

      import { useState, useEffect, createRef, useRef, Component, forwardRef, useImperativeHandle } from "react";
// 创建子组件-函数
const Child = forwardRef(
  function Child(props, ref) {
    // 基于useImperativeHandle()这个Hook函数，可以把函数类型子组件内部的某些东西返回，赋值给转发过来的ref对象中的current属性！
    useImperativeHandle(ref, () => {
      // 在函数类型的子组件中,我们想把那些东西传给父组件,就把那些东西放在forwardRef()第一个入参的函数组件内部中useImperativeHandle()第二个回调函数中的这个return返回的对象中;
      return {
        n: 100,
        m: 200,
      }
    })
    return <div className="child-box">
      <span>子组件-类组件</span>
    </div>
  }
)
// 父组件
export default function Demo() {
  let children = useRef()
  useEffect(() => {
    console.log(`children.current`, children.current);//{n: 100,m: 200,}
  }, [])
  return (
    <div>
      <Child x="10" ref={children}></Child>
    </div>
  );
}

TaskOA任务管理系统

  • 做管理系统,要用UI框架,一般React得用antd;

    • 用antd得考虑汉化,汉化分成组件库本体及日期插件如dayjs。

  • PC端UI组件库：

    • 比较核心的组件，操作也复杂一些，可以当成一个技能来学的。
      • 表格组件
        • 后台管理系统上基本上最主要的了。
      • 表单及表单校验
        • 基本上最重要的了。
      • 弹出层
      • 文件上传
      • 日历
        • 这个主要是在它上面集成其它东西的。
      • …
    • 如何看一个UI组件。
      • 如果有案例，先看案例。
      • 结合案例，查看该组件的核心API。
      • 查看一个UI组件库的API列表，思考着能用这些API达到什么自定义的效果。
      • 在控制台上查询页面上已修改得差不多的UI组件，之后查看UI组件的DOM元素，看它的类名，根据类名大概猜出那个类是重要的，根据需要自定义修改样式。

  • 对着一份设计图，前后端都可以同步开始自己的任务。

    • 如果可以，前端先问后端大概能给什么接口，接口的作用具体是什么。
    • 前端可以先对着设计图搭页面。
    • 如果页面已经搭完，那么前端可以先做一些假数据，根据这些假数据进行交互的设计。
    • 后端写完接口，进行联调。

进阶参考

  1. table标签
方朝端
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2005-2012信息系统项目管理师历年真题
10-19
最新最全2005-2012信息系统项目管理师历年真题（含上午题、案例分析、论文）试题和答案.
Atum2：Atum 2：重返沙滩-向Minecraft添加了全新的埃及主题尺寸
02-03
[Atum 2] 在下载 如何通过Maven获得Atum 2 添加到您的build.gradle中： repositories { maven { // url of the maven that hosts Atum 2 files ... } } dependencies { // compile against Atum 2 ...
20230526----重返学习-TaskOA任务管理系统-其它Hook
seetoyou的博客
05-26 680
搭建结构：DOM骨架antd组件库的运用按需加载与按需导入国际化-由英文化改为中文化核心组件Table表格组件列的构建及格式化处理表格的分页列的选择列的排序列的筛选Form表单数据的处理和收集规则校验及触发机制内置触发通过实例触发内置规则自定义规则实例及方法等Modal与Dialog对话框文件上传等操作搭好骨架写样式样式私有化的处理方案UI组件库中样式的修改那些提取为全局样式数据通信跨域配置。
20230531----重返学习-redux总步骤-TaskOA-react路由管理方案react-router-dom
seetoyou的博客
06-01 333
确定基础骨架目录。编写基础骨架代码。定义派发标识。定义派发标识。创建基础reducer骨架。创建基础reducer骨架。创建基础reducer骨架。编写具体reducer业务逻辑。编写具体reducer业务逻辑。合并reducer并导出。合并reducer并导出。创建redux公共容器。创建redux公共容器。创建action的基础骨架。创建action的基础骨架。创建action的基础骨架。修改具体action的派发逻辑。修改具体action的派发逻辑。合并action并导出。合并action并导出。
TASK-OA项目reduxt实现
weixin_41675013的博客
06-27 732
TASK项目 1.搭建项目 2.ANTD 3.数据处理 4.redux create-react-app 脚手架 $ npm i create-react-app -g $ create-react-app xxx 或者 $ npx create-react-app xxx 【yarn】 向配置less 1.-->$ git init -y (在一个大仓库就直接提交到历史区) (如果项目不在一个仓库或者本身也不是一个仓库，则需要把项目初始化成一个git仓库,代码提交到历史区 ) ...
react使用hook实现TodoList
Binglianxiaojiao的博客
12-26 513
全篇重点掌握react函数组件的使用、react的hook的定义与使用、函数式组件的父子间通讯、函数式组件的多级组件间通讯等，相应的知识点笔记后期会更新上，尽请期待.....注意点：需要调用ArrDisposeFn(()=>[...arr])回调方法，实现逻辑层与视图层同步改变，如果不调用会出现逻辑层数据改变，视图层数据不更新的bug。整个程序使用到的知识点：自定义组件、父子组件间通讯、多级组件间通讯、hook、自定义hook等。TodoList.jsx文件。Input.jsx文件。List.jsx文件。
Task类使用总结
weixin_33941350的博客
12-27 964
由于Framework 4.0和Framework 4.5对Task类稍微有些不同，此处声明以下代码都是基于Framework 4.5 Task类和Task&lt;TResult&gt;类，后者是前者的泛型版本。TResult类型为Task所调用方法的返回值。 主要区别在于Task构造函数接受的参数是Action委托，而Task&lt;TResult&gt;接受的是Func&lt;TRes...
tf-idf实现文本向量化和关键词提取——python版本
zzl12880的博客
07-18 724
import jieba import math text1 = "女排北京奥运会夺冠" text2 = "北京奥运会的羽毛球男单决赛" text3 = "中国队女排夺北京奥运会金牌重返巅峰观众欢呼女排女排女排" text4 = "公告显示闻泰科技与格力创投将共同出资设立珠海得尔塔科技有限公司作为指定收购主体然后以现金方式购买" text5 = "资料显示格力创投成立于2017年格力集团全资控股的一家投资机构共有1次公开投资事件参投企业主要以科技、医药为主" text6 = "欧菲光主要依靠这一相关业务成.
min-max容斥
Hellsegamosken
05-14 2942
min-max 容斥 简单来说，我们想要通过集合最小值计算出最大值： max⁡(S)=∑T⊆Smin⁡(T)⋅(−1)∣T∣−1\max(S)=\sum_{T\subseteq S}\min(T)\cdot (-1)^{|T|-1}max(S)=T⊆S∑​min(T)⋅(−1)∣T∣−1 证明是构造一个映射f(T)，设 x 为最大值，f(T)→f(T⊕x)f(T)\rightarrow f(T\o...
DECARCERATION-PLATFORM
05-10
我们还相信，如果以前的被监禁者的重返旅程少了障碍，积极性强，任务更加明确，他们将能够并且将过着守法的生活。 因此，我们寻求创建一个满足这些需求的平台。 我们设想有一天该工具可以由美国任何州的任何美国...
重返大航海-crx插件
04-06
全新的海战系统在游戏当中玩家不再只是孤单一船，可以自由组织庞大的舰队体验真正的舰队战快感，运筹帷幄中排兵布阵战胜强大的副本敌人或与其他玩家斗智斗勇PK胜负。最后还有令人热血澎湃的玩家公会战。丰富多彩的...
Elixir学习笔记——二进制、字符串和字符列表
chenxupest的专栏
06-04 704
在“基本类型”中，我们学习了一些关于字符串的知识，并使用 is_binary/1 函数进行检查："hello"true在本章中，我们将明确二进制到底是什么、它们与字符串的关系以及 Elixir 中单引号值“like this”的含义。虽然字符串是计算机语言中最常见的数据类型之一，但它们却非常复杂，经常被误解。要理解 Elixir 中的字符串，我们必须了解 Unicode 和字符编码，特别是 UTF-8 编码。
.netcore学习笔记
focus-unchanged-thing
06-07 95
net core和java运行性能对比。这个例子c#比java快了将近1倍。同时占用更少的内存，支持跨平台。所以做游戏用c#可能是更合适的。1..NET Core理论基础。
Diffusers代码学习-链式Inpainting
duhaining1976的博客
06-03 1027
AIGC研究及应用系列
【Docker学习】docker push简述
weixin_42206314的博客
06-04 437
docker push是docker pull的反向操作。我们将镜像上传到公共或私有镜像仓库就需要用到这个命令。
HOW - Lodash 使用指南和源码学习
weixin_58540586的博客
06-03 821
Lodash 是一个 JavaScript 实用工具库，提供了许多常用的函数方法，用于简化 JavaScript 编程中的常见任务。它提供了对数组、集合、对象、函数、字符串等数据类型的操作和处理方法，以及一些实用的辅助函数。
学习小心意——python的构造方法和析构方法
2201_75876277的博客
06-03 312
关于构造方法的玩法有很多，这里只是简单引用一下。小小分享，到此一游。构造方法和析构方法分别用于。
Paddle Graph Learning (PGL)图学习之图游走类deepwalk、node2vec模型[系列四]
最新发布
2401_85373396的博客
06-07 797
在开始介绍图游走算法之前，先来学习一下什么是Graph Embedding。图嵌入是一种将图数据（通常为高维稠密的矩阵）映射为低微稠密向量的过程，如下图所示。图嵌入需要捕捉到图的拓扑结构，顶点与顶点的关系，以及其他的信息 （如子图，连边等）。如果有更多的信息被表示出来，那么下游的任务将会获得更好的表现。向量空间中保持连接的节点彼此靠近。节点嵌入和图嵌入。当需要对节点进行分类，节点相似度预测，节点分布可视化时一般采用节点的嵌入；
CVE-2019-16759漏洞原理详解
08-19
其次，CVE-2019-16759漏洞可能与某个安全控制机制的问题有关。安全控制机制是指软件或系统中用于限制用户权限和保护敏感数据的一系列规则和方法。然而，由于软件或系统在安全控制方面存在漏洞，攻击者可以绕过控制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值