这是我写的一个使用if-else分支和保护表达式的例子.什么时候比另一个更合适？我想知道这一点的主要原因是因为语言通常具有惯用的做事方式.
test1 a b =
if mod b 3 ? 0 then a + b
else if mod b 5 ? 0 then a + b
else a
test2 a b
| mod b 3 ? 0 = a + b
| mod b 5 ? 0 = a + b
| otherwise = a
在Ruby中这样做的正确方法是什么？
def callOrElse(obj, method, default)
if obj.respond_to?(method)
obj.__send__(method)
else
default
end
end
我有一个返回地图的函数.键是静态的,但值是有条件的.像这样:
(defn map-returning-function [x y]
{:a (if (some-test-fn x) "one value" "other value"
:b (if (some-test-fn x) 15 25
:c (if (different-test y) :one :two})
是否有一些更优雅的方法来实现这一点,而无需if为每个值编写测试？我能想到的另一种方式是
(defn another-map-returning-function [x y]
(if (some-test-fn x)
{:a "one value", :b 15, :c (if (different-test y) :one :two)}
{:a "other value" :b 25, :c (if (different-test y) :one :two)}))
这对我来说似乎并不好,因为它重复了条件的每个分支的键名,并重复了函数调用different-test.天堂禁止我需要一个cond而不是一个if.
我一直在阅读有关之间的差异eql?和==红宝石，据我所知，==而在比较值eql?的价值和类型进行比较
根据红宝石文档：
对于Object类的对象，是否为eql？是==的同义词。子类通常会继承这一传统，但也有例外。
似乎文档中指定的行为似乎不会自动继承，但这只是有关如何实现这些方法的建议。这是否还意味着如果您覆盖其中一个==，eql?则应该覆盖两个？
在Person下面的类中，这是重写的典型方法，eql?并且==约束越少，则将其==委托给约束性更大的对象eql?（如果仅实现比较值而不是类型，则eql?委托给它似乎是倒向的）。====
class Person
def initialize(name)
@name = name
end
def eql?(other)
other.instance_of?(self.class) && @name == other.name
end
def ==(other)
self.eql?(other)
end
protected
attr_reader :name
end
我在包中有一个抽象类foo(在这个特殊情况下,一个特性),可以由各种子类实现,我想创建一个正交子类,用于一个更具体的包bar,添加特定于包的信息.似乎最好的方法是通过组合(包装)而不是继承,因为否则我必须声明每个foo-package子类的特定于包的版本.但这会导致需要转发的受保护成员出现问题:
package foo {
trait Foo {
protected def bar: Int
}
}
package bar {
import foo.Foo
class Baz
class WrapFoo(wrapped: Foo) extends Baz with Foo {
protected def bar = wrapped.bar
}
}
这会导致错误:
~/test/scala 14:54 152272% scalac testprotected.scala
testprotected.scala:11: error: method bar in trait Foo cannot be accessed in foo.Foo
Access to protected method bar not permitted because
prefix type foo.Foo does not conform to
class WrapFoo in package bar where …在Python中对iterable执行简单转换是通过列表解析来实现的:
y = [f(arg) for arg in args]
where f是一个简单的语句,或者一个函数mapif f是一个命名函数:
y = map(f, args)
圭多有利于列表解析过map(lambda x:..., args),确实列表内涵上的使用map或filter 在所有.
但是,我不清楚我应该如何解决以下问题:
解决此类问题最常用的方法是什么？我见过并尝试过的一些我已经参与过的Python项目:
显而易见的方法是预先声明输出和循环:
def transform(...):
...
y = []
for arg in args:
first_statement
second_statement
...
y.append(statement)
评论:
y必须与长度相同args)另一种选择是将逻辑封装在嵌套函数中,然后使用map或list comprehension调用它:
def transform(...):
...
def anonymous(arg):
first_statement
second_statement
...
return statement
y = map(anonymous, …我是一名Java程序员,正在迈向Scala编程.
我已经定义了一个类似的函数(可能是惯用错误,我不知道......):
def someGenericAlgorithm(param1: String, param1: String, param3: String) = {
val triedResult1 = someFunction(param1)
triedResult1 match {
case Success(result1) =>
val triedResult2 = someOtherFunction(param2)
triedResult2 match {
case Success(result2) =>
val triedPolymorphicResult = someToBeReplacedAccordingToSpecificLogicFunction(result1, result2, param3)
triedPolymorphicResult match {
case Success(polymorphicResult) =>
doSomethingGeneric(polymorphicResult)
....
case Failure(exception) =>
....
}
case Failure(exception) =>
....
}
case Failure(exception) =>
....
}
}
因此该函数接收3个参数,按顺序处理前两个参数,获取处理结果并将其传递给someToBeReplacedAccordingToSpecificLogicFunction第三个参数的旁边.
现在我希望编写一个类似的函数,因为前两个函数调用存在,错误逻辑是相同的,唯一的区别someToBeReplacedAccordingToSpecificLogicFunction是现在是aReplacementLogicFunction.
如果两个函数具有相同的签名,我想这不会是一个问题,但是,它们没有,它aReplacementLogicFunction有不同的参数,更具体地说,还有两个参数.那么你可以说,我可以在第一种情况下传入Option这两个Options的参数None,这样我就可以将我的两个函数对齐为相同的签名,因此: …
这是我正在编写的一个程序,它将创建一个对文件目录进行分类的csv:
matches = []
for root, dirnames, filenames in os.walk(directory):
for filename in fnmatch.filter(filenames, '*[A-Z]*'):
matches.append([os.path.join(root, filename), "No Capital Letters!"])
test = re.compile(".*\.(py|php)", re.IGNORECASE)
for filename in filter(test.search, filenames):
matches.append([os.path.join(root, filename), "Invalid File type!"])
基本上,用户选择一个文件夹,程序表示问题文件,可以是几种类型(这里只列出两种:没有大写字母的文件,没有php或python文件).可能会有五六个案例.
虽然这有效,但我想重构.是否有可能做类似的事情
for filename in itertools.izip(fnmatch.filter(filenames, '*[A-Z]*'), filter(test.search, filenames), ...):
matches.append([os.path.join(root, filename), "Violation")
能够跟踪哪些原始解压缩列表导致"违规"？
我最近进入Go并看到了很多关于如何进行错误处理的讨论.
我看到的模式如下:
err := DoSomething()
if err != nil {
//handle
}
// continue
经常在管理amqp连接时,我的条件是我只想在错误为nil时继续,因为那时我需要在连接上做一些事情:
c, err := Connect()
if err != nil {
return nil, err
}
s,err := c.RegisterSomethingOnConnection()
if err != nil {
return nil, err
}
val, err := s.DoSomething()
return val, err
正如你所看到的,c.RegisterSomethingOnConnection如果返回的错误Connect()是nil,我只想运行该行.
但是,由于提前退货,我不喜欢上述情况.早期的回报让我感到不舒服,因为从长远来看,它会损害可读性,并且在功能退出时会完全模糊.到目前为止,我的解决方案是执行以下操作:
var err error
var val ReturnType
c,err := Connect()
if err == nil {
s,err := c.RegisterSomethingOnConnection()
if err == nil {
val,err = s.DoSomething()
}
} …一个std::optional<T>可以被初始化到像这样的分离状态:
std::optional<int> oi { nullopt };
但也像这样:
std::optional<int> oi { };
并且类似地用于分配(oi = {}或oi = nullopt).
除了个人偏好/美学意义之外,这些之间是否存在差异,这应该让我更喜欢一个？或者根本没关系？
注意:我问的是我想要显式初始化可选项的情况,而不是默认初始化它(例如强调).