javascript

git

java

python

git-remote

c++

github

django

c#

reactjs

node.js

performance

branch-prediction

git-commit

git-revert

validation

email-validation

undefined

scrum

kubernetes

Matz为什么选择在Ruby中默认使字符串可变?

这个问题的反面是:为什么字符串在Java和.NET中不可变?

在Ruby中做出此选择仅仅是因为操作(追加等)对可变字符串有效,还是有其他原因?

(如果仅仅是效率,那似乎是很奇怪的,因为Ruby的设计似乎并没有在促进高效实现方面给予很高的重视。)

trans by 2020-08-03T12:49:41Z

进行复制和直接初始化的行为背后的动机是什么?

与为什么要调用复制构造函数而不是转换构造函数有关?

初始化有两种语法:直接和复制初始化:

A a(b);
A a = b;

我想知道他们具有不同定义行为的动机。 对于副本初始化,会涉及一个额外的副本,并且我认为该副本没有任何用途。 由于它是临时副本,因此可以并且很可能会对其进行优化,因此用户不能依赖它的发生-因此,多余的副本本身不足以引起不同的行为。 所以为什么?

trans by 2020-08-02T05:16:13Z

语言设计-为什么R中有两个赋值运算符,即<-和和->?

我知道如何使用->->,并且有一些关于<-分配与箭头分配之间区别的文章,但是我不知道何时比<-更喜欢=

似乎社区已合并使用->进行分配。

google R风格指南和Hadley Wickam的tidyverse R风格指南都没有在作业部分提及->

我对导致S / S-PLUS开发人员向右箭头分配操作符->的设计考虑感到好奇。与<-==相比,在哪种设置下使用->会被认为更易读(或更容易键入)。?

我不熟悉允许使用右分配语义的任何其他语言。 在这方面,什么语言启发了R?

我正在寻找引用书籍/早期设计文档/用户手册/归档的邮件列表或其他参考文献的答案,以建立S作者/设计者将其放入前向箭头赋值运算符的意图。

trans by 2020-08-01T23:07:02Z

最有趣的非主流语言?

我对编译器,解释器和语言感兴趣。

您所知道的最有趣但被遗忘或未知的语言是什么? 更重要的是,为什么呢?

我对编译语言,解释语言和VM语言都感兴趣,但对像Whitespace或BF这样的深奥语言不感兴趣。
当然,由于我计划学习并希望从中学习,因此开源将是一个加号。

trans by 2020-07-28T15:32:45Z

为什么默认情况下语言为什么不引发整数溢出错误?

在几种现代编程语言(包括C ++,Java和C#)中,该语言允许整数溢出在运行时发生,而不会引发任何类型的错误情况。

例如,考虑这种(人为的)C#方法,该方法不能解决上溢/下溢的可能性。 (为简便起见,该方法也不处理指定列表为空引用的情况。)

//Returns the sum of the values in the specified list.
private static int sumList(List<int> list)
{
    int sum = 0;
    foreach (int listItem in list)
    {
        sum += listItem;
    }
    return sum;
}

如果按如下方式调用此方法:

List<int> list = new List<int>();
list.Add(2000000000);
list.Add(2000000000);
int sum = sumList(list);

/checked方法中将发生溢出(因为C#中的int类型是32位带符号整数,并且列表中值的总和超过了最大32位带符号整数的值)。 sum变量的值为-294967296(而不是4000000000); 这很可能不是sumList方法的(假设)开发人员想要的。

显然,开发人员可以使用多种技术来避免整数溢出的可能性,例如在Java语言中使用Java的/checked/checked关键字和/checked编译器开关等类型。

但是,我感兴趣的问题是,为什么这些语言默认情况下设计为首先允许整数溢出发生,而不是例如在运行时执行操作时引发异常,从而导致整数溢出? 溢出。 在开发人员在编写执行可能导致溢出的算术运算的代码时忽略了溢出的可能性时,这种行为似乎将有助于避免错误。 (这些语言可能包含类似“未经检查”的关键字之类的东西,它们可以指定一个块,在该块中允许发生整数溢出而不会引发异常,在这种情况下,开发人员明确地打算该行为; C#确实具有此功能。 )

答案是否只是归结为性能-语言设计者不希望其各自的语言默认为具有“慢速”算术整数运算,而运行时将需要做额外的工作来检查每种适用的算术是否发生了溢出 操作-并且在不小心发生溢出的情况下,这种性能考虑的价值超过了避免“无提示”故障的价值?

除了性能方面的考虑之外,是否还有其他原因可以做出这种语言设计决策?

trans by 2020-07-25T19:28:18Z

C#静态成员“继承”-为什么这根本存在?

在C#中,超类的静态成员被“继承”到子类范围内。 例如:

class A { public static int M() { return 1; } }
class B : A {}
class C : A { public new static int M() { return 2; } }
[...]
A.M(); //returns 1
B.M(); //returns 1 - this is equivalent to A.M()
C.M(); //returns 2 - this is not equivalent to A.M()

现在,您不能继承静态类,并且我可以想象到的唯一静态继承可能会完全忽略它:尽管您可以使要求类型参数2976164042022022323200的泛型约束成为X的子类,但是您仍然无法调用 N1.N2.X(这可能简化了VM的工作),更不用说在子类中编写不同的N1.N2.N3.X实现并使用它了。

因此,静态成员的“继承”仅看起来像命名空间污染。 即使您明确限定了该名称(即N1.N2.N3),仍然可以解析X的版本。

编辑与名称空间比较:

namespace N1{  class X();   }
namespace N1.N2 {  class X();   }
namespace N1.N2.N3 { [...] }

N1.N2.N3中,如果我不加限定地使用X,则它是指N1.N2.X。但是,如果我明确地引用了N1.N2.N3.X,并且不存在此类,则我不希望它找到N2的版本。 如果您尝试这样做,确实会向编译器报告错误。 相比之下,如果我明确引用B.M(),为什么编译器不报告错误? 毕竟,“ B”中没有“ M”方法。

这种继承有什么目的? 可以以某种方式建设性地使用此功能吗?

trans by 2020-07-21T11:28:49Z

为什么我们不能在if语句中定义变量?

也许这个问题已经被回答过了,但是这个单词while经常出现,很难找到它。

该示例没有意义(该表达式始终为真),但它说明了我的问题。

为什么此代码有效:

StringBuilder sb;
if ((sb = new StringBuilder("test")) != null) {
    Console.WriteLine(sb);
}

但是这段代码不是:

if ((StringBuilder sb = new StringBuilder("test")) != null) {
    Console.WriteLine(sb);
}

我发现了关于while语句的类似问题。 那里接受的答案说,在while语句中,这意味着将在每个循环中定义变量。 但是对于我的if语句示例,情况并非如此。

那么,为什么我们不允许这样做呢?

trans by 2020-07-19T07:22:52Z

锈-什么是typestate?

TypeState在语言设计方面指的是什么? 在有关Mozilla称为Rust的新语言的一些讨论中,我看到了它。

trans by 2020-07-13T07:56:49Z

为什么在C ++ 0x中没有编译器生成的swap()方法?

C ++编译器会自动生成副本构造函数和副本分配运算符。 为什么也不要swap

如今,实现复制分配运算符的首选方法是复制和交换习惯用法:

T& operator=(const T& other)
{
    T copy(other);
    swap(copy);
    return *this;
}

(忽略使用按值传递的易于复制的表单)。

这种习惯用法的优点是在遇到异常时是事务性的(假定swap实现不会抛出异常)。 相比之下,默认的编译器生成的复制分配运算符将对所有基类和数据成员进行递归复制复制,并且没有相同的异常安全保证。

同时,手动实现swap方法既繁琐又容易出错:

  1. 为了确保不会抛出swap,必须为该类和基类中的所有非POD成员,其非POD成员等中的所有非POD成员实现它。
  2. 如果维护者将新的数据成员添加到类中,则维护者必须记住要修改该类的swap方法。 否则可能会引入一些细微的错误。 另外,由于swap是普通方法,因此如果swap实现不完整,编译器(至少我不知道)不会发出警告。

如果编译器自动生成swap方法会更好吗? 然后,隐式副本分配实现可以利用它。

显而易见的答案可能是:开发C ++时不存在复制和交换习惯,现在这样做可能会破坏现有代码。

尽管如此,也许人们仍然可以选择让编译器使用C ++ 0x用于控制其他隐式函数的语法来生成swap

void swap() = default;

然后可能会有规则:

  1. 如果存在由编译器生成的swap方法,则可以使用复制和交换来实现隐式复制分配运算符。
  2. 如果没有编译器生成的swap方法,则将像以前一样实现隐式的复制分配运算符(在所有基类和所有成员上调用复制辅助)。

是否有人知道是否向C ++标准委员会提出过此类建议?如果是,那么委员会成员有什么意见?

trans by 2020-07-10T17:23:07Z

c ++-make_heap的意义是什么?

有人可以告诉我std::make_heap之类的STL堆功能模板的要点吗? 为什么有人会使用它们? 有实际用途吗?

trans by 2020-07-02T05:51:17Z

为什么Python赋值不返回值?

为什么Python赋值是语句而不是表达式? 如果它是一个表达式,它返回赋值右侧的值,则在某些情况下,它将允许冗长得多的代码。 有没有我看不到的问题?

例如:

# lst is some sequence
# X is come class
x = X()
lst.append(x)

可能被改写为:

lst.append(x = X())

好吧,确切地说,上述方法不起作用,因为x将被视为关键字参数。 但是另一对括号(或关键字参数的另一个符号)将解决该问题。

trans by 2020-06-30T14:09:44Z

计算机科学-评估语言的“转换完整性”的实用准则是什么?

我已经阅读了“ what-is-turing-complete”和wikipedia页面,但是我对正式的证明兴趣不如对Turing Complete的实际意义感兴趣。

我实际上试图确定的是,我刚刚设计的玩具语言是否可以用作通用语言。 我知道我可以证明是否可以用它编写图灵机。 但是在我相当确定成功之前,我不希望进行该练习。

是否有最少的功能集,否则没有图灵完整性是不可能的?是否有实际上可以保证完整性的一组功能?

(我的猜测是条件分支和可读/可写内存存储将带给我大部分帮助)


编辑:

我想我已经说“完成”了。 我试图以合理的信心猜测具有某些功能集的新发明的语言(或者具有特定指令集的VM)将能够计算出任何值得计算的东西。 我知道证明用它构建图灵机是一种方法,但不是唯一的方法。

我所希望的是一组准则,例如:“如果它可以执行X,Y和Z,那么它可能可以执行任何操作”。

trans by 2020-06-30T04:50:55Z

为什么许多语言区分大小写?

Why are many languages case sensitive?

这仅仅是继承问题吗? C ++区分大小写是因为C是,Java区分大小写是因为C ++等? 还是背后有更务实的理由?

trans by 2020-06-27T17:54:40Z

C ++迭代器被认为有害吗?

在今天的Boost库会议上,《现代C ++设计》和《 Loki C ++库》一书的作者Andrei Alexandrescu作了题为“迭代器必须走”的演讲(视频,幻灯片),讨论了迭代器为什么不好,他有更好的解决方案。

我试图阅读演示幻灯片,但是我从中受益匪浅。

  1. 迭代器不好吗?
  2. 他的替补真的更好吗?
  3. C ++实现者会接受他的想法吗?
trans by 2020-06-24T22:41:22Z

为什么Python 3中的切片仍会复制而不是视图?

正如我现在在评论此答案后才注意到的那样,Python 3中的切片返回所切片内容的浅表副本,而不是视图。 为什么仍然如此? 即使将numpy的视图用法而不是副本用于切片,也是如此,事实是dict.keysdict.values__getslice__都在Python 3中返回了视图,并且Python 3还有许多其他方面旨在更好地使用迭代器,这似乎使 将会有朝着切片变得相似的方向发展。 __setslice__确实具有islice函数,该函数可以进行迭代切片,但比正常切片有更多限制,并且不提供沿dict.keysdict.values的视图功能。

同样,您可以对切片使用赋值来修改原始列表,但是切片本身是副本而不是视图,这是该语言的一个矛盾方面,似乎违反了Zen Zen中阐明的一些原理。

也就是说,你可以做的事实

>>> a = [1, 2, 3, 4, 5]
>>> a[::2] = [0, 0, 0]
>>> a
[0, 2, 0, 4, 0]

但不是

>>> a = [1, 2, 3, 4, 5]
>>> a[::2][0] = 0
>>> a
[0, 2, 3, 4, 5]

或类似的东西

>>> a = [1, 2, 3, 4, 5]
>>> b = a[::2]
>>> b
view(a[::2] -> [1, 3, 5])   # numpy doesn't explicitly state that its slices are views, but it would probably be a good idea to do it in some way for regular Python
>>> b[0] = 0
>>> b
view(a[::2] -> [0, 3, 5])
>>> a
[0, 2, 3, 4, 5]

似乎有些武断/不受欢迎。

我知道[http://www.python.org/dev/peps/pep-3099/]以及其中说“切片和扩展切片不会消失的部分(即使__getslice____setslice__ API可能会消失) 被替换),也不会返回标准对象类型的视图。”,但是链接的讨论中没有提及为何做出对视图进行切片的决定; 实际上,在原始帖子中列出的建议中,对该特定建议的大多数评论似乎都是积极的。

是什么阻止了这种类似的事情在Python 3.0中实现,而Python 3.0是专门为与Python 2.x不严格向后兼容而设计的,因此这将是实现这种设计更改的最佳时机,是否有可能 防止它在未来的Python版本中?

trans by 2020-02-16T20:45:50Z

算法-为什么Python的itertools.permutations包含重复项? (当原始列表重复时)

普遍同意,n个不同符号的列表具有n! 排列。 但是,当符号没有区别时,在数学和其他方面,最常见的约定似乎只是计算不同的排列。 因此,列表next_permutation的排列通常被认为是
[1, 1, 2], [1, 2, 1], [2, 1, 1].实际上,以下C ++代码精确地打印了这三个代码:

int a[] = {1, 1, 2};
do {
    cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<endl;
} while(next_permutation(a,a+3));

另一方面,Python的next_permutation似乎还打印了其他内容:

import itertools
for a in itertools.permutations([1, 1, 2]):
    print a

此打印

(1, 1, 2)
(1, 2, 1)
(1, 1, 2)
(1, 2, 1)
(2, 1, 1)
(2, 1, 1)

正如用户Artsiom Rudzenka在一个答案中指出的那样,Python文档如此指出:

元素根据其位置而不是其价值被视为唯一。

我的问题:为什么要做出此设计决定?

似乎遵循通常的约定会给出更有用的结果(实际上,这通常正是我想要的)……或者我缺少一些Python行为的应用程序?

[还是一些实施问题? next_permutation中的算法(例如,在此处由我在StackOverflow上进行了解释,并在此处显示为O(1)摊销的)在Python中似乎高效且可实现,但由于Python不能保证字典顺序,因此它的工作效率更高。 基于价值? 如果是这样,效率的提高是否值得?

trans by 2020-02-15T20:03:27Z

语言设计-使用变量键访问JavaScript对象中的值

代码:

function updateDashboardData() {
    $.getJSON("includes/system/ajaxDataInterface.php", {recordcount:1}, function(data) {
        $('.stationContainer').each(function(data) {
            var bsID = $(this).attr("id");
            var bsStatus = $(this).children('.stationStatus');
            alert(data[bsID][0].time);
            bsStatus.find('.bs_maxHandsets').text(data[bsID][0].maxHandsets);
            bsStatus.find('.bs_time').text(data[bsID][0].time);
        });
    });
}

对象数据:

{
    "A5A50000": [{
        "bsid": "A5A50000",
        "chanCount": 17,
        "time": "2009-05-27 16:36:45",
        "avgInterference": 1.711765,
        "maxInterference": 4.97,
        "avgHandsets": 205.1176,
        "maxHandsets": 315,
        "avgCalls": 6.4118,
        "maxCalls": 13,
        "avgCBA": 3868.98059,
        "maxCBA": 7463,
        "sumSuccessCBA": 197318,
        "sumTimeoutHandoff": 133,
        "sumAttemptHandoff": 1028,
        "sumDeniedHandoff": 216,
        "sumConfirmHandoff": 679,
        "sumHandoffNetwork": 61873,
        "sumJoinNetwork": 96888,
        "sumLeaveNetwork": 93754,
        "sumRcvdKeepalive": 98773,
        "sumTimeoutKeepalive": 19748,
        "sumAttemptUplink": 93689,
        "sumBlockedUplink": 62453
    }]
}

问题:

alert(data.bsID[0].time);正确显示“ 2009-05-27 16:36:45”。

alert(data.bsID[0].time);正确显示“ A5A50000”。

alert(data.bsID[0].time);报告“未定义data.bsID”。

alert(data[bsID][0].time);报告“数据[bsID]未定义”。

我不清楚何时/不评估变量。 也许我忽略了一些愚蠢的事情,但是我无法在这里解决我的问题。

trans by 2020-02-13T05:03:13Z

类型-James Gosling对Java字节为何签名的解释

最初让我感到惊讶的是Java决定指定byte已签名,范围为-128..127(含)。 我的印象是,大多数8位数字表示形式都是无符号的,取而代之的是0..255的范围(例如,点分十进制表示法的IPv4)。

詹姆斯·高斯林(James Gosling)是否曾被要求解释为什么他决定签署byte? 过去,权威编程语言设计师和/或批评家之间是否曾有过关于此问题的著名讨论/辩论?

trans by 2020-02-10T03:16:09Z

动态-为什么动态输入Clojure?

我非常喜欢的一件事是阅读不同的编程语言。 目前,我正在学习Scala,但这并不意味着我对Groovy,Clojure,Python和许多其他语言不感兴趣。 所有这些语言都具有独特的外观和某些特色。 对于Clojure,我不了解这些设计决策之一。 据我所知,Clojure非常强调其功能范式,并且几乎迫使您尽可能使用不可变的“变量”。 因此,如果一半的值是不可变的,为什么要动态键入该语言?

Clojure网站说:

首先,Clojure是动态的。 这意味着Clojure程序不仅是您可以编译和运行的程序,而且还可以与之交互。

好吧,这听起来很奇怪。 如果程序已编译,则无法再进行更改。 当然,您可以与它进行“交互”,这就是UI的用途,但是该网站当然并不意味着一个整洁的“动态” GUI。

Clojure如何从动态打字中受益

我的意思是Clojure的特殊情况,而不是动态类型的一般优点。

动态类型系统如何帮助改善功能编程

同样,我知道不溢出“ int a”的乐趣。 遍及源代码,但类型推断可以减轻很多麻烦。 因此,我只想知道动态类型如何支持功能语言的概念。

trans by 2020-02-04T10:33:15Z

为什么Scala在类中没有静态成员?

我知道你可以间接定义它们实现与伴随对象相似的功能,但我想知道为什么在语言设计中,静态变量不属于类定义。

trans by 2020-01-27T07:38:12Z

1 2 3 4 下一页 共4页