标签: ref

创建不同引用向量的最简单方法是什么？

使用(repeat 5 (ref nil))将返回一个列表,但它们都将引用相同的ref:

user=> (repeat 5 (ref nil))
(#<Ref@16ef71: nil> #<Ref@16ef71: nil> #<Ref@16ef71: nil> #<Ref@16ef71: nil> #<R
ef@16ef71: nil>)

结果相同(replicate 5 (ref nil)):

user=> (replicate 5 (ref nil))
(#<Ref@1d88db7: nil> #<Ref@1d88db7: nil> #<Ref@1d88db7: nil> #<Ref@1d88db7: nil>
 #<Ref@1d88db7: nil>)

GCC的近期支持原子操作(如描述这里)是伟大的,是90%的我们所需要的.不幸的是,我们的一些产品仍然需要在Windows上运行,所以我们也需要Windows的原子整数运算.

在过去,我们为所有平台都有自定义汇编语言实现,但是我想将所有*nix平台移到GCC支持的操作上,我想到了这个想法也许还有更标准的方法来实现这个目标.在Windows上现在也是......

是否有官方认可的方法在Windows上执行此操作(除了使用汇编语言自己实现它们)？

这是我的班级:

public class UserInformation
    {
        public string Username { get; set; }
        public string ComputerName { get; set; }
        public string Workgroup { get; set; }

        public string OperatingSystem { get; set; }
        public string Processor { get; set; }
        public string RAM { get; set; }
        public string IPAddress { get; set; }

        public UserInformation GetUserInformation()
        {
            var CompleteInformation = new UserInformation();

            GetPersonalDetails(ref CompleteInformation);
            GetMachineDetails(ref CompleteInformation);

            return CompleteInformation;
        }

        private void GetPersonalDetails(ref UserInformation CompleteInformation)
        {

        }

        private void GetMachineDetails(ref …

假设我有以下一组静态函数

这里我通过引用发送变量:

public static void ProcessEmailMessage(ref string HTML)
        {
            ModifyLinks(ref HTML);
            AddFakeImage(ref HTML);
        }

        public static void ModifyLinks(ref string HTML)
        {
            //modify HTML links 
        }


        public static void AddFakeImage(ref string HTML)
        {
            //adds an image to the HTML
        }

在这里我按值发送变量

public static string ProcessEmailMessage(string HTML)
        {
            HTML = ModifyLinks(HTML);
            HTML = AddFakeImage(HTML);
            return HTML;
        }

        public static string ModifyLinks(string HTML)
        {
            //modify HTML links
            return HTML;
        }


        public static string AddFakeImage(string HTML)
        {
            //adds an image to the HTML
            return …

有谁知道如何在numpy中启用REFS_OK标志？我似乎无法在网上找到明确的解释。

我的代码是：

import sys
import string
import numpy as np
import pandas as pd
SNP_df = pd.read_csv('SNPs.txt',sep='\t',index_col = None ,header = None,nrows = 101)
output = open('100 SNPs.fa','a')
for i in SNP_df:
    data = SNP_df[i]
    data = np.array(data)
    for j in np.nditer(data):
        if j == 0:
            output.write(("\n>%s\n")%(str(data(j))))
        else:
            output.write(data(j))

我不断收到错误消息：迭代器操作数或请求的dtype保留引用，但未启用REFS_OK。

我无法解决如何启用REFS_OK标志，以便程序可以继续...

我想谦虚地问......

什么,"var或ref/atom/agent for constant values？",请问？当然,我确实使用vars作为常量值.

但我总是想知道当值作为常量时我应该使用哪一个,但它们应该在运行时分配,而不是在编译时(在读取代码时).

例如,想一下用户配置文件中编写的一些java属性.它们应该在运行时分配,因为数据不在代码中.但是在读取数据之前也应该定义它们,因为其他代码引用它们.

在这种情况下,

我何时使用'var'？:

• 我定义'var',或者只是声明'var'(当它没问题的时候).
• 然后我通过读取选项文件的函数再次重新定义了那些'var'.
• 但是覆盖'var'感觉很糟糕,或者定义'var'内部函数感觉很奇怪.

我什么时候使用ref/atom/agent？:

• 我将ref/atom/agents分配给'var'.
• 然后我通过读取选项文件的函数更新那些ref/atom/agents.
• 但由于整个计划使用了这些值,所以我担心它们的成本.
• ...使用太多的@宏有点烦人.

我不知道应该用什么.

在那些情况下你用了什么？

"VAR的？"REF /原子/代理的？甚至'延迟'？

提前致谢.

我想添加一个类别，然后如果成功，将它的引用推送到用户的集合。这就是我这样做的方式：

那是我的“dashboard.js”文件，其中包含类别架构。

var users = require('./users');

var category = mongoose.model('categories', new mongoose.Schema({
    _id:     String,
    name:    String,
    ownerId: { type: String, ref: 'users' }
}));

router.post('/settings/addCategory', function(req, res, next) {
  console.log(req.body);
  var category_toAdd = new category();
  category_toAdd._id = mongoose.Types.ObjectId();
  category_toAdd.name = req.body.categoryName;
  category_toAdd.ownerId = req.body.ownerId;

  category.findOne({
    name: req.body.categoryName,
    ownerId: req.body.ownerId
  }, function(error, result) {
     if(error) console.log(error);
     else {
       if(result === null) {
         category_toAdd.save(function(error) {
           if(error) console.log(error);
           else {
             console.log("Added category: " + category_toAdd);
<<<<<<<<<<<<<<<<<<<THE CONSOLE LOG WORKS GOOD
             users.categories.push(category_toAdd);
           }
         }); …

我正在编写一个组件，该组件state根据ref其子对象处理一些内部事件（例如，与该子对象的ref相关的鼠标事件）。
该组件使用a render-prop传递相关state子对象的子元素，并ref通过React.cloneElementutil 渲染带有附加子元素的子元素。

问题是，当子级是一个class组件时，由于某种原因该子级ref不可用，并且由于它是一种类型为react element的对象function（我当然也将其克隆），因此我找不到一种渲染方法。

但是，如果子DOM节点只是一个像a这样的节点div，则它按预期运行。

我的解决方法是检查子类型，如果是子类型，function则将克隆的元素包装成自己的子类型div，如果只是dom节点，则照原样渲染。
但是，我不想用多余的东西包裹孩子，div因为我不想添加不必要的DOM节点。

这是一个基本的代码示例，为简洁起见，删除了大多数代码：
Parent组件：

class Parent extends Component {

    attachRef = node => {
        this.ref = node;
    }

    render() {
        const { render } = this.props;
        const { someValue } = this.state;
        const Child = render(someValue);
        const WithRef = React.cloneElement(Child, {
            ref: this.attachRef
        }); …

我正在处理大型嵌套词典，并试图删除嵌套的子词典。我想知道为什么会发生以下行为。

当我设置对字典 d 的引用（称为 ref），然后更改 ref 并打印 d 时，它会显示添加了第三个元素的 d 的更新版本。

input:
d={"a":1,"b":2}
ref=d
ref["c"]=3
print(d)

output:
{'a': 1, 'b': 2, 'c': 3}

鉴于这种行为，我希望能够通过 delete 删除字典

input:
d={"a":1,"b":2}
ref=d
del ref
print(d)

output:
{'a': 1, 'b': 2}

我想知道删除引用时是否有删除原始对象的方法（意味着第二个程序的输出将是错误的，因为d被删除了。

在启用了彻底依赖规则的 React Typescript 中，当我定义一个 ref 并在效果内部使用它时，linter 就可以了：

const stringRef: RefObject<string> = useRef("Hello World!");
  
useEffect(() => {
  console.log(stringRef.current);
}, []) // no warning, the linter detects that I'm using a ref

但是，当我将效果放在自定义钩子中时，linter 抱怨我应该在依赖项数组中包含 ref：

const stringRef: RefObject<string> = useRef("Hello World!");
  
useCustomHook(stringRef);

// in another-file.ts
const useCustomHook = (ref: RefObject<string>) => {
  useEffect(() => {
    console.log(ref.current);
  }, []) // ESLint: React Hook useEffect has a missing dependency: 'ref'. Either include it or remove the dependency array.(react-hooks/exhaustive-deps)
}

从语义上讲，没有任何变化，但是，linter 无法识别 ref 是 RefObject（即使我是这样输入的）。 …