标签: variable-declaration

在C#中,在比较以下三种替代方案时,性能是否会有任何差异？

一

void ONE(int x) {

if (x == 10) 
{
    int y = 20;
    int z = 30;
    // do other stuff
} else {
    // do other stuff
}
}

二

void TWO(int x) {

int y;
int z;

if (x == 10) 
{
    y = 20;
    z = 30;
    // do other stuff
} else {
    // do other stuff
}
}

三

void THREE(int x) {

int y = 20;
int z = 30; …

在Stefanov的JS Design Patterns一书中,他写道"你使用一个var语句并声明用逗号分隔的多个变量",然后给出一个"single var"模式的例子,如下所示:

function func() {
    var a = 1,
        b = 2,
        sum = a + b,
        myobject = {},
        i,
        j;

斯特凡诺夫还写道:

• "在您声明变量时,也可以使用初始值初始化变量,这是一个很好的做法."
• "您还可以在声明时进行一些实际工作,例如前面代码中sum = a + b的情况."

现在我有一些代码如下,用单个var模式声明相同数量的变量,但做了更多"声明时的实际工作":

var html = '{purchaseQty}<br>FR:&nbsp; {fromLoc}'
    ,tpl = new Ext.XTemplate(html)
    ,srcReqLoc = record.get('SRC_REQUEST_LOC').trim()
    ,srcSupLoc = record.get('SRC_SUP_LOC').trim()
    ,fromLoc = srcReqLoc ? srcReqLoc : srcSupLoc
    ,tplCfg = {
        purchaseQty: purchaseQty
        ,fromLoc: fromLoc
    };

做太多"宣布时的实际工作"有什么缺点？顺便说一下,我不认为这是Javascript单一var模式的完全重复.我超载了吗？因为我问的是一般的缺点,而不仅仅是我的代码可能出错.

我想我可以看到一般的缺点是无法检查错误,例如在我的例子中我在从record.get预期返回的字符串上调用trim(),但如果返回undefined,则"无法调用方法"在未定义的对象上"(或者它是什么;)将被抛出.任何人都可以想到其他什么吗？

考虑

INTEGER,DIMENSION(3) :: NumberVector

和

INTEGER              :: NumberVector(3)

这两个声明之间是否有任何差异,或者它们是否完全相同？(我的意思是在任何可能的上下文和变体中:例如,在这两个是相同的情况下,如果我声明一个隐式大小的数组作为子程序的输入参数之一怎么办？它仍然是无关紧要的我用了？)

好吧,我先说一下我为什么要这样做.我经常用C/C++编写代码,所以对我来说定义函数非常自然:

vector<int> TestFunct (int a, int b){
<some code here>

return <result>;}

现在我正在学习Fortran,所以我声明这样的函数:

function TestFunc(a,b)
        integer, dimension(:)    :: TestFunc
        integer                  :: a
        integer                  :: b
        <some code here>
endfunction TestFunc

但我最近了解到结果的数据类型可以在函数语句中定义,例如:<data_type> function TestFunc(a,b),这对我来说更自然,因为我习惯了类似的C++声明.

问题是,当我'尝试定义一个向量(实际上是一个integer, dimension(:)严格说话)作为结果数据类型时,我有ifort错误#5082(我将在下一行详述).

在一个例子中,对于代码:

real, dimension(:) function TestFunc(a,b)
         integer, intent(in)    :: a
         integer, intent(in)    :: b

         <more code here>

endfunction Testfunc

我得到输出:

main.f90(23): error #5082: Syntax error, found ',' when expecting one of: ( * ) ( :: %FILL , …

对于一个错字,我a留在那里.当我去编译时,编译器报告:

'a'和'f'的声明之间缺少','

码:

int a
f(void) 
{
}

因为我从来没有得到任何这样的错误信息,而且我不知道我可以在那里放一个逗号并且它编译得很好(在我测试的多个编译器中),这是非常令人惊讶的:

int a,
f(void) 
{
}

但当然这不是我的意图,而是int f(void){}代替.我尝试了另一个编译器,但它没有用,并报告了这样的语法错误(在clang中):

错误:预期';' 在顶级声明者之后.

我的问题是:哪一个是正确的？它应该或不应该编译？标准对这种行为有什么看法？

我不打算使用它,因为把变量和函数分成逗号有点难看(就像它是函数原型一样).我只是好奇.

编辑:添加void在函数参数中.其实我想用空参数写一个函数

到目前为止,我一直在使用以下方式的类:

GameEngine.h声明该类如下

class GameEngine {
public:
    // Declaration of constructor and public methods

private:
    InputManager inputManager;
    int a, b, c;

    // Declaration of private methods
};

我的GameEngine.cpp文件然后只是实现方法

#include "____.h"    
GameEngine::GameEngine() {

}

void GameEngine::run() {
    // stuff
}

但是,我最近读到变量声明不应该在头文件中.在上面的例子中,这将是一个inputManager和a,b,c.

现在,我一直在寻找放置变量声明的位置,我找到的最接近的答案是:头文件中的变量声明

但是,我不确定extern的使用是否有意义; 我只是声明私有变量,它们只会在类本身的实例中使用.我的头文件中的变量声明是否正常？或者我应该把它们放在别处吗？如果我把它们放在cpp文件中,它们会直接进入#include吗？

我想弄清楚何时在PL/SQL块的声明部分中的变量定义中允许使用RANGE子句.

以下代码在Oracle 12c上进行了测试

这有效......

declare
   l_constrained  PLS_INTEGER  RANGE  7..10 ;
begin
   l_constrained := 9;
end ;
/

这给出了编译错误......

declare
   l_constrained  NUMBER(2)  RANGE  7..10 ;
begin
   l_constrained := 9;
end ;
/

它似乎只适用于PL/SQL数据类型而不适用于SQL数据类型,但这只是我的第一印象.

有人可以给我一些信息,并可能请我转到Oracle关于使用RANGE条款的官方文档吗？我找不到它了...

在D中，如何在D中声明指向非常量/可变数据的const或不可变指针？

dlang网站说您不能仅仅将其声明为const，因为这会使指针const及其指向的数据都不可修改。

我已经阅读了与此相关的较早的帖子，表明这根本是不可能的。如果是这样，那么这就是语言设计中的一个大漏洞。应该有可能单独声明指针为不可修改的指针，否则这是疯狂的。使const从指针传播到也隐含const数据可能是有用的默认安全功能。

我在另一个问题中注意到使用let和var变量声明时循环的性能差异.

最初的问题是正确回答,let在for循环中使用较慢,因为let为每次迭代创建一个新的作用域来保存let声明的变量的值.还有更多工作要做,所以慢一点是正常的.作为参考,我在NodeJS(7.9.0)执行时给出代码和结果:

请注意,以下所有javascript代码均与NodeJS版本7.9.0相关

常规代码:

'use strict';
console.time('var');
for (var i = 0; i < 100000000; i++) {}
console.timeEnd('var');


console.time('let');
for (let j = 0; j < 100000000; j++) {}
console.timeEnd('let');

输出:

var: 55.792ms
let: 247.123ms

为了避免j在循环的每次迭代中额外的范围声明,我们j在循环之前声明变量.人们可能会认为这应该使let循环性能与之匹配var.但不是!!!这是代码和结果供参考:

let前循环定义的代码:

'use strict';
console.time('var');
for (var i = 0; i < 100000000; i++) {}
console.timeEnd('var');


console.time('let');
let j;
for …

我正在通过Go规范来学习语言,这些要点来自" 声明和范围 "中的规范.

虽然我能够理解第1-4点,但我对第5点和第6点感到困惑:

5. 在函数内声明的常量或变量标识符的范围从ConstSpec或VarSpec(短变量声明的ShortVarDecl)结束开始,并在最内层包含块的末尾结束.
6. 在函数内声明的类型标识符的范围从TypeSpec中的标识符开始,并在最内层包含块的末尾结束.

这是我用来理解Go中范围的代码:

package main

import "fmt"

func main() {
    x := 42
    fmt.Println(x)
    {
        fmt.Println(x)
        y := "The test message"
        fmt.Println(y)
    }
    // fmt.Println(y) // outside scope of y
}

从这段代码中我了解到范围x是在main函数内,并且范围y是在开始和结束括号之后fmt.Println(x),并且我不能y在结束括号之外使用.

如果我理解正确的话,第4点和第5点都说同样的话.所以我的问题是:

1. 如果他们说同样的话,这两点的重要性是什么？

2. 如果它们不同,您能告诉我区别吗？