Exception 在动态语言中，参数化类型检查的正确位置在哪里？

考虑以下几点。（伪代码）

类
{
你好
世界
公众的
构造函数（你好，世界）
{
if（hello不是字符串）
{
抛出异常（）
}
if（世界不是数组）
{
抛出异常（）
}
这是setHello（hello）
这个.setWorld（世界）
}
受保护的
setHello（你好）
{
if（hello不是字符串）
{
抛出异常（）
}
你好
}
私有的
setWorld（世界）
{
if（世界不是数组）
{
抛出异常（）
}
如果（不是这个：isASafe（世界））
{
抛出异常（）
}
这个世界
}
公众的
静止的
isASafe（世界）
{
if（世界不是数组）
{
返回错误
}
如果（世界长度<1）
{
返回错误
}
如果（世界[天空]不是蓝色的）
{
返回错误
}
返回真值
}
}

最佳做法是先在构造函数中执行参数类型/有效性检查，然后再在函数中执行参数类型/有效性检查，还是仅在两种方法中的一种方法中执行参数类型/有效性检查。（即构造函数异或方法）

此外，所述方法的范围（公共/受保护/私有/等）是否改变了上述答案（1）。例如，isASafe（world）是一个公共静态方法，并且只在类中封装逻辑

构造器是否应该进行任何检查

---

我对这件事有自己的看法，但我想看看其他人怎么想，以及他们认为什么最有效。

检查参数有效性对于所有公共功能来说显然比受保护或私人功能更重要。因为您的构造函数是公共的，所以清楚地检查是有意义的

并非总是可以在所有情况下检查有效性-什么是有效的或无效的问题，例如天空==蓝色，在您无法访问的上下文中可能会有所不同

我更喜欢防御代码。在检测到数据不一致之前运行的语句越少，意味着断言发生的位置就越靠近导致问题的语句，从而使查找更容易/更快

这意味着我倾向于对大多数方法的参数进行一些健全性检查。我通常不必检查某些私有方法，尽管您可能会冒着有人（可能是您）在某一天将其设置为受保护或公开的风险，而且您也会错过在更接近源的地方发现数据不一致的机会

Class
{
    hello
    world

    public
    constructor(hello, world)
    {
        if (hello is not String)
        {
            throw Exception()
        }

        if (world is not Array)
        {
            throw Exception()
        }

        this.setHello(hello)
        this.setWorld(world)
    }

    protected
    setHello(hello)
    {
        if (hello is not String)
        {
            throw Exception()
        }

        this.hello = hello
    }

    private
    setWorld(world)
    {
        if (world is not Array)
        {
            throw Exception()
        }

        if (not this:isASafe(world))
        {
           throw Exception()
        }

        this.world = world
    }

    public
    static
    isASafe(world)
    {
        if (world is not Array)
        {
            return false
        }

        if (world.length < 1)
        {
            return false
        }

        if (world['sky'] is not 'blue')
        {
            return false
        }

        return true
    }
}