blocks|key|125841|text|我不知道您的配置文件是什么样子，但最明显的是json文件，尽管我会使用json+schema来验证文件是否符合该模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|125842|下面是json模式v4文档：http://json-schema.org/documentation.html|offset|length|125843|下面是如何测试它的一个示例：https://github.com/fge/json-schema-validator|125844|当然，您必须编写基于接口的模式，但不能直接使用它们。|125845|entityMap|0|LINK|mutability|MUTABLE|url|http://json-schema.org/documentation.html|1|https://github.com/fge/json-schema-validator^0|0|E|15|0|0|E|18|1|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@$D|V|E|W|1|X]]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]]]

I don't know how your configuration file looks like, but most obvious would be json file, though I would go with json schema to validate if file fits the schema or not.

Here's json schema v4 documentation: <a href="http://json-schema.org/documentation.html" rel="nofollow">http://json-schema.org/documentation.html</a>

And one of examples how you could test it: <a href="https://github.com/fge/json-schema-validator" rel="nofollow">https://github.com/fge/json-schema-validator</a>

Of course you have to write your schema based on interfaces, but you can't use them directly.

blocks|key|2680665|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2680666|号|blockquote|2680667|2680668|目前，类型仅在开发和编译时使用。类型信息不会以任何方式转换为编译后的JavaScript代码。|2680669|2680670|来自https://stackoverflow.com/a/16016688/318557，正如@JasonEvans所指出的那样|offset|length|2680671|自2015年6月以来，TypeScript+repo中有一个关于此问题的公开问题：https://github.com/microsoft/TypeScript/issues/3628|2680672|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/16016688/318557|1|https://github.com/microsoft/TypeScript/issues/3628^0|0|0|0|0|0|2|17|0|0|15|1F|1|0^^$0|@$1|2|3|-4|4|5|6|X|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|Y|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|Z|7|@]|8|@]|9|$]]|$1|E|3|F|4|5|6|10|7|@]|8|@]|9|$]]|$1|G|3|-4|4|5|6|11|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|12|7|@]|8|@$J|13|K|14|1|15]]|9|$]]|$1|L|3|M|4|5|6|16|7|@]|8|@$J|17|K|18|1|19]]|9|$]]|$1|N|3|-4|4|5|6|1A|7|@]|8|@]|9|$]]]|O|$P|$4|Q|R|S|9|$T|U]]|V|$4|Q|R|S|9|$T|W]]]]

<blockquote>
 No.
 
 Currently, types are used only during development and compile time.
 The type information is not translated in any way to the compiled
 JavaScript code.
</blockquote>

From <a href="https://stackoverflow.com/a/16016688/318557">https://stackoverflow.com/a/16016688/318557</a>, as pointed out by @JasonEvans

There is an open issue since Jun 2015 about this in the TypeScript repo: <a href="https://github.com/microsoft/TypeScript/issues/3628" rel="noreferrer">https://github.com/microsoft/TypeScript/issues/3628</a>

blocks|key|2680694|text|可以。您可以使用我之前发布的TypeScript编译器的增强版本在运行时执行此检查。您可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2680695|export+interface+Person+{
++++name:+string;
++++surname:+string;
++++age:+number;
}

let+personOk+=+{+name:+"John",+surname:+"Doe",+age:+36+};
let+personNotOk+=+{+name:+22,+age:+"x"+};

//+YES.+Now+you+CAN+use+an+interface+as+a+type+reference+object.
console.log("isValid(personOk):++"+%2B+isValid(personOk,+Person)+%2B+"\n");
console.log("isValid(personNotOk):++"+%2B+isValid(personNotOk,+Person)+%2B+"\n");|code-block|syntax|javascript|2680696|这是输出：|2680697|isValid(personOk):++true

Field+name+should+be+string+but+it+is+number
isValid(personNotOk):++false|2680698|请注意，isValid函数在中以递归方式工作，因此您也可以使用它来验证嵌套对象。您可以找到完整的工作示例here|CODE|2680699|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/pcan/reflec-ts-examples/tree/master/simple-validator^0|0|3|0|0|0|0|4|7|D|1|1G|4|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|15|8|@$9|16|A|17|B|Q]|$9|18|A|19|B|C]]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|R|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|S|$T|$5|U|V|W|E|$X|Y]]]]

Yes. You can do this check at runtime by using an enhanced version of the TypeScript compiler that I released a few time ago. You can do something like the following:

<pre><code>export interface Person {
 name: string;
 surname: string;
 age: number;
}

let personOk = { name: "John", surname: "Doe", age: 36 };
let personNotOk = { name: 22, age: "x" };

// YES. Now you CAN use an interface as a type reference object.
console.log("isValid(personOk): " + isValid(personOk, Person) + "\n");
console.log("isValid(personNotOk): " + isValid(personNotOk, Person) + "\n");
</code></pre>

and this is the output:

<pre><code>isValid(personOk): true

Field name should be string but it is number
isValid(personNotOk): false
</code></pre>

Please note that the <code>isValid</code> function works recursively, so you can use it to validate nested objects, too. You can find the full working example <a href="https://github.com/pcan/reflec-ts-examples/tree/master/simple-validator" rel="nofollow noreferrer">here</a>

blocks|key|2892597|text|我怀疑TypeScript+(明智地)遵守了卷曲定律，Typescript是一个转译器，而不是一个对象验证器。也就是说，我也认为typescript接口会造成糟糕的对象验证，因为接口的词汇量(惊人地)有限，并且不能根据其他程序员可能用来区分对象的形状进行验证，例如数组长度、属性数量、模式属性等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2892598|在使用非TypeScript代码中的对象时，我使用JSONSchema验证包(如AJV+)进行运行时验证，并使用.d.ts文件生成器(如DTSgenerator或DTS-generator)从我的JSONshcema编译TypeScript类型定义。|offset|length|2892599|主要的注意事项是，由于JSONschemata能够描述无法通过typescript+(例如patternProperties)区分的形状，因此它不是从JSON+schema到.t.ds的一对一转换，在使用此类JSON+schema时，您可能必须对生成的.d.ts文件进行一些手动编辑。|2892600|也就是说，因为其他程序员可能会使用像数组长度这样的属性来推断对象类型，所以我习惯于使用枚举来区分TypeScript编译器可能会混淆的类型，以防止转换器接受使用一种类型而不是另一种类型，如下所示：|2892601|[MyTypes.yaml]

definitions:+
++++type-A:+
++++++++type:+object
++++++++properties:
++++++++++++type:
++++++++++++++++enum:
++++++++++++++++-+A
++++++++++++foo:+
++++++++++++++++type:+array
++++++++++++++++item:+string
++++++++++++++++maxLength:+2
++++type-B:+
++++++++type:+object
++++++++properties:
++++++++++++type:
++++++++++++++++enum:
++++++++++++++++-+B
++++++++++++foo:+
++++++++++++++++type:+array
++++++++++++++++item:+string
++++++++++++++++minLength:+3
++++++++items:+number|code-block|syntax|javascript|2892602|它会生成一个.d.ts文件，如下所示：|style|CODE|2892603|[MyTypes.d.ts]

interface+typeA{
++++type:+"A";
++++foo:+string[];
}

interface+typeB{
++++type:+"B";
++++foo:+string[];
}|2892604|entityMap|0|LINK|mutability|MUTABLE|url|https://spacetelescope.github.io/understanding-json-schema/structuring.html|1|https://www.npmjs.com/package/ajv|2|https://www.npmjs.com/package/dtsgenerator|3|https://www.npmjs.com/package/dts-generator|4|https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-objects^0|0|P|A|0|14|3|1|1W|C|2|29|D|3|0|19|H|4|0|0|0|6|5|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@$D|1C|E|1D|1|1E]|$D|1F|E|1G|1|1H]|$D|1I|E|1J|1|1K]|$D|1L|E|1M|1|1N]]|A|$]]|$1|F|3|G|5|6|7|1O|8|@]|9|@$D|1P|E|1Q|1|1R]]|A|$]]|$1|H|3|I|5|6|7|1S|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1T|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1U|8|@$D|1V|E|1W|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|L|7|1X|8|@]|9|@]|A|$M|N]]|$1|U|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]|14|$5|X|Y|Z|A|$10|15]]|16|$5|X|Y|Z|A|$10|17]]|18|$5|X|Y|Z|A|$10|19]]]]

I suspect that TypeScript is (wisely) adhering to Curly's Law, and Typescript is a transpiler, not an object validator. That said, I also think that typescript interfaces would make for lousy object validation, because interfaces have a (wonderfully) limited vocabulary and can't validate against shapes that other programmers may use to distinguish objects, such as array length, number of properties, pattern properties, etc. 

When consuming objects from non-typescript code, I use a <a href="https://spacetelescope.github.io/understanding-json-schema/structuring.html" rel="noreferrer">JSONSchema</a> validation package, such as <a href="https://www.npmjs.com/package/ajv" rel="noreferrer">AJV</a>, for run-time validation, and a .d.ts file generator (such as <a href="https://www.npmjs.com/package/dtsgenerator" rel="noreferrer">DTSgenerator</a> or <a href="https://www.npmjs.com/package/dts-generator" rel="noreferrer">DTS-generator</a>) to compile TypeScript type definitions from my JSONshcema. 

The major caveat is that because JSONschemata are capable of describing shapes that cannot be distinguished by typescript (such as <a href="https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-objects" rel="noreferrer">patternProperties</a>), it's not a one-to-one translation from JSON schema to .t.ds, and you may have to do some hand editing of generated .d.ts files when using such JSON schemata.

That said, because other programmers may use properties like array length to infer object type, I'm in the habit of distinguishing types that could be confused by the TypeScript compiler using enum's to prevent the transpiler from accepting use of one type in place of the other, like so: 

<pre><code>[MyTypes.yaml]

definitions: 
 type-A: 
 type: object
 properties:
 type:
 enum:
 - A
 foo: 
 type: array
 item: string
 maxLength: 2
 type-B: 
 type: object
 properties:
 type:
 enum:
 - B
 foo: 
 type: array
 item: string
 minLength: 3
 items: number
</code></pre>

Which generates a <code>.d.ts</code> file like so: 

<pre><code>[MyTypes.d.ts]

interface typeA{
 type: "A";
 foo: string[];
}

interface typeB{
 type: "B";
 foo: string[];
}
</code></pre>

blocks|key|2680757|text|“有”一种方法，但你必须自己实现它。它被称为“用户定义的类型保护”，看起来像这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2680758|interface+Test+{
++++prop:+number;
}

function+isTest(arg:+any):+arg+is+Test+{
++++return+arg+&&+arg.prop+&&+typeof(arg.prop)+==+'number';
}|code-block|syntax|javascript|2680759|当然，isTest函数的实际实现完全取决于您，但好的方面是它是一个实际的函数，这意味着它是可测试的。|offset|length|style|CODE|2680760|现在，在运行时，您可以使用isTest()来验证对象是否遵守接口。在编译时，typescript会采取保护措施，并按预期处理后续使用，即：|2680761|let+a:any+=+{+prop:+5+};

a.x;+//ok+because+here+a+is+of+type+any

if+(isTest(a))+{
++++a.x;+//error+because+here+a+is+of+type+Test
}|2680762|更深入的解释在这里：https://basarat.gitbook.io/typescript/type-system/typeguard|2680763|entityMap|0|LINK|mutability|MUTABLE|url|https://basarat.gitbook.io/typescript/type-system/typeguard^0|0|0|3|6|0|D|8|0|0|A|1N|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@$I|16|J|17|K|L]]|9|@]|A|$]]|$1|O|3|P|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|19|8|@]|9|@$I|1A|J|1B|1|1C]]|A|$]]|$1|S|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

There &quot;is&quot; a way, but you have to implement it yourself. It's called a &quot;User Defined Type Guard&quot; and it looks like this:
<pre><code>interface Test {
 prop: number;
}

function isTest(arg: any): arg is Test {
 return arg &amp;&amp; arg.prop &amp;&amp; typeof(arg.prop) == 'number';
}
</code></pre>
Of course, the actual implementation of the <code>isTest</code> function is totally up to you, but the good part is that it's an actual function, which means it's testable.
Now at runtime you would use <code>isTest()</code> to validate if an object respects an interface. At compile time typescript picks up on the guard and treats subsequent usage as expected, i.e.:
<pre><code>let a:any = { prop: 5 };

a.x; //ok because here a is of type any

if (isTest(a)) {
 a.x; //error because here a is of type Test
}
</code></pre>
More in-depth explanations here: <a href="https://basarat.gitbook.io/typescript/type-system/typeguard" rel="noreferrer">https://basarat.gitbook.io/typescript/type-system/typeguard</a>

blocks|key|122926|text|是的，有一个https://github.com/gcanti/io-ts库可以做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|122927|想法很简单，将简单的属性检查组合成更复杂的对象检查|122928|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/gcanti/io-ts^0|6|V|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

yes, there is a lib that does it <a href="https://github.com/gcanti/io-ts" rel="nofollow noreferrer">https://github.com/gcanti/io-ts</a>

the idea is simple, have simple checks for properties composed into more complex checks for objects

blocks|key|2680850|text|这是一个很好的方法。您可以使用typescript-json-schema将TypeScript接口转换为JSON+schema，例如|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2680851|typescript-json-schema+--required+--noExtraProps+\
++-o+YOUR_SCHEMA.json+YOUR_CODE.ts+YOUR_INTERFACE_NAME|code-block|syntax|javascript|2680852|然后在运行时使用ajv等JSON+schema验证器验证数据。|2680853|const+fs+=+require('fs');
const+Ajv+=+require('ajv');

//+Load+schema
const+schema+=+JSON.parse(fs.readFileSync('YOUR_SCHEMA.json',+{encoding:"utf8"}));
const+ajv+=+new+Ajv();
ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json'));
var+validator+=+ajv.compile(schema);

if+(!validator({"hello":+"world"}))+{
++console.log(validator.errors);
}|2680854|entityMap|0|LINK|mutability|MUTABLE|url|https://www.npmjs.com/package/typescript-json-schema|1|https://www.npmjs.com/package/ajv^0|F|M|0|0|0|8|3|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

Here's a good way. You can convert a TypeScript interface to JSON schema using <a href="https://www.npmjs.com/package/typescript-json-schema" rel="noreferrer">typescript-json-schema</a>, e.g.

<pre class="lang-bash prettyprint-override"><code>typescript-json-schema --required --noExtraProps \
 -o YOUR_SCHEMA.json YOUR_CODE.ts YOUR_INTERFACE_NAME
</code></pre>

Then validate data at runtime using a JSON schema validator such as <a href="https://www.npmjs.com/package/ajv" rel="noreferrer">ajv</a>, e.g.

<pre class="lang-js prettyprint-override"><code>const fs = require('fs');
const Ajv = require('ajv');

// Load schema
const schema = JSON.parse(fs.readFileSync('YOUR_SCHEMA.json', {encoding:"utf8"}));
const ajv = new Ajv();
ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json'));
var validator = ajv.compile(schema);

if (!validator({"hello": "world"})) {
 console.log(validator.errors);
}
</code></pre>

blocks|key|2680889|text|这里有另一个替代方案，专门针对这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2680890|ts-interface-builder是一个在构建时在TypeScript文件(例如foo.ts)上运行的工具，用于构建运行时描述符(例如foo-ti.ts)。|offset|length|style|CODE|2680891|ts-interface-checker在运行时使用它们来验证对象。例如。|2680892|import+{createCheckers}+from+'ts-interface-checker';
import+fooDesc+from+'foo-ti.ts';
const+checkers+=+createCheckers(fooDesc);

checkers.EngineConfig.check(someObject);+++//+Succeeds+or+throws+an+informative+error
checkers.PathPlannerConfig.check(someObject);|code-block|syntax|javascript|2680893|您可以使用strictCheck()方法来确保没有未知的属性。|2680894|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/gristlabs/ts-interface-builder|1|https://github.com/gristlabs/ts-interface-checker^0|0|17|6|1Y|9|0|K|0|0|0|K|1|0|0|5|D|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@$D|16|E|17|1|18]]|A|$]]|$1|H|3|I|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|J|3|K|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1E|8|@$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]]]

Here is another alternative, specifically for this:

<a href="https://github.com/gristlabs/ts-interface-builder" rel="noreferrer">ts-interface-builder</a> is a tool you run at build time on your TypeScript file (e.g. <code>foo.ts</code>) to build runtime descriptors (e.g. <code>foo-ti.ts</code>).

<a href="https://github.com/gristlabs/ts-interface-checker" rel="noreferrer">ts-interface-checker</a> uses these to validate objects at runtime. E.g.

<pre><code>import {createCheckers} from 'ts-interface-checker';
import fooDesc from 'foo-ti.ts';
const checkers = createCheckers(fooDesc);

checkers.EngineConfig.check(someObject); // Succeeds or throws an informative error
checkers.PathPlannerConfig.check(someObject);
</code></pre>

You can use <code>strictCheck()</code> method to ensure there are no unknown properties.

blocks|key|2680933|text|我知道这个问题已经过时了，但我刚刚使用装饰器为JSON对象和typescript编写了自己的验证器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2680934|此处提供：ts-json-object。|offset|length|2680935|自从这个问题被提出以来，Typescript已经有了一些进展，现在已经有了实验性的功能，允许记录类型信息以供以后使用。|2680936|下面的示例验证@required和@optional属性，但也验证它们的类型，即使在验证表示法中没有提到该类型。|style|CODE|2680937|示例：|2680938|import+{JSONObject,required,optional,lt,gte}+from+'ts-json-object'

class+Person+extends+JSONObject+{
++++@required+//+required
++++name:+string
++++@optional+//+optional!
++++@lt(150)+//+less+than+150
++++@gte(0)+//+Greater+or+equal+to+0
++++age?:+number
}

let+person+=+new+Person({
+name:+'Joe'
})+//+Ok
let+person+=+new+Person({
})+//+Will+throw+a+TypeError,+because+name+is+required
let+person+=+new+Person({
+name:+123
})+//+Will+throw+a+TypeError,+because+name+must+be+a+string|code-block|syntax|javascript|2680939|具有许多其他功能，如自定义验证等。|2680940|entityMap|0|LINK|mutability|MUTABLE|url|https://www.npmjs.com/package/ts-json-object^0|0|5|E|0|0|0|7|9|H|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@$D|19|E|1A|J|K]|$D|1B|E|1C|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1D|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1E|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1F|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

I realize this question is old, but I just wrote my own validator for JSON objects and typescript, for this exact purpose, using decorators. 
Available here: <a href="https://www.npmjs.com/package/ts-json-object" rel="nofollow noreferrer">ts-json-object</a>. 
Typescript has moved on a bit since this question was asked, and now has experimental features allowing recording of type information for later usage. 
The following example validates <code>@required</code> and <code>@optional</code> properties, but also validates their type, even though there is no mentioning of the type in the validation notation.

Example:

<pre class="lang-js prettyprint-override"><code>import {JSONObject,required,optional,lt,gte} from 'ts-json-object'

class Person extends JSONObject {
 @required // required
 name: string
 @optional // optional!
 @lt(150) // less than 150
 @gte(0) // Greater or equal to 0
 age?: number
}

let person = new Person({
 name: 'Joe'
}) // Ok
let person = new Person({
}) // Will throw a TypeError, because name is required
let person = new Person({
 name: 123
}) // Will throw a TypeError, because name must be a string
</code></pre>

Has many other features such as custom validations, etc.

blocks|key|125929|text|我刚刚做了一个简单的站点，用于从typescript接口生成JavaScript验证代码。注意：仔细阅读限制。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|125930|https://ts-interface-validator.vercel.app/|125931|entityMap|0|LINK|mutability|MUTABLE|url^0|19|3|0|0|16|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@$9|S|A|T|1|U]]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|G]]]]

Just made simple site for generating JavaScript validation code out of typescript interfaces.
Note: Read the limitation carefully.
<a href="https://ts-interface-validator.vercel.app/" rel="nofollow noreferrer">https://ts-interface-validator.vercel.app/</a>

blocks|key|123001|text|为了补充“使用这个库”的答案，下面是我的答案:我创建了一个名为ts-data-checker的包，它在运行时运行TypeScript语言服务来检查JSON：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|123002|import+{+checker+}+from+"ts-data-checker";

export+interface+PathPlannerConfig+{
++++nbMaxIter?:+number;
++++nbIterPerChunk?:+number;
++++heuristic?:+string;
}

const+{+checkJson+}+=+checker("PathPlannerConfig",+"./nameofthisfile");

if+(checkJson(`{+"nbMaxIter":+1+}`))+{
++++console.log('valid!');
}|code-block|syntax|javascript|123003|entityMap^0|V|F|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

To pile on the &quot;use this lib&quot; answers, here is mine: I've created a package called <code>ts-data-checker</code> which runs TypeScript language service at runtime to check JSON:
<pre class="lang-js prettyprint-override"><code>import { checker } from &quot;ts-data-checker&quot;;

export interface PathPlannerConfig {
 nbMaxIter?: number;
 nbIterPerChunk?: number;
 heuristic?: string;
}

const { checkJson } = checker(&quot;PathPlannerConfig&quot;, &quot;./nameofthisfile&quot;);

if (checkJson(`{ &quot;nbMaxIter&quot;: 1 }`)) {
 console.log('valid!');
}
</code></pre>

I load a JSON configuration file at runtime, and use an interface to define its expected structure:

<pre><code>interface EngineConfig {
 pathplanner?: PathPlannerConfig;
 debug?: DebugConfig;
 ...
}

interface PathPlannerConfig {
 nbMaxIter?: number;
 nbIterPerChunk?: number;
 heuristic?: string;
}

interface DebugConfig {
 logLevel?: number;
}

...
</code></pre>

This makes it convenient to access the various properties since I can use autocompletions etc.

Question: is there a way to use this declaration to check the correctness of the file I load? ie that I do not have unexpected properties?

Check if an object implements an interface at runtime with TypeScript

TypeScript

编译器

JSON

我在运行时加载了一个JSON配置文件，并使用一个接口来定义其预期的结构：interface EngineConfig {    pathplanner?: PathPlannerConfig;    debug?: DebugConfig;    ...}interface PathPlannerConfig {   ...

问检查对象是否在运行时使用TypeScript实现了接口
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问检查对象是否在运行时使用TypeScript实现了接口EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问检查对象是否在运行时使用TypeScript实现了接口
EN