blocks|key|2850989|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2850990|我认为没有一种直接的方法来指定一个数字是整数还是浮点数。在TypeScript规范的3.2.1节中，我们可以看到：|ordered-list-item|2850991|2850992|"...The+Number基元类型对应于命名类似的JavaScript基元类型，并表示双精度64位格式IEEE754浮点值...“|2850993|2850994|我认为int是Visual+Studio+intelliSense中的一个错误。正确的是number.|offset|length|style|CODE|2850995|2850996|entityMap^0|0|0|0|0|0|3|3|18|6|0|0^^$0|@$1|2|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|R|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|S|7|@]|8|@]|9|$]]|$1|E|3|F|4|5|6|T|7|@]|8|@]|9|$]]|$1|G|3|-4|4|5|6|U|7|@]|8|@]|9|$]]|$1|H|3|I|4|C|6|V|7|@$J|W|K|X|L|M]|$J|Y|K|Z|L|M]]|8|@]|9|$]]|$1|N|3|-4|4|5|6|10|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|11|7|@]|8|@]|9|$]]]|P|$]]

<ol>
<li>I think there is not a direct way to specify whether a number is integer or floating point. In the TypeScript specification section 3.2.1 we can see:

<blockquote>
 "...The Number primitive type corresponds to the similarly named JavaScript primitive type and represents double-precision 64-bit format IEEE 754 floating point values..."
</blockquote></li>
<li>I think <code>int</code> is a bug in Visual Studio intelliSense. The correct is <code>number</code>.</li>
</ol>

blocks|key|3064268|text|TypeScript是JavaScript的超集，它没有整数的概念。它只有一个数字的概念，它有一个浮点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3064269|一般来说，编译器为TypeScript+int类型仅强制执行整数所需的工作量可能会很大，并且在某些情况下，仍然无法确保在编译时仅分配整数，这就是为什么不能可靠地向TypeScript添加int的原因。|offset|length|style|CODE|3064270|当您最初在Visual+Studio中获取intelliSense时，该工具不可能确定要提供什么，因此您可以获取所有内容，包括int+-但是一旦您处理的是已知类型的内容，您就会获得合理的intelliSense。|3064271|示例|3064272|var+myInt:+number;
var+myString:+string;

myInt.+//+toExponential,+toFixed,+toPrecision,+toString
myString.+//+charAt,+charCodeAt,+concat,+indexOf,+lastIndexOf,+length+and+many+more...|code-block|syntax|javascript|3064273|entityMap^0|0|2L|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|X|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|Y|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

TypeScript is a superset of JavaScript, which doesn't have a concept of an int. It only has the concept of a number, which has a floating point.
Generally speaking, the amount of work the compiler would have to do to enforce only whole numbers for a TypeScript int type could potentially be massive and in some cases it would still not be possible to ensure at compile time that only whole numbers would be assigned, which is why it isn't possible to reliably add an <code>int</code> to TypeScript.
When you initially get intelliSense in Visual Studio, it isn't possible for the tooling to determine what to supply, so you get everything, including int - but once you are dealing with something of a known type, you'll get sensible intelliSense.
Examples
<pre><code>var myInt: number;
var myString: string;

myInt. // toExponential, toFixed, toPrecision, toString
myString. // charAt, charCodeAt, concat, indexOf, lastIndexOf, length and many more...
</code></pre>

blocks|key|210558|text|正如你所看到的，typescript没有像javascript语言那样的浮点数据类型。只有同时覆盖所有int和double的number；也许你必须创建一个接受一个数字的函数，并检查它是int还是double，在错误/成功的情况下返回一些状态。像这样作为你的类的方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|210559|function+SetN(x:number)+{
+++var+is_int+=+parseInt(x)+===+parseFloat(x);
+++if(is_int)+this.n+=+x;
+++return+is_int;
}

//..
y+=+10.5;
if(SetN(y))+{
++//OK
}+else+{
+++//error+not+set+y+isn't+a+int
}|code-block|syntax|javascript|210560|注意:它对10.0不起作用，例如，如果你真的不想要它，也许你必须把它转换成字符串，并尝试找到一个.。|210561|entityMap^0|1F|3|1J|6|1Q|6|2L|3|2Q|6|0|0|5|4|1C|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|N|$]]

Well, as you have seen, typescript haven't float data type such as javascript language. Only have the <code>number</code> that cover all <code>int</code> and <code>double</code> at same time; maybe you must make a function that take a number and check it if it's a <code>int</code> or <code>double</code>, by returning some state in case error/success. Something like this as method of your class:

<pre><code>function SetN(x:number) {
 var is_int = parseInt(x) === parseFloat(x);
 if(is_int) this.n = x;
 return is_int;
}

//..
y = 10.5;
if(SetN(y)) {
 //OK
} else {
 //error not set y isn't a int
}
</code></pre>

Note: it doest not works for <code>10.0</code> e.g. If you want no really it, maybe you must conver it to string and try to find a <code>.</code>.

blocks|key|212531|text|在earlier+versions+of+javascript中保留了int以供将来使用关键字(如果您愿意，可以使用ECMAScript)。但它现在是一个有效的词(其中"+now“等同于”在最新规范中“)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|212532|例如，在262年，它仍然被保留，http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf|212533|除了typescript之外，还可以实现int数据类型，但所有编译时类型检查和强制转换规则都可用。|212534|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Future_reserved_keywords_in_older_standards|1|http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf^0|Z|3|1|U|0|0|G|21|1|0|K|3|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@$9|10|A|11|1|12]]|E|$]]|$1|H|3|I|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

<code>int</code> was reserved for future use keyword in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Future_reserved_keywords_in_older_standards" rel="nofollow noreferrer">earlier versions of javascript</a> (ECMAScript if you prefer). But it is a valid word now (where "now" equates to "in the latest spec").

For instance, in 262 it was still reserved, <a href="http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf" rel="nofollow noreferrer">http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf</a>

It would make nice addition to typescript to have an <code>int</code> datatype implemented but with all compile-time type checking and casting rules available.

blocks|key|211029|text|这是一个不做装箱的implementation+of+number+interface。我认为可以使用这种设计来创建Integer类型|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|211030|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/31174747/2905130^0|9|Y|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Here is an <a href="https://stackoverflow.com/a/31174747/2905130">implementation of number interface</a> that doesn't do boxing. I think it would be possible to use this design to create an Integer type

blocks|key|2851152|text|在TypeScript中，您可以使用标记近似有时称为不透明类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2851153|//+Helper+for+generating+Opaque+types.
type+Opaque<T,+K>+=+T+&+{+__opaque__:+K+};

//+2+opaque+types+created+with+the+helper
type+Int+=+Opaque<number,+'Int'>;
type+ID+=+Opaque<number,+'ID'>;

//+using+our+types+to+differentiate+our+properties+even+at+runtime
//+they+are+still+just+numbers
class+Foo+{
++++someId:+ID;
++++someInt:+Int;
}

let+foo+=+new+Foo();

//+compiler+won't+let+you+do+this+due+to+or+markers
foo.someId+=+2;
foo.someInt+=+1;

//+when+assigning,+you+have+to+cast+to+the+specific+type
//+NOTE:+This+is+not+completely+type+safe+as+you+can+trick+the+compiler+
//+with+something+like+foo.someId+=+1.45+as+ID+and+it+won't+complain.
foo.someId+=+2+as+ID;
foo.someInt+=+1+as+Int;

//+you+can+still+consume+as+numbers
let+sum:+number+=+foo.someId+%2B+foo.someInt;|code-block|syntax|javascript|2851154|这样做可以让您在代码中更明确地说明您的属性需要什么类型，并且编译器不允许您在没有强制转换的情况下分配原始值。这不会产生任何额外的.js输出，而且您仍然可以使用这些值作为它们所基于的任何类型。在本例中，我使用的是数字，但您也可以使用字符串和其他类型。|2851155|在本例中，您仍然可以欺骗编译器接受不是Int或Id的内容，但是如果您试图将1.45赋值为Int或类似的内容，它应该会跳出来。您还可以选择创建帮助器函数，用于创建值以提供运行时验证。|2851156|有许多不同的方法可以创建“标记”类型。这里有一篇好文章：https://michalzalecki.com/nominal-typing-in-typescript/|offset|length|2851157|entityMap|0|LINK|mutability|MUTABLE|url|https://michalzalecki.com/nominal-typing-in-typescript/^0|0|0|0|0|S|1J|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

In TypeScript you can approximate what is sometimes called an opaque type using a marker.

<pre><code>// Helper for generating Opaque types.
type Opaque&lt;T, K&gt; = T &amp; { __opaque__: K };

// 2 opaque types created with the helper
type Int = Opaque&lt;number, 'Int'&gt;;
type ID = Opaque&lt;number, 'ID'&gt;;

// using our types to differentiate our properties even at runtime
// they are still just numbers
class Foo {
 someId: ID;
 someInt: Int;
}

let foo = new Foo();

// compiler won't let you do this due to or markers
foo.someId = 2;
foo.someInt = 1;

// when assigning, you have to cast to the specific type
// NOTE: This is not completely type safe as you can trick the compiler 
// with something like foo.someId = 1.45 as ID and it won't complain.
foo.someId = 2 as ID;
foo.someInt = 1 as Int;

// you can still consume as numbers
let sum: number = foo.someId + foo.someInt;
</code></pre>

Doing this allow you to be more explicit in your code as to what types your properties expect, and the compiler won't allow you to assign a primitive value without a cast. This doesn't produce any additional .js output, and you can still consume and use the values as whatever types they are based on. In this example I'm using numbers, but you can use on strings and other types as well. 

You can still trick the compiler into accepting something that isn't an Int or an Id in this example, but it should jump out if you were trying to assign 1.45 as Int or something like that. You also have the option of creating helper functions that you use to create your values to provide runtime validation.

There's a number of different ways you can create "marked" types. Here's a good article: <a href="https://michalzalecki.com/nominal-typing-in-typescript/" rel="noreferrer">https://michalzalecki.com/nominal-typing-in-typescript/</a>

blocks|key|2851200|text|TypeScript中没有integer或float，而是number类型，就像在JavaScript中一样。但是如果你想告诉程序员你想要的是integer类型，你可以尝试使用Type+Aliases，如下所示|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2851201|type+integer+=+number;
type+float+=+number;

//+example:
function+setInt(id:+integer)+{}|code-block|syntax|javascript|2851202|但这仍然是number类型，您可以获取float。|2851203|文档中描述的一部分：|2851204|“别名实际上并不会创建一个新类型--它会创建一个新名称来引用该类型。给基元添加别名并不是特别有用，尽管它可以用作文档的一种形式。”|2851205|entityMap|0|LINK|mutability|MUTABLE|url|https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-aliases^0|D|7|L|5|T|6|1Z|7|2G|C|0|0|0|5|6|J|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|F|3|G|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1G|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1H|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

There is no <code>integer</code> or <code>float</code> but <code>number</code> type in TypeScript like in JavaScript.
But if you want tell programmer that you expect <code>integer</code> type you can try to use <a href="https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-aliases" rel="noreferrer">Type Aliases</a> like
<pre><code>type integer = number;
type float = number;

// example:
function setInt(id: integer) {}
</code></pre>
but this is still <code>number</code> type and you can get <code>float</code>.
Part of description from documentation: 
&quot;Aliasing doesn’t actually create a new type - it creates a new name to refer to that type. Aliasing a primitive is not terribly useful, though it can be used as a form of documentation.&quot;

blocks|key|3064579|text|这是我在Google上的最高搜索结果，所以我想我应该提供我找到的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3064580|使用bigint|offset|length|style|CODE|3064581|现在是2020年了，bigint已经被接受了，它值得一提。您可以简单地执行以下操作。请注意，与number相比，bigint带来了更大的性能影响。|3064582|const+myNumber:+bigint+=+10n|code-block|syntax|javascript|3064583|使用标称类型/标记类型/不透明类型|3064584|另一种选择是使用nominal类型，但可以说它不太符合人体工程学，而且我不确定它是否比bigint更快，但该模式确实适用于任何类型，而不仅仅是number。TypeScript对此没有“一流”的支持，所以你不得不做一个厚脸皮的黑客攻击。有一个名为newtype-ts的库，其中包括像Integer这样的常见类型，所以您可能只想使用它，但我将在下面解释其工作原理。|3064585|首先，我们定义了integer类型。|3064586|const+TAG+=+Symbol()
type+integer+=+number+&+{+readonly+[TAG]:+unique+symbol+}|3064587|TAG确保我们有一个唯一的值，这样我们就不会意外地创建一个具有相同键的对象，并且出于同样的原因，我们也使该字段成为唯一的符号。现在，你的整数实际上不会有这个对象字段，但这很好。|3064588|这样，您仍然可以使用%2B将integer添加到number中。不太好。因此，您可以通过使用函数对类型系统进行消息传递来对此处的参数强制类型安全。我只是将其称为integer，正如你所看到的，它并不是特定于guard+s的-，你可以创建更多不透明的类型，然后再次使用它。|3064589|type+guard+=+<A>(f:+(...ns:+Array<A>)+=>+A,+...ns:+Array<A>)+=>+A
const+guard:+guard+=+(f,+...ns)+=>+f(...ns)|3064590|如果您尝试使用number调用它|3064591|const+bad:+integer+=+guard((a,+b)+=>+a+%2B+b+as+integer,+myCoolInteger,+10)|3064592|您将得到如下错误|3064593|Argument+of+type+'10'+is+not+assignable+to+parameter+of+type+'integer'.
++Type+'10'+is+not+assignable+to+type+'{+readonly+[TAG]:+unique+symbol;+}'.(2345)|3064594|注意，您在这里没有强制使用返回类型(因为您必须使用as+integer)，并且像/这样的一些运算符将返回浮点数，因此您可能仍然希望执行运行时检查或将Math.round添加到特定版本的guard中，但这至少可以确保您不会尝试同时使用两个单独的数字类型-假设您有GBP和USD并尝试添加它们，这可能不是您想要的。|3064595|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/gcanti/newtype-ts^0|0|2|6|0|A|6|1B|6|1K|6|0|0|0|17|6|1Z|6|3F|A|3X|7|3F|A|0|0|8|7|0|0|0|3|0|A|1|C|7|M|6|26|7|0|0|7|6|0|0|0|0|P|A|14|1|22|A|2K|5|3M|3|3Q|3|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1L|8|@$D|1M|E|1N|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1O|8|@$D|1P|E|1Q|F|G]|$D|1R|E|1S|F|G]|$D|1T|E|1U|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1V|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1X|8|@$D|1Y|E|1Z|F|G]|$D|20|E|21|F|G]|$D|22|E|23|F|G]|$D|24|E|25|F|G]]|9|@$D|26|E|27|1|28]]|A|$]]|$1|S|3|T|5|6|7|29|8|@$D|2A|E|2B|F|G]]|9|@]|A|$]]|$1|U|3|V|5|L|7|2C|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|2D|8|@$D|2E|E|2F|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2G|8|@$D|2H|E|2I|F|G]|$D|2J|E|2K|F|G]|$D|2L|E|2M|F|G]|$D|2N|E|2O|F|G]]|9|@]|A|$]]|$1|10|3|11|5|L|7|2P|8|@]|9|@]|A|$M|N]]|$1|12|3|13|5|6|7|2Q|8|@$D|2R|E|2S|F|G]]|9|@]|A|$]]|$1|14|3|15|5|L|7|2T|8|@]|9|@]|A|$M|N]]|$1|16|3|17|5|6|7|2U|8|@]|9|@]|A|$]]|$1|18|3|19|5|L|7|2V|8|@]|9|@]|A|$M|N]]|$1|1A|3|1B|5|6|7|2W|8|@$D|2X|E|2Y|F|G]|$D|2Z|E|30|F|G]|$D|31|E|32|F|G]|$D|33|E|34|F|G]|$D|35|E|36|F|G]|$D|37|E|38|F|G]]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|39|8|@]|9|@]|A|$]]]|1D|$1E|$5|1F|1G|1H|A|$1I|1J]]]]

This is the top result on Google for me so I figure I should provide the solutions I found.

<h1>Using <code>bigint</code></h1>

Now that it's 2020 and <code>bigint</code> has been accepted, it deserves a mention. You can simply do the below. Beware that <code>bigint</code>s come with a bigger performance impact compared to a <code>number</code>.

<pre><code>const myNumber: bigint = 10n
</code></pre>

 

<h1>Using a nominal type / tagged type / opaque type</h1>

An alternative is to use a nominal type, but it's arguably less ergonomic and I'm not sure if it's any faster than <code>bigint</code>, but the pattern does generalise to any type, not just <code>number</code>. TypeScript doesn't have "first-class" support for this so you have to do a cheeky hack. There's a library for this called <a href="https://github.com/gcanti/newtype-ts" rel="noreferrer"><code>newtype-ts</code></a> that includes common types like <code>Integer</code> so you might just want to just use that, but I'll explain the workings below.

To start out with we define the <code>integer</code> type.

<pre><code>const TAG = Symbol()
type integer = number &amp; { readonly [TAG]: unique symbol }
</code></pre>

The <code>TAG</code> ensures we have a unique value so that we don't accidentally make an object with the same key, and we make the field a unique symbol too for the same reason. Now, your integer won't actually have this object field but that's fine.

With this you can still add <code>integer</code> to <code>number</code> using <code>+</code>. Not good. So you can enforce type safety on the arguments here by massaging the type system with a function. I'm just gonna call it guard, and again as you can see it isn't specific to <code>integer</code>s – you could make more opaque types and use this again.

<pre><code>type guard = &lt;A&gt;(f: (...ns: Array&lt;A&gt;) =&gt; A, ...ns: Array&lt;A&gt;) =&gt; A
const guard: guard = (f, ...ns) =&gt; f(...ns)
</code></pre>

If you try to call that with a <code>number</code>

<pre><code>const bad: integer = guard((a, b) =&gt; a + b as integer, myCoolInteger, 10)
</code></pre>

you'll get an error like below

<pre><code>Argument of type '10' is not assignable to parameter of type 'integer'.
 Type '10' is not assignable to type '{ readonly [TAG]: unique symbol; }'.(2345)
</code></pre>

Note that you aren't enforcing the return type here (because you have to use <code>as integer</code>) and some operators like <code>/</code> will return floating point numbers so you probably still want to do runtime checks or add a <code>Math.round</code> to a specialised version of <code>guard</code>, but this will at least ensure you're not trying to use two separate numeric types together – imagine you have <code>GBP</code> and <code>USD</code> and try to add those, that would likely not be what you intended.

blocks|key|208331|text|AssemblyScript支持整数值(使用其asm.js后端)。您可以使用--jsFile生成JavaScript文件。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|208332|要手动执行此操作，您可以通过添加%7C+0来强制将值设置为整数。|208333|这提高了性能，因为浏览器引擎现在能够使用整数，而整数在操作中比浮点数更快。|208334|假设你打算这样写：|208335|function+add(a:+i32,+b:+i32)+{
++return+a+%2B+b
}|code-block|syntax|javascript|208336|您应该将其编写为以下代码|208337|type+i32+=+number
function+add(a:+i32,+b:+i32)+{
++a+=+a+%7C+0
++b+=+b+%7C+0
++return+a+%2B+b
}|208338|或者在JavaScript中(这是asc+--jsFile生成的)|208339|function+add(a,+b)+{
++a+=+a+%7C+0
++b+=+b+%7C+0
++return+a+%2B+b
}|208340|对于类属性：|208341|type+i32+=+number
class+MyClass+{
++a:+i32+=+a+%7C+0
}|208342|entityMap^0|12|8|0|G|3|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1A|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1B|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1C|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|T|5|N|7|1E|8|@]|D|@]|E|$O|P]]|$1|U|3|V|5|6|7|1F|8|@]|D|@]|E|$]]|$1|W|3|X|5|N|7|1G|8|@]|D|@]|E|$O|P]]|$1|Y|3|Z|5|6|7|1H|8|@]|D|@]|E|$]]|$1|10|3|11|5|N|7|1I|8|@]|D|@]|E|$O|P]]|$1|12|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|13|$]]

AssemblyScript supports integer values (with its asm.js backend). You can generate a JavaScript file using <code>--jsFile</code>.
To do it manually, you can force a value to be an integer by adding <code>| 0</code>.
This improves the performance because the browser engine is now able to use integers, which are faster than floats in the operations.
Say you intend to write:
<pre><code>function add(a: i32, b: i32) {
 return a + b
}
</code></pre>
You should write it as the following
<pre><code>type i32 = number
function add(a: i32, b: i32) {
 a = a | 0
 b = b | 0
 return a + b
}
</code></pre>
or in JavaScript (this is what asc --jsFile generates)
<pre><code>function add(a, b) {
 a = a | 0
 b = b | 0
 return a + b
}
</code></pre>
For class properties:
<pre><code>type i32 = number
class MyClass {
 a: i32 = a | 0
}
</code></pre>

I'm experimenting with <code>TypeScript</code>, and in the process of creating a class with an <code>ID</code> field that should be an <code>integer</code>, I have gotten a little confused.
First off, in Visual Studio 2012 with the TypeScript plugin, I see <code>int</code> in the intelliSense list of types. But I get a compile error that says:
<blockquote>
the name 'int' does not exist in the current scope.
</blockquote>
I reviewed the language specs and see only the following primitive types: <code>number</code>, <code>string</code>, <code>boolean</code>, <code>null</code>, and <code>undefined</code>. No <code>integer</code> type.
So, I'm left with two questions:
<ol>
<li>How should I indicate to users of my class that a particular field is not just a <code>number</code> but an <code>integer</code> (and never a <code>floating</code> point or <code>decimal</code> number)?
</li>
<li>Why do I see <code>int</code> in the intellisense list if it's not a valid type?
</li>
</ol>
Update: All the answers I've gotten so far are about how <code>JavaScript</code> doesn't have an int type, it would be hard to enforce an <code>int</code> type at runtime... I know all that. I am asking if there is a <code>TypeScript</code> way to provide an annotation to users of my class that this field should be an <code>integer</code>. Perhaps a comment of some particular format?

How do you specify that a class property is an integer?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在试验TypeScript，在创建一个带有ID字段的类的过程中，我有点困惑了。首先，在带有TypeScript插件的Visual Studio2012中，我在intelliSense类型列表中看到了int。但是我得到了一个编译错误，它说：名称'int‘在当前作用域内不存在。我查看了语言规范，只看到以下原始类型：nu...

问如何指定一个类属性是一个整数？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何指定一个类属性是一个整数？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何指定一个类属性是一个整数？
EN