javascript

java

python

c#

android

node.js

c++

reactjs

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

python类中的变量范围

在类中声明变量(在函数外部):所有类函数都可以访问它(基本上是公共变量)

在类内的函数内声明变量:只有该函数才能访问它(在该函数范围内)

在类内的函数内部声明带有self。(变量名)的变量:所有类函数都可以访问它(这与全局变量名有何不同?)

并且由于没有私有/受保护的事物,所以所有事物都是公共的,因此可以从类内部访问所有可以从类内部访问的事物。

我还有其他细微差别应该知道吗?

trans by 2020-02-21T23:30:04Z

javascript-if / else语句中的函数声明?

函数声明如何处理?

var abc = '';
if(1 === 0){
    function a(){
        abc = 7;
    }
}else if('a' === 'a'){
    function a(){
        abc = 19;
    }
}else if('foo' === 'bar'){
    function a(){
        abc = 'foo';
    }
} 
a();
document.write(abc); //writes "foo" even though 'foo' !== 'bar'

此示例在Chrome和Firefox中产生不同的输出。 Chrome输出foo,而FF输出19

trans by 2020-02-21T16:17:54Z

范围-在Scala中有通用的记忆方式吗?

我想记住这一点:

def fib(n: Int) = if(n <= 1) 1 else fib(n-1) + fib(n-2)
println(fib(100)) // times out

因此,我编写了此文件,并完成了令人惊讶的编译和工作(我很惊讶,因为fib在其声明中引用了自己):

case class Memo[A,B](f: A => B) extends (A => B) {
  private val cache = mutable.Map.empty[A, B]
  def apply(x: A) = cache getOrElseUpdate (x, f(x))
}

val fib: Memo[Int, BigInt] = Memo {
  case 0 => 0
  case 1 => 1
  case n => fib(n-1) + fib(n-2) 
}

println(fib(100))     // prints 100th fibonacci number instantly

但是,当我尝试在val fib内声明fib时,出现编译器错误:

def foo(n: Int) = {
  val fib: Memo[Int, BigInt] = Memo {
    case 0 => 0
    case 1 => 1
    case n => fib(n-1) + fib(n-2) 
  }
  fib(n)
} 

以上未能编译val fib

为什么在def内部声明val fib失败,但在类/对象范围之外进行声明呢?

为了澄清,为什么我可能想在def范围内声明递归的备忘函数-这是我对子集和问题的解决方案:

/**
   * Subset sum algorithm - can we achieve sum t using elements from s?
   *
   * @param s set of integers
   * @param t target
   * @return true iff there exists a subset of s that sums to t
   */
  def subsetSum(s: Seq[Int], t: Int): Boolean = {
    val max = s.scanLeft(0)((sum, i) => (sum + i) max sum)  //max(i) =  largest sum achievable from first i elements
    val min = s.scanLeft(0)((sum, i) => (sum + i) min sum)  //min(i) = smallest sum achievable from first i elements

    val dp: Memo[(Int, Int), Boolean] = Memo {         // dp(i,x) = can we achieve x using the first i elements?
      case (_, 0) => true        // 0 can always be achieved using empty set
      case (0, _) => false       // if empty set, non-zero cannot be achieved
      case (i, x) if min(i) <= x && x <= max(i) => dp(i-1, x - s(i-1)) || dp(i-1, x)  // try with/without s(i-1)
      case _ => false            // outside range otherwise
    }

    dp(s.length, t)
  }
trans by 2020-02-20T12:17:48Z

范围-Rails:为什么with_exclusive_scope受保护? 有什么好的使用方法吗?

给定一个带有default_scope的模型以过滤所有过时的条目:

# == Schema Information
#
#  id          :integer(4)      not null, primary key
#  user_id     :integer(4)      not null, primary key
#  end_date    :datetime        

class Ticket < ActiveRecord::Base
  belongs_to :user
  default_scope :conditions => "tickets.end_date > NOW()"
end

现在我想买票。 在这种情况下,with_exclusive_scope是可行的方法,但是此方法是否受保护? 仅此有效:

 Ticket.send(:with_exclusive_scope) { find(:all) }

有点骇客,不是吗? 那么正确的使用方式是什么? 特别是在处理关联时,情况变得更糟(假设用户有很多票证):

 Ticket.send(:with_exclusive_scope) { user.tickets.find(:all) }

太丑了!!! -不能成为铁轨!?

trans by 2020-02-19T19:46:01Z

如何在Python中解析对变量的引用

该消息有很多示例,但是有点长,但是我希望将帮助我和其他人更好地掌握变量的全部内容和Python 2.7中的属性查找。

我正在使用PEP 227的条款([http://www.python.org/dev/peps/pep-0227/)]用于代码块(例如模块,类定义,函数定义等)和变量绑定(例如赋值,参数声明,类和函数声明,for循环等)

我将术语变量用于可以不使用点和需要用对象限定的名称的属性名称(例如obj.x作为对象obj的属性x)。

Python中所有代码块都有三个作用域,但有以下功能:

  • 本地
  • 全球
  • 内建

Python中有四个仅用于功能的块(根据(PEP 227):

  • 本地
  • 封闭功能
  • 全球
  • 内建

将变量绑定到块中并在其中查找的规则是非常简单:

  • 变量与块中对象的任何绑定都会使该变量局部变量,除非变量声明为全局变量(在该变量中变量属于全局范围)
  • 使用规则LGB(本地,全局的,内置的)所有块,但功能
  • 使用规则LEGB(本地,封闭的,全局的,内置的)。

让我知道一些验证此规则的示例,并展示了许多特别案例。 对于每个示例,我都会给出自己的理解。 请如果我错了,请纠正我。 对于最后一个示例,我不了解结果。

范例1:

x = "x in module"
class A():
    print "A: "  + x                    #x in module
    x = "x in class A"
    print locals()
    class B():
        print "B: " + x                 #x in module
        x = "x in class B"
        print locals()
        def f(self):
            print "f: " + x             #x in module
            self.x = "self.x in f"
            print x, self.x
            print locals()

>>>A.B().f()
A: x in module
{'x': 'x in class A', '__module__': '__main__'}
B: x in module
{'x': 'x in class B', '__module__': '__main__'}
f: x in module
x in module self.x in f
{'self': <__main__.B instance at 0x00000000026FC9C8>}

类(规则LGB)没有嵌套作用域,如果不使用,则类无法访问该类的属性限定名称(在此示例中为self.x)。 这在以下内容中有很好的描述PEP227。

范例2:

z = "z in module"
def f():
    z = "z in f()"
    class C():
        z = "z in C"
        def g(self):
            print z
            print C.z
    C().g()
f()
>>> 
z in f()
z in C

这里使用LEGB规则查找函数中的变量,但是如果路径中有一个类,则跳过类参数。 又是在这里,这就是PEP 227正在解释的内容。

范例3:

var = 0
def func():
    print var
    var = 1
>>> func()

Traceback (most recent call last):
  File "<pyshell#102>", line 1, in <module>
func()
  File "C:/Users/aa/Desktop/test2.py", line 25, in func
print var
UnboundLocalError: local variable 'var' referenced before assignment

我们期望使用诸如python这样的动态语言来处理一切动态解决。 但这不是函数的情况。 本地变量在编译时确定。 PEP 227和[http://docs.python.org/2.7/reference/executionmodel.html]描述了这一点这样的行为

“如果名称绑定操作发生在代码块内的任何地方,块中名称的使用被视为对当前块。”

示例4:

x = "x in module"
class A():
    print "A: " + x
    x = "x in A"
    print "A: " + x
    print locals()
    del x
    print locals()
    print "A: " + x
>>> 
A: x in module
A: x in A
{'x': 'x in A', '__module__': '__main__'}
{'__module__': '__main__'}
A: x in module

但是我们在这里看到,PEP227中的此声明“如果名称绑定该操作在代码块内的任何位置进行,使用该名称的所有方式该块中的内容被视为对当前块的引用。” is当代码块为类时出错。 而且,对于班级,似乎本地名称绑定不是在编译时进行的,而是在使用类名称空间执行。 在这方面,PEP227和Python文档中的执行模型具有误导性,并且有些零件错了。

范例5:

x = 'x in module'
def  f2():
    x = 'x in f2'
    def myfunc():
        x = 'x in myfunc'
        class MyClass(object):
            x = x
            print x
        return MyClass
    myfunc()
f2()
>>> 
x in module

我对这段代码的理解如下。 指令x = x首先查找表达式右手x所指的对象至。 在这种情况下,将在类中本地查找对象,然后遵循LGB规则,它将在全局范围内查找字符串“ x in module”。 然后,MyClass的局部属性x为在类字典中创建并指向字符串对象。

范例6:

现在这是一个我无法解释的例子。它与示例5非常接近,我只是在更改本地MyClass从x到y的属性。

x = 'x in module'
def  f2():
    x = 'x in f2'
    def myfunc():
        x = 'x in myfunc'
        class MyClass(object):
            y = x
            print y
        return MyClass
    myfunc()
f2()
>>>
x in myfunc

在这种情况下,为什么要在MyClass中查找x引用最内在的功能?

trans by 2020-02-14T07:57:09Z

我的JavaScript范围有什么问题?

这个问题已经在这里有了答案:

  • JavaScript闭包如何工作?                                     86个回答
  • 循环内的JavaScript闭合–简单的实际示例                                     44个答案

每次以下警报0

function timer() {
    for (var i = 0; i < 3; ++i) {
        var j = i;
        setTimeout(function () {
            alert(j);
        }, 1000);
    }
}

timer();

0是否不应该将1设置为setTimeout的各个范围?

而如果我这样做:

function timer() {
    for (var i = 0; i < 3; ++i) {
        (function (j) {
            setTimeout(function () {
                alert(j);
            }, 1000);
        })(i);
    }
}

timer();

它会像它应该警告012一样。

我有什么想念的吗?

trans by 2020-02-13T22:53:27Z

变量-G函数外的非声明语句

我正在为提供JSON或XML格式数据的API构建Go库。

此API需要我每15分钟左右请求test,并在调用中使用它。 例如:

foo.com/api/[my-application-id]/getuserprofilejson/[username]/[session-id]
foo.com/api/[my-application-id]/getuserprofilexml/[username]/[session-id]

在我的Go库中,我试图在test函数的外部创建一个变量,并打算对其进行ping操作以获取每个API调用的值。 如果该值为nil或为空,则请求一个新的会话ID,依此类推。

package apitest

import (
    "fmt"
)

test := "This is a test."

func main() {
    fmt.Println(test)
    test = "Another value"
    fmt.Println(test)

}

声明全局可访问变量(但不一定是常量)的惯用Go方法是什么?

我的test变量需要:

  • 可从其自己的程序包中的任何位置进行访问。
  • 多变
trans by 2020-02-12T19:03:41Z

IF语句中的javascript变量范围

在“ if”语句中声明和分配的变量是否仅在该“ if”块中或整个函数中可见?

我在下面的代码中这样做正确吗? (似乎可以工作,但是多次声明“变量结构”似乎很尴尬)有没有更干净的解决方案?

    function actionPane(state) {
    if(state === "ed") {
        var structure = {
            "element" : "div",
            "attr" : {
                "class" : "actionPane"
            },
            "contains" : [{
                "element" : "a",
                "attr" : {
                    "title" : "edit",
                    "href" : "#",
                    "class" : "edit"
                },
                "contains" : ""
            }, {
                "element" : "a",
                "attr" : {
                    "title" : "delete",
                    "href" : "#",
                    "class" : "delete"
                },
                "contains" : ""
            }]
        }
    } else {
        var structure = {
            "element" : "div",
            "attr" : {
                "class" : "actionPane"
            },
            "contains" : [{
                "element" : "a",
                "attr" : {
                    "title" : "save",
                    "href" : "#",
                    "class" : "save"
                },
                "contains" : ""
            }, {
                "element" : "a",
                "attr" : {
                    "title" : "cancel",
                    "href" : "#",
                    "class" : "cancel"
                },
                "contains" : ""
            }]
        }
    }
    return structure;
}
trans by 2020-02-10T04:55:04Z

python-如何使用装饰器将变量注入作用域?

[免责声明:做我想做的事可能有更多的pythonic方式,但是我想知道python的作用域在这里是如何工作的]

我试图找到一种方法来制作装饰器,该装饰器的作用类似于将名称注入另一个函数的作用域(以使名称不会泄漏到装饰器作用域之外)。 例如,如果我有一个函数说要打印一个尚未定义的名为var的变量,我想在调用它的装饰器中定义它。 这是一个中断的示例:

c = 'Message'

def decorator_factory(value):
    def msg_decorator(f):
        def inner_dec(*args, **kwargs):
            var = value
            res = f(*args, **kwargs)
            return res
        return inner_dec
    return msg_decorator

@decorator_factory(c)
def msg_printer():
    print var

msg_printer()

我希望它打印“ var”,但它给出:

NameError: global name 'var' is not defined

追溯甚至指向var,其定义为:

<ipython-input-25-34b84bee70dc> in inner_dec(*args, **kwargs)
      8         def inner_dec(*args, **kwargs):
      9             var = value
---> 10             res = f(*args, **kwargs)
     11             return res
     12         return inner_dec

所以我不明白为什么找不到var

有什么办法可以做这样的事情吗?

trans by 2020-02-08T08:21:14Z

为什么具有相同名称但签名不同的多重继承函数不被视为重载函数?

以下代码段在编译过程中产生“对foo的模糊调用”错误,我想知道在完全限定对foo的调用之前是否有解决此问题的方法:

#include <iostream>

struct Base1{
    void foo(int){
    }
};

struct Base2{
    void foo(float){
    }
};

struct Derived : public Base1, public Base2{
};

int main(){
    Derived d;
    d.foo(5);

    std::cin.get();
    return 0;
}

所以,问题就是标题所说的。 有想法吗? 我的意思是,以下内容可以完美工作:

#include <iostream>

struct Base{
    void foo(int){
    }
};

struct Derived : public Base{
    void foo(float){
    }
};

int main(){
    Derived d;
    d.foo(5);

    std::cin.get();
    return 0;
}
trans by 2020-02-07T04:42:19Z

JavaScript中的“ let”和“ var”之间是否存在性能差异

在范围方面,这两个关键字之间的差异已经进行了充分的讨论,但是我想知道两者之间是否存在任何性能差异?

trans by 2020-02-05T03:49:12Z

作用域-如何在Java中创建静态局部变量?

我读过Java与C / C ++不同,它不支持static局部变量。 现在,如果我想用局部变量编码一个函数,其值应在函数调用之间保持不变,我该怎么做?
我应该使用实例变量吗?

trans by 2020-01-28T19:36:36Z

java-我可以将变量从JSP scriptlet传递到JSTL,但不能从JSTL传递给JSP scriptlet,而无需

以下代码导致错误:

 <c:set var="test" value="test1"/>
 <%
   String resp = "abc";
   resp = resp + test;
   pageContext.setAttribute("resp", resp);
 %>
 <c:out value="${resp}"/>

错误说

"error a line 4: unknown symbol 'test'".

如何将test从JSTL代码传递到JSP脚本?

trans by 2020-01-28T04:55:59Z

scope-在python-3.6中带有'f'前缀的字符串

我正在尝试Python 3.6。 通过新代码,我偶然发现了这种新语法:

f"My formatting string!"

看来我们可以做这样的事情:

>>> name = "George"
>>> print(f"My cool string is called {name}.")
My cool string is called George.

谁能阐明这件事的内部运作方式? 特别是f前缀的字符串可以采用的变量范围是什么?

trans by 2020-01-27T06:05:17Z

javascript-如何从$ .getJSON函数返回变量

我想返回StudentId以在$.getJSON()范围之外的其他地方使用

j.getJSON(url, data, function(result)
{
    var studentId = result.Something;
});

//use studentId here

我想这与范围界定有关,但似乎与c#的工作方式不同

trans by 2020-01-23T19:49:07Z

作用域-Python覆盖嵌套函数中的变量

假设我有以下python代码:

def outer():
    string = ""
    def inner():
        string = "String was changed by a nested function!"
    inner()
    return string

我想调用external()返回“字符串已被嵌套函数更改!”,但我得到了“”。 我得出结论,Python认为string = "string was changed by a nested function!"行是对inner()局部的新变量的声明。 我的问题是:如何告诉Python应该使用external()字符串? 我不能使用global关键字,因为该字符串不是全局字符串,它只存在于外部作用域中。 有想法吗?

trans by 2020-01-21T04:37:50Z

为什么我的HelloWorld函数未在此范围内声明?

#include <iostream>

using namespace std;

int main()
{
    HelloWorld();
    return 0;
}

void HelloWorld()
{
    cout << "Hello, World" << endl;
}

我在g ++中遇到以下编译错误:

l1.cpp: In function 'int main()':
l1.cpp:5:15: error: 'HelloWorld' was not declared in this scope
trans by 2020-01-18T20:50:07Z

如何使用Emacs Lisp动态范围界定?

我以前学过Clojure,并且非常喜欢这种语言。 我也喜欢Emacs,并使用Emacs Lisp破解了一些简单的东西。 有一件事阻止了我在思想上对Elisp进行任何更重要的事情。 这是动态范围界定的概念。 我只是害怕它,因为它对我是如此陌生,并且闻起来像半全局变量。

因此,对于变量声明,我不知道哪些事情是安全的,哪些事情是危险的。 据我了解,使用setq设置的变量属于动态作用域(是吗?)那让let变量呢? 我读过的某个地方可以让您进行简单的词法作用域定义,但我读过的其他地方则可以让let var动态地作用域。

我最担心的是,我的代码(使用setq或let)意外地破坏了我调用的平台或第三方代码中的某些变量,或者在此类调用之后,我的局部变量被意外弄乱了。 如何避免这种情况?

我是否可以遵循一些简单的经验法则,准确地知道示波器会发生什么,而不会被某些奇怪的,难以调试的方式所咬住?

trans by 2020-01-13T02:37:43Z

javascript-如何在AngularJS控制器中获取当前作用域dom元素?

我有一个externalItems列表。 在每个externalItem内,我都有一个innerItems列表。 它们是动态排序的。

当鼠标光标指向innerItems之一时,我必须在该innerItem元素上方显示弹出窗口。

Popup div是body的孩子,因为我不想为innerItems的每一个单独创建一个弹出窗口。

如我所见,在ng-mouseover上,我调用了将左/上属性设置为绝对定位的弹出窗口的函数。 因此,对于每个innerItems,我想调用jQuery .offset()方法,该方法从页面的左上角为我提供左/上值。

那么如何获取当前作用域元素的jQuery对象呢? 或者,如果我选择了错误的方式

trans by 2020-01-12T11:44:09Z

angularjs-多个指令[Popup,我的可拖动式]要求新的/隔离的范围

我为对话框编写了一个指令(myPopup),并为拖动该对话框编写了另一个指令(myDraggable),但是我总是收到错误消息:

多个指令[myPopup,myDraggable]要求新的/隔离的范围

这是一个柱塞:[http://plnkr.co/edit/kMQ0hK5RnVw5xOBdDq5P?p=preview]

我能做什么?

JS代码:

var app = angular.module('myApp', []);

function myController($scope) {
    $scope.isDraggable = true;
}


app.directive('myPopup', [
    function () {
        "use strict";

        return {
            restrict: 'E',
            replace: true,
            transclude: true,
            template: '<div my-draggable="draggable"class="dialog"><div class="title">{{title}}</div><div class="content" ng-transclude></div></div>',
            scope: {
                title: '@?dialogTitle',
                draggable: '@?isDraggable',
                width: '@?width',
                height: '@?height',
            },
            controller: function ($scope) {
                // Some code
            },
            link: function (scope, element, attr) {
                if (scope.width) {
                    element.css('width', scope.width);
                }

                if (scope.height) {
                    element.css('height', scope.height);
                }                    
            }
        };
    }
]);

app.directive('myDraggable', ['$document',
    function ($document) {
    return {
        restrict: 'A',
        replace: false,
        scope: { enabled: '=myDraggable' },

        link: function (scope, elm, attrs) {
            var startX, startY, initialMouseX, initialMouseY;

            if (scope.enabled === true) {
                elm.bind('mousedown', function ($event) {
                    startX = elm.prop('offsetLeft');
                    startY = elm.prop('offsetTop');
                    initialMouseX = $event.clientX;
                    initialMouseY = $event.clientY;
                    $document.bind('mousemove', mousemove);
                    $document.bind('mouseup', mouseup);
                    $event.preventDefault();
                });
            }

            function getMaxPos() {
                var computetStyle = getComputedStyle(elm[0], null);
                var tx, ty;
                var transformOrigin =
                    computetStyle.transformOrigin ||
                    computetStyle.webkitTransformOrigin ||
                    computetStyle.MozTransformOrigin ||
                    computetStyle.msTransformOrigin ||
                    computetStyle.OTransformOrigin;
                tx = Math.ceil(parseFloat(transformOrigin));
                ty = Math.ceil(parseFloat(transformOrigin.split(" ")[1]));
                return {
                    max: {
                        x: tx + window.innerWidth - elm.prop('offsetWidth'),
                        y: ty + window.innerHeight - elm.prop('offsetHeight')
                    },
                    min: {
                        x: tx,
                        y: ty
                    }
                };
            }

            function mousemove($event) {
                var x = startX + $event.clientX - initialMouseX;
                var y = startY + $event.clientY - initialMouseY;
                var limit = getMaxPos();
                x = (x < limit.max.x) ? ((x > limit.min.x) ? x : limit.min.x) : limit.max.x;
                y = (y < limit.max.y) ? ((y > limit.min.y) ? y : limit.min.y) : limit.max.y;
                elm.css({
                    top: y + 'px',
                    left: x + 'px'
                });
                $event.preventDefault();
            }

            function mouseup() {
                $document.unbind('mousemove', mousemove);
                $document.unbind('mouseup', mouseup);
            }
        }
    };
}]);
trans by 2020-01-10T16:11:14Z

1 2 3 4 5 6 下一页 共6页