GVKun编程网logo

isinstance（foo，bar）vs type（foo）是bar

14

对于想了解isinstance的读者，本文将是一篇不可错过的文章，我们将详细介绍foo，barvstype，并且为您提供关于Array,ArrayConstructor,forinloop,typeo

对于想了解isinstance的读者，本文将是一篇不可错过的文章，我们将详细介绍foo，barvs type，并且为您提供关于Array, Array Constructor, for in loop, typeof, instanceOf_javascript技巧、c – int foo(type&bar);是一种不好的做法？、c# – 什么时候是obj.GetType().IsInstanceOfType(typeof(MyClass))是真的吗？、Cannot find an initializer for type '[(String)]' that accepts an argument list of type '(LazyForward的有价值信息。

本文目录一览：

isinstance（foo，bar）vs type（foo）是bar

isinstance（foo，bar）vs type（foo）是bar

确实是一个语义问题。

直到最近，如果我必须对结构进行任何类型检查，我都会使用type(obj) is listet。等 但是，自从加入SO以来，我已经注意到每个人（我是说
EVERYONE ）都在使用它isinstance(obj,list)。看来它们是同义词，并timeit揭示了它们之间几乎相同的速度。

def a(): return type(list()) is listdef b(): return isinstance(list(),list)from timeit import timeittimeit(a)# 0.5239454597495582timeit(b)# 0.5021292075273176

实际上，甚至dis同意他们是同义词，除了type is的COMPARE_OP

from dis import disdis(a)# 2           0 LOAD_GLOBAL              0 (type) #             3 LOAD_GLOBAL              1 (list) #             6 CALL_FUNCTION            0 (0 positional, 0 keyword pair) #             9 CALL_FUNCTION            1 (1 positional, 0 keyword pair) #            12 LOAD_GLOBAL              1 (list) #            15 COMPARE_OP               8 (is) #            18 RETURN_VALUEdis(b)# 2           0 LOAD_GLOBAL              0 (isinstance)#             3 LOAD_GLOBAL              1 (list) #             6 CALL_FUNCTION            0 (0 positional, 0 keyword pair) #             9 LOAD_GLOBAL              1 (list) #            12 CALL_FUNCTION            2 (2 positional, 0 keyword pair) #            15 RETURN_VALUE

坦率地说，我的说法if type(foo) is list:比起来更具可读性ifisinstance(foo,list):，第一个基本上只是伪代码，第二个使用某些参数调用某些函数（每次我必须在toisinstance或or中查找instanceof）。它看起来不像是类型转换，也没有明确的方法来知道是否isinstance(a,b)检查的b是实例，a反之亦然。

我从这个问题中了解到我们可以使用isinstance它，因为它比继承更好。type(ClassDerivedFromList) islist将失败，而isinstance(ClassDerivedFromList,list)将成功。但是，如果我要检查什么始终是基本目标，那么我真正失去的是什么typeis？

答案1

小编典典

如果我正在检查什么永远是基本对象，那么我从打字中真正地失去的是什么？

好吧，很高兴在您的问题中提供完整的书面答案，因此您的答案是 什么
都不会丢失！isinstance()正如您已经说过和引用过的，唯一必要的情况是检查给定类与另一个类的继承。type()只能用于检查实例是否 完全
属于给定的基本类型。

Array, Array Constructor, for in loop, typeof, instanceOf_javascript技巧

Array, Array Constructor, for in loop, typeof, instanceOf_javascript技巧

注意: JavaScript 中数组不是 关联数组。 JavaScript 中只有对象 来管理键值的对应关系。但是关联数组是保持顺序的，而对象不是。

由于 for in 循环会枚举原型链上的所有属性，唯一过滤这些属性的方式是使用 `hasOwnProperty` 函数，因此会比普通的 for 循环慢上好多倍。

遍历（Iteration）
为了达到遍历数组的最佳性能，推荐使用经典的 for 循环。

复制代码 代码如下:

var list = [1, 2, 3, 4, 5, ...... 100000000];
for(var i = 0, l = list.length; i console.log(list[i]);
}

上面代码有一个处理，就是通过 l = list.length 来缓存数组的长度。

虽然 length 是数组的一个属性，但是在每次循环中访问它还是有性能开销。 可能最新的 JavaScript 引擎在这点上做了优化，但是我们没法保证自己的代码是否运行在这些最近的引擎之上。

实际上，不使用缓存数组长度的方式比缓存版本要慢很多。

`length` 属性（The `length` property）
length 属性的 getter 方式会简单的返回数组的长度，而 setter 方式会截断数组。
复制代码 代码如下:

var foo = [1, 2, 3, 4, 5, 6];
foo.length = 3;
foo; // [1, 2, 3]

foo.length = 6;
foo; // [1, 2, 3]

译者注：在 Firebug 中查看此时 foo 的值是： [1, 2, 3, undefined, undefined, undefined] 但是这个结果并不准确，如果你在 Chrome 的控制台查看 foo 的结果，你会发现是这样的： [1, 2, 3] 因为在 JavaScript 中 undefined 是一个变量，注意是变量不是关键字，因此上面两个结果的意义是完全不相同的。

// 译者注：为了验证，我们来执行下面代码，看序号 5 是否存在于 foo 中。
5 in foo; // 不管在 Firebug 或者 Chrome 都返回 false
foo[5] = undefined;
5 in foo; // 不管在 Firebug 或者 Chrome 都返回 true
为 length 设置一个更小的值会截断数组，但是增大 length 属性值不会对数组产生影响。

结论（In conclusion）
为了更好的性能，推荐使用普通的 for 循环并缓存数组的 length 属性。使用 for in 遍历数组被认为是不好的代码习惯并倾向于产生错误和导致性能问题。

Array 构造函数
由于 Array 的构造函数在如何处理参数时有点模棱两可，因此总是推荐使用数组的字面语法 - [] - 来创建数组。

[1, 2, 3]; // 结果: [1, 2, 3]
new Array(1, 2, 3); // 结果: [1, 2, 3]

[3]; // 结果: [3]
new Array(3); // 结果: []
new Array(''3'') // 结果: [''3'']
译者注：这里的模棱两可指的是数组的两种构造函数语法 var arr1 = new Array(arrayLength); var arr2 = new Array(element0, element1, ..., elementN);

// 译者注：因此下面的代码将会使人很迷惑
new Array(3, 4, 5); // 结果: [3, 4, 5]
new Array(3) // 结果: []，此数组长度为 3
由于只有一个参数传递到构造函数中（译者注：指的是 new Array(3); 这种调用方式），并且这个参数是数字，构造函数会返回一个 length 属性被设置为此参数的空数组。需要特别注意的是，此时只有 length 属性被设置，真正的数组并没有生成。译者注：在 Firebug 中，你会看到 [undefined, undefined, undefined]，这其实是不对的。在上一节有详细的分析。

var arr = new Array(3);
arr[1]; // undefined
1 in arr; // false, 数组还没有生成
这种优先于设置数组长度属性的做法只在少数几种情况下有用，比如需要循环字符串，可以避免 for 循环的麻烦。

new Array(count + 1).join(stringToRepeat);
// 译者注：new Array(3).join(''#'') 将会返回 "##"
结论（In conclusion）
应该尽量避免使用数组构造函数创建新数组。推荐使用数组的字面语法。它们更加短小和简洁，因此增加了代码的可读性。

for in 循环
和 in 操作符一样，for in 循环同样在查找对象属性时遍历原型链上的所有属性。

注意: for in 循环不会遍历那些 enumerable 设置为 false 的属性；比如数组的 length 属性。
复制代码 代码如下:

// 修改 Object.prototype
Object.prototype.bar = 1;

var foo = {moo: 2};
for(var i in foo) {
console.log(i); // 输出两个属性：bar 和 moo
}

由于不可能改变 for in 自身的行为，因此有必要过滤出那些不希望出现在循环体中的属性，这可以通过 Object.prototype 原型上的 `hasOwnProperty` 函数来完成。

注意: 由于 for in 总是要遍历整个原型链，因此如果一个对象的继承层次太深的话会影响性能。

使用 `hasOwnProperty` 过滤（Using `hasOwnProperty` for filtering）
复制代码 代码如下:

// foo 变量是上例中的
for(var i in foo) {
if (foo.hasOwnProperty(i)) {
console.log(i);
}
}

这个版本的代码是唯一正确的写法。由于我们使用了 hasOwnProperty，所以这次只输出 moo。如果不使用 hasOwnProperty，则这段代码在原生对象原型（比如 Object.prototype）被扩展时可能会出错。

一个广泛使用的类库 Prototype 就扩展了原生的 JavaScript 对象。因此，但这个类库被包含在页面中时，不使用 hasOwnProperty 过滤的 for in 循环难免会出问题。

最佳实践（Best practices）
推荐总是使用 hasOwnProperty。不要对代码运行的环境做任何假设，不要假设原生对象是否已经被扩展了。

typeof 操作符
typeof 操作符（和 `instanceof` 一起）或许是 JavaScript 中最大的设计缺陷，因为几乎不可能从它们那里得到想要的结果。

尽管 instanceof 还有一些极少数的应用场景，typeof 只有一个实际的应用（译者注：这个实际应用是用来检测一个对象是否已经定义或者是否已经赋值），而这个应用却不是用来检查对象的类型。

注意: 由于 typeof 也可以像函数的语法被调用，比如 typeof(obj)，但这并是一个函数调用。那两个小括号只是用来计算一个表达式的值，这个返回值会作为 typeof 操作符的一个操作数。实际上不存在名为 typeof 的函数。

JavaScript 类型表格（The JavaScript type table）
Value Class Type
-------------------------------------
"foo" String string
new String("foo") String object
1.2 Number number
new Number(1.2) Number object
true Boolean boolean
new Boolean(true) Boolean object
new Date() Date object
new Error() Error object
[1,2,3] Array object
new Array(1, 2, 3) Array object
new Function("") Function function
/abc/g RegExp object (function in Nitro/V8)
new RegExp("meow") RegExp object (function in Nitro/V8)
{} Object object
new Object() Object object
上面表格中，Type 一列表示 typeof 操作符的运算结果。可以看到，这个值在大多数情况下都返回 "object"。

Class 一列表示对象的内部属性 [[Class]] 的值。

JavaScript 标准文档中定义: [[Class]] 的值只可能是下面字符串中的一个： Arguments, Array, Boolean, Date, Error, Function, JSON, Math, Number, Object, RegExp, String.

为了获取对象的 [[Class]]，我们需要使用定义在 Object.prototype 上的方法 toString。

对象的类定义（The Class of an object）
JavaScript 标准文档只给出了一种获取 [[Class]] 值的方法，那就是使用 Object.prototype.toString。
复制代码 代码如下:

function is(type, obj) {
var clas = Object.prototype.toString.call(obj).slice(8, -1);
return obj !== undefined && obj !== null && clas === type;
}

is(''String'', ''test''); // true
is(''String'', new String(''test'')); // true

上面例子中，Object.prototype.toString 方法被调用，this 被设置为了需要获取 [[Class]] 值的对象。

译者注：Object.prototype.toString 返回一种标准格式字符串，所以上例可以通过 slice 截取指定位置的字符串，如下所示：
复制代码 代码如下:

Object.prototype.toString.call([]) // "[object Array]"
Object.prototype.toString.call({}) // "[object Object]"
Object.prototype.toString.call(2) // "[object Number]"

ES5 提示: 在 ECMAScript 5 中，为了方便，对 null 和 undefined 调用 Object.prototype.toString 方法，其返回值由 Object 变成了 Null 和 Undefined。

译者注：这种变化可以从 IE8 和 Firefox 4 中看出区别，如下所示：
复制代码 代码如下:

// IE8
Object.prototype.toString.call(null) // "[object Object]"
Object.prototype.toString.call(undefined) // "[object Object]"

// Firefox 4
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
测试为定义变量（Testing for undefined variables）
typeof foo !== ''undefined''

上面代码会检测 foo 是否已经定义；如果没有定义而直接使用会导致 ReferenceError 的异常。这是 typeof 唯一有用的地方。

结论（In conclusion）
为了检测一个对象的类型，强烈推荐使用 Object.prototype.toString 方法；因为这是唯一一个可依赖的方式。正如上面表格所示，typeof 的一些返回值在标准文档中并未定义，因此不同的引擎实现可能不同。

除非为了检测一个变量是否已经定义，我们应尽量避免使用 typeof 操作符。

instanceof 操作符
instanceof 操作符用来比较两个操作数的构造函数。只有在比较自定义的对象时才有意义。如果用来比较内置类型，将会和 typeof 操作符 一样用处不大。

比较自定义对象（Comparing custom objects）
复制代码 代码如下:

function Foo() {}
function Bar() {}
Bar.prototype = new Foo();

new Bar() instanceof Bar; // true
new Bar() instanceof Foo; // true

// 如果仅仅设置 Bar.prototype 为函数 Foo 本省，而不是 Foo 构造函数的一个实例
Bar.prototype = Foo;
new Bar() instanceof Foo; // false
`instanceof` 比较内置类型（Using `instanceof` with native types）
new String(''foo'') instanceof String; // true
new String(''foo'') instanceof Object; // true

''foo'' instanceof String; // false
''foo'' instanceof Object; // false

有一点需要注意，instanceof 用来比较属于不同 JavaScript 上下文的对象（比如，浏览器中不同的文档结构）时将会出错，因为它们的构造函数不会是同一个对象。

结论（In conclusion）
instanceof 操作符应该仅仅用来比较来自同一个 JavaScript 上下文的自定义对象。正如 `typeof` 操作符一样，任何其它的用法都应该是避免的。

c – int foo(type&bar);是一种不好的做法？

c – int foo(type&bar);是一种不好的做法？

好吧,我们来了.我的C书还有另一个提议的做法.它说“返回值(非空)函数不应该将引用类型作为参数.”所以基本上如果你要实现这样的函数： 

int read_file(int& into){
   ...
}

并使用整数返回值作为某种错误指示符(忽略我们有异常的事实)然后该函数编写得很糟糕它实际上应该像

void read_file(int& into,int& error){

}

现在对我来说,第一个更清晰,更好用.如果要忽略错误值,可以轻松完成.但是这本书暗示了后来的.请注意,本书并未说返回值函数是坏的.它宁愿说你应该只返回一个值,或者你应该只使用引用.

你对此有何看法？我的书上装满了废话吗？ (再次)

解决方法

建议很愚蠢.直接返回值更小,更容易键入.

直接退货：

if (read_file(...)) {
    ... handle problem ...
}

间接回报：

int status;

read_file(...,status);
if (status) {
    ... handle problem ...
}

编辑：一个更大的问题是是否使用非const@R_301_5823@.让副作用飞出参数会令人惊讶.一种编码标准说参考参数应该是const,输出参数应该使用指针.这样读者就可以得到一个&在呼叫点喊出“这个参数发生了什么”.

c# – 什么时候是obj.GetType().IsInstanceOfType(typeof(MyClass))是真的吗？

c# – 什么时候是obj.GetType().IsInstanceOfType(typeof(MyClass))是真的吗？

我正在看别人写的这段代码,我想知道它什么时候会评估为真.基本上,它说someType是someOtherType的一个实例.它甚至有意义吗？到目前为止,我已经尝试过： 

derivedClass.GetType().isinstanceOfType(typeof(BaseClass)) 

baseClass.GetType().isinstanceOfType(typeof(DerivedClass)) 

myClass.GetType().isinstanceOfType(typeof(MyClass))

并且所有人都评价为假.

任何帮助表示赞赏.

解决方法

只有当涉及的对象(derivedClass,baseClass和myClass)是对象的实例或未记录的RuntimeType对象(注意 Type是抽象的)时,这3行中的每一行都将返回true,因此例如以下将导致true声明： 

var myObject = new object();
myObject.GetType().isinstanceOfType(typeof(Console));

myObject = typeof(Object);
myObject.GetType().isinstanceOfType(typeof(Console));

请注意,使用的类型(在本例中为Console)无关紧要,并且对语句的结果没有影响.

为什么？

IsInstanceOfType的文档告诉我们,如果传入的对象是当前类型的实例,它将返回true,例如,如果myForm是一个派生自Form的类,则以下语句将返回true,否则它将返回false.

typeof(Form).isinstanceOfType(myForm);

在你的情况下,myForm实际上是typeof(BaseClass),它是未记录的类型RuntimeType(派生自Type),因此如果这个未记录的类型恰好从提供的类型派生,你只会返回true – 这是不太可能是理想的行为.

我应该用什么呢？

您可能会追溯的是is keword,如果提供的对象是给定类型的实例,则返回true

derivedClass is BaseClass
baseClass is DerivedClass
myClass is MyClass

Cannot find an initializer for type '[(String)]' that accepts an argument list of type '(LazyForward

Cannot find an initializer for type '[(String)]' that accepts an argument list of type '(LazyForward

@H_301_1@Swift编译错误:Cannot find an initializer for type ''[(String)]'' that accepts an argument list of type ''(LazyForwardCollection<MapCollectionView<Dictionary<Int,String>,Int>>)''

错误代码:

@H_301_1@ var dict = [1: "m",2: "i",3: "i",4: "s"]

@H_301_1@

@H_301_1@ let dictKeysArray = [String](dict.keys)

@H_301_1@

@H_301_1@ 根据字典字面量推断,该字典的类型是<Int: String>.即key为Int类型.错误的原因就是你用Int类型的初始化了key,现在又用String类型的取.所以会报该编译错误.

@H_301_1@

正确写法:

@H_301_1@let dictKeysArray = dict.keys

或者将String改成Int.

关于isinstance和foo，barvs type的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于Array, Array Constructor, for in loop, typeof, instanceOf_javascript技巧、c – int foo(type&bar);是一种不好的做法？、c# – 什么时候是obj.GetType().IsInstanceOfType(typeof(MyClass))是真的吗？、Cannot find an initializer for type '[(String)]' that accepts an argument list of type '(LazyForward等相关内容，可以在本站寻找。

本文标签：

上一篇是否有CSS“ haschildren”选择器？（css选择器有否定选择器吗）

下一篇网站上所有浏览器（Chrome）上每个打印页面上的页脚（谷歌浏览器打印的页眉页脚在哪）

相关文章