小编Joh*_*ica的帖子

最近我遇到了这个奇怪的问题:

while(list($key, $value) = each($array))

没有列出所有数组值,用...替换它...

foreach($array as $key => $value)

......工作得很好

而且,我现在很好奇......这两者有什么区别？

我有一个很大的旧配置对象.就像是:

var object = {
  item1: 'value1',
  item2: 1000,
  item3: ['a', 'b', 'c'],
  item4: [1, 2, 3],
  item5: {
    foo: 'bar'
  }
};

... 等等.我想重写为有效的JSON,因此它可以通过intertubes旅行,但我并不想通过每一行中我的文件到处都是手动添加双引号.当然,我不介意手动包装在括号中的整个事情,改变了最初的任务是第一属性,但除此之外,我希望有一些资源,将做繁重的工作.

无论如何,如果知道TextMate命令,正则表达式技巧,在线转换器,友好机器人或任何其他会使这不那么繁琐的事情,请帮助我.

我想在我的Linux $ HOME目录中创建一个单独的git repo.在这个回购 - 显然 - 我可以在版本控制下添加所有内容,但这没有任何意义.我只想添加与我相关的文件和文件夹,如.vimrc,.vim,.bashrc等(可能只有隐藏文件和文件夹,但可能没有)

我知道我可以利用.gitignore来尝试实现这样的行为,但这将是痛苦的,几乎无法维护.相反,我想知道的是,是否有任何方法可以手动声明我想要管理的文件和文件夹,只有那样.

我想知道为什么列表理解比附加到列表要快得多.我认为差异只是表达,但事实并非如此.

>>> import timeit 
>>> timeit.timeit(stmt='''\
t = []
for i in range(10000):
    t.append(i)''', number=10000)
9.467898777974142

>>> timeit.timeit(stmt='t= [i for i in range(10000)]', number=10000)
4.1138417314859

列表理解速度提高了50%.为什么？

让我们在一个示例中展示它，其中我们有一个包含主数据的 Data 类、某种指向主数据的索引，并且我们还需要公开索引const的版本。

class Data
{
public:
  const std::vector<int>& getPrimaryData() const { return this->primaryData; }
  const std::vector<int*>& getIndex() const { return this->index; }
private:
  std::vector<int> primaryData;
  std::vector<int*> index;
};

这是错误的，因为用户可以轻松修改数据：

const Data& data = something.getData();
const std::vector<int*>& index = data.getIndex();
*index[0] = 5; // oups we are modifying data of const object, this is wrong

原因是 Data::getIndex 应返回的正确类型是：

const std::vector<const int*>&

但是您可以猜测当您尝试以“仅将非常量变体转换为常量变体”的方式编写方法时会发生什么：

// compiler error, can't convert std::vector<int*> to std::vector<const int*> these are unrelated types.
const std::vector<const int*>& …

With reference to Comma-Separated return arguments in C function [duplicate] ,

x=x+2,x+1;

will be evaluated as

x=x+2; 

However, in case of the following code

#include<stdlib.h>
#include<stdio.h>

int fun(int x)
{
    return (x=x+2,x+1); //[A]
}

int main()
{
   int x=5;
   x=fun(x);
   printf("%d",x); // Output is 8
}

Shouldn't line [A],be evaluated as

x=x+2;

giving x = 7

我有一个列表,它将始终只包含1和0.我需要获得列表的非零索引列表:

a = [0, 1, 0, 1, 0, 0, 0, 0]
b = []
for i in range(len(a)):
    if a[i] == 1:  b.append(i)
print b

实现这一目标的"pythonic"方式是什么？

#include <stdio.h>

int foo1(void)
{
    int p;
    p = 99;
    return p;
}

char *foo2(void)
{
    char buffer[] = "test_123";
    return buffer;
}

int *foo3(void)
{
    int t[3] = {1,2,3};
    return t;
}

int main(void)
{
    int *p;
    char *s;

    printf("foo1: %d\n", foo1());
    printf("foo2: %s\n", foo2());
    printf("foo3: %d, %d, %d\n", p[0], p[1], p[2]);
    return 0;
}

当我编译它时gcc -ansi -pedantic -W -Wall,编译器会发出foo2()和foo3()的警告消息:

warning: function returns address of local variable

我认为不允许返回局部变量,但foo1()工作正常,似乎返回指向本地对象的指针和对象本身之间存在巨大差异.

任何人都能对这个问题有所了解吗？提前致谢!

一个模块包含多个测试，如下所示：

#[cfg(test)]
mod tests_cases {

    /*
    #[test]
    fn test_1() {
        let a = 1;
        let b = 2;
        println!("{},{}", a, b);
        assert_ne!(a, b);
    }
    */

    #[test]
    fn test_2() {
        let c = 1;
        let d = 1;
        println!("currently working on this: {},{}", c, d);
        assert_eq!(c, d);
    }
}

当使用输出可见 ( cargo test -- --nocapture) 进行第二个测试时，我不想看到第一个测试的输出。

是否有一个选项可以禁用注释的单元测试？或者是否可以选择只运行第二个单元测试？

当我在32位和64位环境下运行我的应用程序时双倍大小有什么区别吗？

如果我没有弄错的话,32位环境中的双精度将在0之后占用16位数,而64位中的双位将占用32位,我是对的吗？